diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..61f5e73
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,16 @@
+# Copy to `.env` (gitignored) and fill in. `config/settings.py` reads this file as well as the
+# process environment, so anything set here reaches the CLI without exporting it in your shell.
+#
+# Nothing here is needed to run `make check`, `make test-cpp` or the Android JVM suites. These are
+# only for the operations that talk to the Hugging Face Hub.
+
+# Personal Hub token — read access for pulling gated/private BASE models during an export, and write
+# access to your own namespace.
+#
+# Needed by:  mobiletransformers export --model <gated-id>
+#             mobiletransformers pull / push  (personal repos)
+#             make device-hub-test REPO=<you>/<name>
+#             the sample app's Install button, baked in at build time as BuildConfig.HF_TOKEN
+#             (see MobileTransformersApp/build.gradle.kts — `make android-build` does NOT source
+#             this file, so export it yourself: `set -a && . ./.env && set +a`)
+HF_TOKEN=
\ No newline at end of file
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 0000000..ec11d90
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,118 @@
+# The badge workflow: the checks that are cheap, deterministic and meaningful on a bare runner.
+#
+# Separate from `ci.yml` on purpose. That workflow stages everything including `export-smoke` (which
+# installs torch + optimum) and `android-assemble` (which SELF-SKIPS without the vendored native
+# deps). Neither belongs behind a status badge: one is slow enough to discourage pushing, and the
+# other would report green by skipping — a badge that is green when nothing ran is worse than no
+# badge, because it is trusted.
+#
+# So this file runs only what a hosted runner can do honestly, in a couple of minutes, with no model
+# downloads, no NDK, no vendored binaries and no credentials:
+#
+#   python   -> lint + typecheck + enum parity + guards + docs gate + the core unit suite
+#   cpp      -> host googletests over the ORT-free headers
+#   kotlin   -> SDK + app JVM unit tests (Kotlin compiler + Android SDK stubs; no native libs)
+#
+# Every job here was verified against a SIMULATED FRESH CLONE on 2026-08-17 — the tracked files only,
+# with no `third_party/wheels/` wheel, no `jniLibs`/`aarLibs`, no `.env` and no device. That run is
+# what caught `make check` failing on a bare machine: `[tool.uv.sources]` points
+# `onnxruntime-training` at a local path, and a bare `uv run` validates it before executing, so
+# `make lint` died on a missing 632 MB training wheel. The Makefile now uses `uv run --frozen`.
+# Without that fix this workflow would have gone red on its first run.
+#
+# `ci.yml` stays `workflow_dispatch`-only and keeps the heavier stages. Anything needing the native
+# dependencies, a device or a token belongs there, not here.
+name: checks
+
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  # Unqualified on purpose: a pull request from ANY branch runs these checks, which is what makes
+  # dropping work branches from the `push` list above safe — the badge tracks `main`, and everything
+  # merging into it is still gated.
+  pull_request: {}
+  workflow_dispatch: {}
+
+# A new push supersedes an in-flight run of the same ref: the badge should reflect the tip, and
+# queued runs of superseded commits cost minutes for an answer nobody reads.
+concurrency:
+  group: checks-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  python:
+    name: python (lint, typecheck, parity, guards, tests)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      # The core/dev profile: no onnxruntime provider, no torch, no model downloads. `--frozen` so a
+      # drifted lock fails here rather than silently resolving something else.
+      - name: Sync core + dev (Python 3.10)
+        run: uv sync --frozen --group dev --python 3.10
+      - name: Lint
+        run: make lint
+      - name: Typecheck
+        run: make typecheck
+      - name: Enum/schema parity (Python source of truth vs Kotlin + C++ mirrors)
+        run: make parity
+      - name: Guards (secrets, registry dispatch, plan identifiers, machine paths)
+        run: make guard
+      - name: Docs gate (markdown links, CLI table, Kotlin facade symbols)
+        # `--frozen` for the reason spelled out at the top of this file: a bare `uv run` validates
+        # the local-path `onnxruntime-training` source before running anything, and that wheel is
+        # git-ignored. Every `uv run` in a workflow carries it — see test_guards.py.
+        run: uv run --frozen pytest tests/unit/test_docs.py -q
+      - name: Unit tests
+        run: make test
+
+  cpp:
+    name: cpp (host googletest)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      # Host toolchain only. The shipping library needs the NDK and ONNX Runtime, but the headers
+      # carrying the fail-closed logic are ORT-free and testable anywhere.
+      - name: C++ host unit tests
+        run: make test-cpp
+
+  kotlin:
+    name: kotlin (SDK JVM unit tests)
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ runner.os }}-${{ hashFiles('android/MobileTransformers/**/*.gradle.kts', 'android/MobileTransformers/gradle/libs.versions.toml') }}
+      # JVM-only: no NDK, no vendored native libs — both modules were confirmed to build and test
+      # against a tree with an empty `jniLibs`/`aarLibs`. The app module is included because it holds
+      # the navigation, download-state and PEFT-label suites, which are exactly the logic that has
+      # broken from under the UI before.
+      - name: JVM unit tests (SDK + sample app)
+        working-directory: android/MobileTransformers
+        run: ./gradlew :MobileTransformers:testDebugUnitTest :MobileTransformersApp:testDebugUnitTest
+      - name: Upload test report on failure
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: kotlin-test-report
+          path: |
+            android/MobileTransformers/MobileTransformers/build/reports/tests/testDebugUnitTest
+            android/MobileTransformers/MobileTransformersApp/build/reports/tests/testDebugUnitTest
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..387ff11
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,171 @@
+# Staged CI. Cheapest-first so failures surface fast:
+#
+#   fast          -> lint + typecheck + parity + guards (F2) + core unit tests (every PR, minutes)
+#   kotlin-test   -> :MobileTransformers JVM unit tests                        (every PR, no NDK)
+#   cpp-test      -> host googletest over the ORT-free C++ headers              (every PR, no NDK)
+#   export-smoke  -> export profile installed; export/package/manifest wiring  (every PR, < ~10 min)
+#   android-*     -> Gradle assembleDebug for both modules                     (every PR, self-skips*)
+#
+# The Kotlin JVM suite needs only the Kotlin compiler + Android SDK stubs — NOT the vendored native
+# libraries — so it runs on every PR.
+#
+# * The Android ASSEMBLE job needs the git-ignored vendored native deps. On a bare hosted runner those
+#   are absent, so the job SELF-SKIPS with a warning rather than failing spuriously (mirrors
+#   .github/workflows/ort-training-smoke.yml). How the native deps reach CI — rebuild vs. cached
+#   artifact vs. private storage — is still an open decision. See docs/RELEASE_CHECKLIST.md.
+#
+# No PR job downloads a large model (assert via logs): fast/export-smoke use only tiny fixtures; the
+# generate_artifacts + 1-token desktop leg + device train->merge->generate->RAG run in device.yml
+# (manual + nightly), never on a PR.
+
+name: ci
+
+# DISABLED (2026-08-08): automatic triggers removed — these workflows are not in use yet, and the
+# native-dependency provisioning question they depend on is unresolved, so every run either self-skips
+# or fails for reasons unrelated to the change under test. A red badge nobody acts on is worse than no
+# badge: it trains everyone to ignore CI.
+#
+# They remain fully intact and MANUALLY runnable (Actions -> select workflow -> "Run workflow").
+# To re-enable, restore the original `on:` block recorded directly below.
+#
+# ORIGINAL:
+#   on:
+#     push:
+#       branches: [main]
+#       tags: ['v*']
+#     pull_request: {}
+
+on:
+  workflow_dispatch: {}
+
+jobs:
+  fast:
+    name: fast (lint + typecheck + parity + tests)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Sync core + dev (Python 3.10, no onnxruntime provider)
+        run: uv sync --frozen --group dev --python 3.10
+      - name: Lint
+        run: make lint
+      - name: Typecheck
+        run: make typecheck
+      - name: Parity gate (F2 — enums/schemas vs. Kotlin/C++ mirrors)
+        run: make parity
+      - name: Guards (secret reads, registry dispatch, plan identifiers, machine paths)
+        run: make guard
+      - name: Docs gate (markdown links, CLI table, Kotlin facade symbols)
+        # `--frozen` is load-bearing, not a nicety: a bare `uv run` validates every source in the
+        # lock before executing, and `onnxruntime-training` resolves to a git-ignored 662 MB wheel
+        # that no runner has. Without it this step dies on a missing training wheel it never needed.
+        run: uv run --frozen pytest tests/unit/test_docs.py -q
+      - name: Unit tests
+        run: make test
+
+  kotlin-test:
+    name: kotlin-test (SDK JVM unit tests)
+    needs: fast
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ runner.os }}-${{ hashFiles('android/MobileTransformers/**/*.gradle.kts', 'android/MobileTransformers/gradle/libs.versions.toml') }}
+      # JVM-only: no NDK, no vendored native libs. `testDebugUnitTest` compiles Kotlin and runs the
+      # facade/hub/packages/rag/runtime/training suites.
+      - name: SDK JVM unit tests
+        working-directory: android/MobileTransformers
+        run: ./gradlew :MobileTransformers:testDebugUnitTest
+      - name: Upload test report on failure
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: kotlin-test-report
+          path: android/MobileTransformers/MobileTransformers/build/reports/tests/testDebugUnitTest
+
+  cpp-test:
+    name: cpp-test (host googletest, ORT-free headers)
+    needs: fast
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      # Host toolchain only — the shipping library needs the NDK + ONNX Runtime, but handoff_io.h,
+      # constants/merger_variant.h and mem_probe.h are ORT-free and carry the fail-closed logic.
+      - name: C++ host unit tests
+        run: make test-cpp
+
+  export-smoke:
+    name: export-smoke (export/package/manifest wiring)
+    needs: fast
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      # Export profile needs Python >= 3.11 (optimum-onnx pulls onnxruntime >= 1.24). Runs the
+      # export-profile tests that self-skip in the fast job's core env.
+      - name: Sync export profile + dev (Python 3.12)
+        run: uv sync --extra export --group dev --python 3.12
+      - name: Export/package/manifest smoke
+        run: make test-smoke
+
+  android-assemble:
+    name: android-assemble (self-skips without vendored native deps)
+    needs: fast
+    runs-on: ubuntu-latest
+    timeout-minutes: 25
+    strategy:
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+      - name: Check for the vendored native deps
+        id: nativedeps
+        working-directory: android/MobileTransformers
+        run: |
+          # jniLibs/ is the only vendored input the native build still needs. aarLibs/ was dropped as a
+          # Gradle dependency (build.gradle.kts documents the .so-from-jniLibs decision) and the
+          # protobuf headers under cpp/includes/ went with weight_serializer.cpp — the flat
+          # per-tensor .bin files are raw external data, so nothing on device parses ONNX protobuf.
+          if [ -d MobileTransformers/src/main/jniLibs ]; then
+            echo "present=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "present=false" >> "$GITHUB_OUTPUT"
+            echo "::warning::Vendored native libs (src/main/jniLibs) absent; skipping Android assemble. Run scripts/fetch_native_deps.sh, or see docs/ARCHITECTURE.md."
+          fi
+      - name: Assemble SDK + sample app (debug)
+        if: steps.nativedeps.outputs.present == 'true'
+        working-directory: android/MobileTransformers
+        run: ./gradlew :MobileTransformers:assembleDebug :MobileTransformersApp:assembleDebug
+
+      # On a tag, also produce the release AAR. scripts/android_build_aar.sh verifies that every ABI
+      # directory the AAR ships actually contains libmobiletransformers.so — an AAR with an ABI dir
+      # but no project library fails at System.loadLibrary on the consumer's device.
+      - name: Build the release AAR (tags only)
+        if: steps.nativedeps.outputs.present == 'true' && startsWith(github.ref, 'refs/tags/v')
+        run: scripts/android_build_aar.sh
+      - name: Upload the release AAR (tags only)
+        if: steps.nativedeps.outputs.present == 'true' && startsWith(github.ref, 'refs/tags/v')
+        uses: actions/upload-artifact@v4
+        with:
+          name: mobiletransformers-android-aar
+          path: android/MobileTransformers/MobileTransformers/build/outputs/aar/*-release.aar
diff --git a/.github/workflows/device.yml b/.github/workflows/device.yml
new file mode 100644
index 0000000..bc97b13
--- /dev/null
+++ b/.github/workflows/device.yml
@@ -0,0 +1,98 @@
+# Device / model-zoo pipeline. NEVER runs on a PR — it needs a
+# physical Android device (or device-farm runner) and is long/intensive. Manual
+# (`workflow_dispatch`) only — the nightly `schedule` is commented out below, so do not read the
+# original design as something that currently runs. The end-to-end device leg: train 1 step -> merge -> generate 1 token ->
+# ingest/query 1 RAG doc; then build a small starter zoo and record time/memory as artifacts in the
+# docs/mobile_evaluation.md style.
+#
+# `runs-on` targets a self-hosted, device-attached runner (label `android-device`). Until such a
+# runner is registered this workflow simply never picks up a runner — it does not fail hosted CI.
+
+name: device
+
+# DISABLED (2026-08-08): automatic triggers removed — these workflows are not in use yet, and the
+# native-dependency provisioning question they depend on is unresolved, so every run either self-skips
+# or fails for reasons unrelated to the change under test. A red badge nobody acts on is worse than no
+# badge: it trains everyone to ignore CI.
+#
+# They remain fully intact and MANUALLY runnable (Actions -> select workflow -> "Run workflow").
+# To re-enable, restore the original `on:` block recorded directly below.
+#
+# ORIGINAL:
+#   on:
+#     workflow_dispatch: {}
+#     schedule:
+#       - cron: '17 3 * * *'   # nightly 03:17 UTC
+
+on:
+  workflow_dispatch: {}
+
+jobs:
+  device-e2e:
+    name: device train->merge->generate->RAG (manual)
+    runs-on: [self-hosted, android-device]
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Confirm an attached device
+        run: |
+          adb devices -l | tee adb-devices.txt
+          test "$(adb devices | grep -c 'device$')" -ge 1
+          # Only arm64-v8a ships a complete jniLibs set (see docs/ARCHITECTURE.md "ABI support").
+          abi="$(adb shell getprop ro.product.cpu.abi | tr -d '\r')"
+          echo "device ABI: $abi" | tee -a adb-devices.txt
+          test "$abi" = "arm64-v8a"
+
+      # Export + reshape + push a real package, then run the instrumented suites over it. Every suite
+      # `assumeTrue`-skips without a pushed package, so provisioning must succeed for this job to mean
+      # anything — which is why the skip count is asserted below rather than left to be read by eye.
+      - name: Provision a device package
+        run: make device-package MODEL=${{ inputs.model || 'HuggingFaceTB/SmolLM2-135M-Instruct' }} TRAIN=${{ inputs.train || '1' }}
+
+      - name: Instrumented suites (copy weight-load path)
+        run: |
+          adb shell setprop debug.mtf.mmap_weights 0
+          make device-test
+
+      # Gate 0.2 needs the same four points under the zero-copy path; the toggle is a system property
+      # precisely because an instrumented test cannot set an env var in the process it measures.
+      - name: RSS table (mmap weight-load path)
+        run: |
+          adb shell setprop debug.mtf.mmap_weights 1
+          make device-test || true
+          adb shell setprop debug.mtf.mmap_weights 0
+
+      # A run where everything skipped is not a passing device run. Fail loudly instead of reporting
+      # green on an un-provisioned device — the failure mode this whole workflow exists to prevent.
+      - name: Assert the suites actually ran
+        run: |
+          results="android/MobileTransformers/MobileTransformers/build/outputs/androidTest-results/connected/debug"
+          test -d "$results" || { echo "::error::no instrumented results at $results"; exit 1; }
+          skipped=$(grep -ho '<skipped' "$results"/*.xml | wc -l)
+          total=$(grep -ho '<testcase' "$results"/*.xml | wc -l)
+          echo "instrumented: $total total, $skipped skipped"
+          test "$total" -gt 0
+          test "$skipped" -lt "$total"
+
+      - name: Collect the RSS table
+        if: always()
+        run: |
+          adb pull "/sdcard/Android/data/com.martinkorelic.mobiletransformers.test/files/mt_rss" rss || true
+
+      - name: Upload metrics artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: device-metrics
+          path: |
+            adb-devices.txt
+            rss/
+            android/MobileTransformers/MobileTransformers/build/outputs/androidTest-results/connected/debug/
+          if-no-files-found: warn
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..5f7ee25
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,72 @@
+# Build and publish the documentation site to GitHub Pages.
+#
+# WHY THE OFFICIAL PAGES ACTIONS AND NOT `mkdocs gh-deploy`. The previous, separate docs repository
+# used `gh-deploy --force`, which pushes a built site to a `gh-pages` branch from inside the runner.
+# It silently stopped publishing: four commits — including the one that fixed the site's branding —
+# were merged and never appeared, and nothing went red, because a failed push in that flow does not
+# always fail the step. `configure-pages` + `deploy-pages` publishes an artifact through the Pages
+# API instead: there is no branch to get out of sync, and a failure is a failed job.
+#
+# `--strict` is the point of the build step: it turns an unresolved internal link into a build
+# failure. The docs and the code live in one tree now, so a rename that breaks a link should break
+# the build rather than ship a 404.
+#
+# REQUIRES: Settings -> Pages -> Source = "GitHub Actions" (a one-time repository setting).
+
+name: docs
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/docs.yml'
+  pull_request:
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# A queued deploy should wait for the running one rather than race it, but an in-progress build is
+# still worth finishing — cancelling it would lose the link check on the newer commit.
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: build (mkdocs --strict)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install MkDocs
+        # Deliberately not `uv sync`: the site needs mkdocs and nothing else, and the project's own
+        # profiles carry torch-sized dependencies that have no bearing on rendering markdown.
+        run: pip install mkdocs mkdocs-material
+      - name: Build
+        run: mkdocs build --strict
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+  deploy:
+    # PRs get the link check from `build`, but must not publish. Only main deploys.
+    if: github.event_name != 'pull_request'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/ort-training-smoke.yml b/.github/workflows/ort-training-smoke.yml
new file mode 100644
index 0000000..94b0c21
--- /dev/null
+++ b/.github/workflows/ort-training-smoke.yml
@@ -0,0 +1,51 @@
+# ORT-training toolchain smoke (Gate 0.3): import the source-built wheel and run
+# `generate_artifacts` on the tiny fixture. Proves the train toolchain is alive.
+#
+# NOTE ON WHEEL PROVISIONING: the source-built `onnxruntime-training==1.23.0+cpu` wheel is
+# cp312-only and git-ignored (third_party/wheels/, referenced via [tool.uv.sources]). It is NOT on
+# public PyPI, so a hosted runner has nothing to fetch. Wiring this into the always-on staged
+# pipeline — and deciding HOW the wheel reaches CI (rebuild-in-CI vs. a private index / cached
+# artifact) — is an open decision. Until then this job is `workflow_dispatch`
+# (manual) and self-skips when the wheel is absent, so it never spuriously fails a normal run.
+
+name: ort-training-smoke
+
+# NOT scheduled by design (unchanged 2026-08-08): manual-only, because it needs the source-built
+# ORT-training wheel, which hosted runners do not have. Left as-is while ci.yml/device.yml had
+# their automatic triggers removed — this one never had any.
+on:
+  workflow_dispatch: {}
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Check for the source-built training wheel
+        id: wheel
+        run: |
+          if ls third_party/wheels/onnxruntime_training-*.whl >/dev/null 2>&1; then
+            echo "present=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "present=false" >> "$GITHUB_OUTPUT"
+            echo "::warning::ORT-training wheel absent; skipping smoke. See third_party/onnxruntime/BUILD.md."
+          fi
+
+      - name: Verify wheel checksum matches manifest
+        if: steps.wheel.outputs.present == 'true'
+        run: |
+          expected=$(python -c "import json;print(json.load(open('third_party/onnxruntime/manifest.json'))['wheel']['sha256'])")
+          actual=$(sha256sum third_party/wheels/onnxruntime_training-*.whl | cut -d' ' -f1)
+          test "$expected" = "$actual" || { echo "wheel sha256 mismatch"; exit 1; }
+
+      - name: Sync ort-training-local profile (Python 3.12)
+        if: steps.wheel.outputs.present == 'true'
+        run: uv sync --frozen --python 3.12 --group ort-training-local
+
+      - name: Run the generate_artifacts smoke
+        if: steps.wheel.outputs.present == 'true'
+        run: uv run --python 3.12 --frozen --group ort-training-local pytest tests/integration/test_ort_training_smoke.py -q
diff --git a/.gitignore b/.gitignore
index b6f34b6..47c1667 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,5 +13,28 @@ merged_models/
 data/
 experiment/
 dist/
-.deepeval/
 experiment_results/
+
+# Packaging / restructure
+*.egg-info/
+third_party/wheels/*.whl
+third_party/onnxruntime/build/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.venv-genai-spike/
+
+# Gradle daemon caches (67 files of examples/consumer-app/.gradle were tracked until 2026-08-14)
+.gradle/
+# Implementation plans, audits and per-cycle handoff notes. Working material for whoever is building
+# this, not user documentation — `docs/` is the shipped set. Untracked 2026-08-17 at the owner's
+# request; the directory stays on disk. `tests/unit/test_docs.py` enumerates via `git ls-files`, so
+# its link check drops these automatically rather than by an exclude list.
+agent_docs/
+
+# Generated documentation site (`make docs-build`). Published by CI from source, never committed.
+site/
+
+# Agent/editor local state. Ignored here rather than relying on a personal global ignore file:
+# a contributor without that global rule would otherwise see it as untracked noise in a clean clone.
+.claude/settings.local.json
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..08b1cdb
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,76 @@
+# Changelog
+
+All notable changes to MobileTransformers are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project follows Semantic Versioning from
+v1.0.0 onward.
+
+## [0.2.0] — 17-08-2026
+
+First public release.
+
+### Added
+
+**Host — exporting models**
+
+- One-command export: a Hugging Face checkpoint becomes an ONNX inference graph, a PEFT-enabled
+  training graph with an optimiser, a tokenizer, an optional embedding stage, and a manifest tying
+  them together.
+- **PEFT methods:** LoRA, LoRA-XS, and **MARS** (Multi-Adapter Rank Sharing) — this project's own
+  method, which shares adapter components across layers so trainable parameters grow with rank
+  rather than with depth.
+- Decoder and encoder tasks: text generation, sequence classification, and feature extraction for
+  retrieval.
+- A `mobiletransformers` CLI covering export, packaging, validation, Hub push/pull, adapter
+  conversion and federated aggregation.
+
+**Android SDK**
+
+- `mobiletransformers-android` — an AAR consumable from any app, with a single `fromPretrained`
+  entry point that resolves, downloads, verifies and atomically installs a package.
+- **Generation** — streaming, with a chat template and KV cache, over either of two selectable ONNX
+  Runtime engines.
+- **Fine-tuning** — a real training loop with an optimiser and a live loss curve, surviving the app
+  going to the background.
+- **Merging** — folding a trained adapter back into the inference weights, so the fine-tuned model is
+  the one that then generates.
+- **Retrieval** — chunking, embedding and vector search over documents you supply, with grounded
+  generation that reports its sources before the answer.
+- **Classification** for encoder packages, scored per label.
+- **Tool calling** — a model's answer parsed into a structured call, validated against an allowlist
+  the app owns, and bound to an Android intent. Nothing executes without user consent.
+- **Federated adapter exchange** — export local factors, aggregate on a host, import the average
+  back. Default-off and consent-gated.
+
+All of it runs on the device, with no server and no data leaving the phone.
+
+**Published artifacts**
+
+- **Six model packages** on the Hub under
+  [`mobiletransformers`](https://huggingface.co/mobiletransformers), each shipping both an inference
+  and a training stage — including one exported with MARS.
+- The gitignored native build artifacts are hosted, so a fresh clone can provision itself with
+  `make fetch-native-deps` and no credentials.
+
+**Sample app and documentation**
+
+- A reference app exercising every capability through the public facade only, with navigation that
+  derives from what the loaded package can actually do.
+- A documentation site built from this repository's own `docs/`, and `make doctor` — a preflight
+  report naming every missing prerequisite and the command that fixes it.
+
+### Known issues
+
+- The host gates are green, but nothing in this release is exercised end to end on a device by CI.
+- **arm64-v8a only.** The SDK does not run on a standard x86_64 Android emulator.
+- The training export path is Linux x86_64 and Python 3.12 only, because of the source-built ONNX
+  Runtime Training wheel.
+- The licence is CC BY-NC 4.0, which does not suit a consumable Android library. Relicensing is a
+  rights-holders decision and is the outstanding blocker for v1.0.
+
+### Non-goals
+
+- **GPU/NPU training.** Inference may use an accelerated execution provider; training is CPU-only.
+- **Multimodal training.** Text-generation and encoder tasks only.
+- **Competing with server-side trainers on throughput.** The target is feasibility and privacy on a
+  phone, not tokens/second parity with a datacentre.
+- **On-device engine/facade device parity**, which remains gated on device acceptance runs.
diff --git a/CITATION.cff b/CITATION.cff
index 1f5ad72..be431c9 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -6,6 +6,6 @@ authors:
   - family-names: "Pejović"
     given-names: "Veljko"
 title: "MobileTransformers: An On-Device LLM PEFT Framework for Fine-Tuning and Inference"
-version: 1.0.0
-date-released: 2025-10-18
-url: "https://gitlab.fri.uni-lj.si/lrk/mobiletransformers"
\ No newline at end of file
+version: 0.2.0
+date-released: 2026-08-17
+url: "https://gitlab.fri.uni-lj.si/lrk/mobiletransformers"
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ed6c028
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,190 @@
+# MobileTransformers developer Makefile.
+#
+# Every target is a THIN WRAPPER (<= ~3 lines) over the `mobiletransformers` CLI or Gradle —
+# no build/export logic lives here. `setup*` targets honor the dependency-profile isolation
+# (the onnxruntime-import-colliding profiles can never co-install; each `setup` variant syncs its own
+# environment). CI invokes these targets, not raw commands.
+
+.PHONY: help setup setup-export setup-train setup-genai doctor fetch-native-deps \
+        lint format typecheck parity guard test test-smoke test-train test-jvm test-cpp test-integration check consumer-app \
+        export-model package-model publish-catalog publish-artifacts android-build device-package device-test device-hub-test device-rss device-federated build-aar publish-local docs docs-build docs-serve requirements clean-generated
+
+# Overridable export knobs (used by `export-model`).
+MODEL   ?=
+OUTPUT  ?= build/package
+PEFT    ?= lora
+QUANT   ?= int4
+CONFIG  ?=
+# `package-model` re-emits the manifest of an ALREADY-EXPORTED package; defaults to what export wrote.
+PACKAGE ?= $(OUTPUT)
+# device-package knobs (the script re-applies its own defaults for empty values).
+VARIANT ?= cpu-int4
+TRAIN   ?= 0
+RAG     ?= 1
+# Explicit Optimum task. Empty means auto-select, which never picks `text-classification` —
+# an encoder fine-tune must name it (e.g. TASK=text-classification).
+TASK    ?=
+# The host-side package the federated gateway aggregates against. It must be the SAME export the
+# device holds — `weight_handoff_map.json` is the authority on tensor names/shapes for both sides.
+FED_PKG ?= build/pkg
+# Gradle 8.7 / AGP 8.5.1 need JDK 17.
+#
+# Resolution order, and the order matters: an explicit JAVA_HOME in the environment wins; else a JDK
+# 17+ already on PATH; else Android Studio's bundled JBR at its Linux default. The PATH probe is
+# second rather than absent because the hardcoded path is a *Linux Android Studio* location that
+# exists on exactly one kind of machine — on macOS, on a CI runner, or under any other JDK install it
+# silently resolves to a directory that is not there, and Gradle then reports a Java version error
+# naming neither JAVA_HOME nor this file. `make doctor` reports which branch you are on.
+JAVA_HOME ?= $(shell \
+  if command -v java >/dev/null 2>&1 && \
+     java -version 2>&1 | head -1 | grep -qE '"(1[7-9]|2[0-9])'; then \
+    dirname "$$(dirname "$$(readlink -f "$$(command -v java)")")"; \
+  else echo /opt/android-studio/jbr; fi)
+# `uv run`, but WITHOUT re-resolving the lock.
+#
+# `[tool.uv.sources]` points `onnxruntime-training` at a local path under `third_party/wheels/`, and
+# that wheel is git-ignored (632 MB, source-built). A bare `uv run` validates every source in the lock
+# before executing, so on a machine that does not have the wheel it fails with
+#
+#   Failed to read from the distribution cache ... No such file or directory
+#
+# for `make lint` — a target with no connection to training whatsoever. That made `make check`
+# impossible on a fresh clone and would have turned CI red on the first run. `--frozen` skips the
+# re-resolution; the lock is committed and covers every profile, so there is nothing to re-resolve.
+#
+# Targets that genuinely need the wheel (`test-train`) deliberately do NOT use this.
+UVRUN   := uv run --frozen
+GRADLE  := cd android/MobileTransformers && JAVA_HOME=$(JAVA_HOME) ./gradlew
+CPP_DIR := android/MobileTransformers/MobileTransformers/src/main/cpp
+
+help:  ## List every target with its description.
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) \
+		| sort | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
+
+# --- environment setup (profile-isolated; never combine the conflicting pairs) ------------------
+setup:  ## Install core + dev tooling (no onnxruntime provider).
+	uv sync --frozen --group dev
+
+setup-export:  ## Install the export profile (optimum-onnx[onnxruntime]; Python >= 3.11).
+	uv sync --extra export
+
+setup-train:  ## Install the source-built ORT-training profile (cp312 only).
+	uv sync --python 3.12 --group ort-training-local
+
+setup-genai:  ## Install the onnxruntime-genai smoke profile (Python >= 3.11).
+	uv sync --group genai-smoke
+
+doctor:  ## Report every prerequisite and the command that fixes each. Read-only; always exits 0.
+	@scripts/doctor.sh
+
+fetch-native-deps:  ## Download + verify the gitignored Android native libraries (see third_party/android/manifest.json).
+	@scripts/fetch_native_deps.sh
+
+# --- standing checks (CI re-invokes these) ------------------------------------------------------
+lint:  ## Formatter + linter check (ruff).
+	$(UVRUN) ruff check src/ tests/
+	$(UVRUN) ruff format --check src/ tests/
+
+format:  ## Auto-format + auto-fix (ruff).
+	$(UVRUN) ruff format src/ tests/
+	$(UVRUN) ruff check --fix src/ tests/
+
+typecheck:  ## Static type check (mypy).
+	$(UVRUN) mypy src/mobiletransformers
+
+parity:  ## Cross-language enum/schema parity gate (Python source of truth vs. Kotlin/schemas).
+	$(UVRUN) python -m mobiletransformers.codegen.enums --check
+
+guard:  ## CI ratchets: secret reads, registry-dispatch literals, plan identifiers, machine paths.
+	$(UVRUN) pytest tests/unit/test_guards.py -q
+
+test-jvm:  ## Android SDK JVM unit tests (no device, no NDK, no vendored native libs).
+	$(GRADLE) :MobileTransformers:testDebugUnitTest
+
+test-cpp:  ## C++ host unit tests (googletest; ORT-free headers only, no NDK/device).
+	cmake -S $(CPP_DIR)/tests -B build/cpp-tests -DCMAKE_BUILD_TYPE=Release >/dev/null
+	cmake --build build/cpp-tests -j
+	ctest --test-dir build/cpp-tests --output-on-failure
+
+test-integration:  ## Integration tests (env-gated; skip when their profile is absent).
+	$(UVRUN) pytest tests/integration
+
+test:  ## Python unit tests (core env, no heavy deps).
+	$(UVRUN) pytest tests/unit tests/fixtures tests/export tests/hub tests/support tests/cli tests/adapter tests/federated
+
+test-smoke:  ## Export/package/manifest wiring smoke (core-runnable subset).
+	$(UVRUN) pytest tests/export tests/hub tests/cli -q
+
+test-train:  ## ORT-training smoke — requires the cp312 source-built wheel (ort-training-local).
+	uv run --python 3.12 --group ort-training-local pytest tests/integration/test_ort_training_smoke.py
+
+check: lint typecheck parity guard test  ## lint + typecheck + parity + guards + tests (the standing gate).
+
+# --- one-command export / package (no logic here) -----------------------------------------------
+export-model:  ## MODEL=<hf-id> [OUTPUT= PEFT= QUANT=] -> device-ready package.
+	uv run mobiletransformers export --model $(MODEL) --output $(OUTPUT) --peft $(PEFT) --quant $(QUANT)
+
+package-model:  ## PACKAGE=<dir> [CONFIG=] -> re-hash + re-emit that package's manifest and checksums.
+	uv run mobiletransformers package-model --package $(PACKAGE) $(if $(CONFIG),--config $(CONFIG),)
+
+publish-catalog: ## [ONLY=<key> PUSH=0 KEEP=1] -> export + verify + publish the showcase model catalog.
+	ONLY=$(ONLY) PUSH=$(if $(PUSH),$(PUSH),1) KEEP=$(if $(KEEP),$(KEEP),0) scripts/publish_catalog.sh
+
+# --- android / publish (thin wrappers over Gradle + scripts/) -----------------------------------
+android-build:  ## gradle assembleDebug (SDK + sample app).
+	$(GRADLE) :MobileTransformers:assembleDebug :MobileTransformersApp:assembleDebug
+
+device-package:  ## MODEL=<hf-id> [VARIANT= TRAIN=1 RAG=1 TASK=] -> export + adb push a real package for device tests.
+	MODEL=$(MODEL) VARIANT=$(VARIANT) TRAIN=$(TRAIN) RAG=$(RAG) TASK=$(TASK) scripts/device_package.sh
+
+device-test:  ## Run the instrumented device suites over the pushed package (skips w/o a device/package).
+	$(GRADLE) :MobileTransformers:connectedDebugAndroidTest
+
+device-hub-test:  ## REPO=<org>/<name> [HUB_TOKEN=] -> pull that repo from the Hub ONTO THE DEVICE and load it.
+	@[ -n "$(REPO)" ] || { echo "set REPO=<org>/<name>, e.g. REPO=mobiletransformers/functiongemma-270m-it" >&2; exit 1; }
+	$(GRADLE) :MobileTransformers:connectedDebugAndroidTest \
+	  -Pandroid.testInstrumentationRunnerArguments.class=com.martinkorelic.mobiletransformers.HubPullDeviceTest \
+	  -Pandroid.testInstrumentationRunnerArguments.mtHubRepoId=$(REPO) \
+	  $(if $(HUB_TOKEN),-Pandroid.testInstrumentationRunnerArguments.mtHubToken=$(HUB_TOKEN),)
+
+device-rss:  ## Collect the four-point RSS table (copy vs mmap, both engines) and evaluate the memory gates.
+	scripts/device_rss.sh
+
+device-federated:  ## Round-trip: export factors on device -> `federated serve` on host -> import back.
+	PKG=$(FED_PKG) scripts/federated_round_device.sh
+
+consumer-app:  ## Build examples/consumer-app against the mavenLocal artifact (publication proof).
+	cd examples/consumer-app && ./gradlew assembleDebug
+
+build-aar:  ## Assemble the release AAR (scripts/android_build_aar.sh owns the body).
+	scripts/android_build_aar.sh
+
+publish-local:  ## Publish the library to mavenLocal (scripts/publish_local_maven.sh owns the body).
+	scripts/publish_local_maven.sh
+
+docs:  ## Regenerate the derived docs (compatibility matrix) and check every page's links/tables.
+	uv run --frozen mobiletransformers support-matrix --md docs/COMPATIBILITY_MATRIX.md
+	$(UVRUN) pytest tests/unit/test_docs.py -q
+
+docs-build:  ## Build the documentation site. `--strict` fails on any unresolved internal link.
+	uv run --frozen --group docs mkdocs build --strict
+
+docs-serve:  ## Serve the documentation site locally with live reload (http://127.0.0.1:8000).
+	uv run --frozen --group docs mkdocs serve
+
+publish-artifacts:  ## Upload the gitignored build artifacts to the Hub (needs HF_TOKEN_ORG).
+	uv run --frozen python scripts/publish_build_artifacts.py $(if $(DRY_RUN),--dry-run,)
+
+requirements:  ## Regenerate requirements/*.lock.txt from uv.lock (they had no producer and rotted).
+	uv export --no-emit-project --group dev --format requirements.txt -o requirements/requirements-dev.lock.txt
+	uv export --no-emit-project --extra export --format requirements.txt -o requirements/requirements-export.lock.txt
+	uv export --no-emit-project --extra rag --format requirements.txt -o requirements/requirements-rag.lock.txt
+	uv export --python 3.12 --no-emit-project --group ort-training-local --format requirements.txt -o requirements/requirements-train-local.lock.txt
+	# The SBOM had no producer at all, so it sat at 0.1.0 for a month while the project moved on.
+	# A dependency inventory nobody regenerates is a claim that quietly stops being true.
+	uv export --no-emit-project --group dev --format cyclonedx1.5 -o requirements/sbom-cyclonedx.json
+
+# --- cleanup (generated artifacts ONLY; never user caches / cache_dir/) --------------------------
+clean-generated:  ## Remove generated build/model artifacts ONLY (never user caches).
+	rm -rf build/ dist/ onnx_models/ *.egg-info src/*.egg-info
+	find . -maxdepth 2 -type d -name '__pycache__' -prune -exec rm -rf {} +
diff --git a/README.md b/README.md
index 9a1dd51..d3ebee8 100644
--- a/README.md
+++ b/README.md
@@ -1,141 +1,201 @@
-# 📱 MobileTransformers: An On-Device LLM PEFT Framework for Fine-Tuning and Inference
+![MobileTransformers](docs/assets/mobiletransformers_banner.png)
 
-**MobileTransformers** (or **ORTransformersMobile**) is a modular framework designed for fully **on-device execution** of large and small language models (LLM / SLM) on mobile and edge devices.  
-Built on top of **ONNX Runtime**, it leverages hardware-accelerated execution providers such as **XNNPACK**, **NNAPI**, and **QNN** for efficient inference and training on Android and similar platforms.
+# MobileTransformers: An On-Device LLM PEFT Framework for Fine-Tuning and Inference
 
-- **OR**: ONNX Runtime  
-- **Transformers**: Core architecture of large language models  
-- **Mobile**: Fully on-device mobile execution 
+[![checks](https://github.com/martinkorelic/mobiletransformers/actions/workflows/checks.yml/badge.svg)](https://github.com/martinkorelic/mobiletransformers/actions/workflows/checks.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%20%7C%203.12-3776AB?logo=python&logoColor=white)](pyproject.toml)
+[![Android 7.0+](https://img.shields.io/badge/Android-API%2024%2B-3DDC84?logo=android&logoColor=white)](docs/ANDROID_SDK.md)
+[![Models on Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20models-mobiletransformers-FFD21E)](https://huggingface.co/mobiletransformers)
 
-![Example of MobileTransformers application](docs/ortransformer-feature.gif)
-> Example of MobileTransformers Android application running on Google Pixel 6 (2021) with support for on-device LLM training and inference with retrieval-augmented generation.
+**Export a Hugging Face model, pull it onto a phone, then chat with it, retrieve over your own
+documents, classify text, fine-tune it, merge the adapter into the weights, and let it call tools —
+entirely on the device.** No server, no inference API, no data leaving the phone.
 
-
-## 📥 Main links
-
-### Documentation
-
-Installation instructions, training and inference examples, and API documentation.
-
-[MobileTransformers Documentation](https://martinkorelic.github.io/mobiletransformers-docs/)
-
-### Research
-
-For a comprehensive understanding of the research behind MobileTransformers, including detailed explanations of Multi-Adapter Rank Sharing (MARS), on-device training methodologies, and experimental results:
-
-[Master's Thesis - Parameter-Efficient Tuning of Large Language Models on Mobile Devices](https://repozitorij.uni-lj.si/IzpisGradiva.php?lang=eng&id=175561)
+Built on **ONNX Runtime**, for both inference *and* training on Android.
 
 ---
 
-## 🚀 What is MobileTransformers?
+## Examples
 
-A comprehensive, privacy-first framework that empowers researchers and developers to export, fine-tune, merge, and deploy transformer-based language models directly on your Android device. Eliminate dependency on cloud services while maintaining full control over your AI models in your pocket.
-Perfect for privacy-preserving NLP applications, offline AI assistants, personalized chatbots, and edge computing scenarios where data sovereignty and real-time responsiveness are crucial. Whether you're building the next generation of pocket AI or developing enterprise edge solutions, **MobileTransformers** provides the foundation for truly autonomous mobile intelligence.
+A few of the features, recorded on a phone.
 
-**Key Benefits**:
+<table>
+<tr>
+<td width="50%" valign="top">
 
-- 🔒 **Complete Privacy**: Your data never leaves your device
-- 📱 **Pocket-Sized AI**: Full LLM/SLM capabilities in your smartphone
-- 🔧 **Hardware execution provider support**: Hardware-accelerated inference for efficient on-device execution
-- 🌐 **Offline-First**: Works anywhere, anytime, without internet connectivity
-- 🤖 **Universal Model Support**: Compatible with most custom LLMs/SLMs from Huggingface
+<img src="docs/assets/mobiletransformers_train.gif" alt="Fine-tuning a model on the phone" width="100%">
 
----
-
-## 📦 Repository Contents
-
-This comprehensive repository provides everything needed for on-device LLM deployment:
+**Fine-tuning, on the phone.** A LoRA adapter trained against a local dataset — loss falling, step by
+step, on the device's own CPU. The adapter is then merged into the weights so the next answer comes
+from the fine-tuned model, not from an adapter stacked at runtime.
 
-- 🔄 **Export Pipeline**: Streamlined conversion system transforming Huggingface LLMs/SLMs into PEFT-enabled training models and ONNX inference graphs optimized for Android deployment
-- 📱 **Complete Android Application**: Full-featured Android folder containing the entire mobile application stack, ready for pocket deployment
-- 🧪 **Custom PEFT support**: Customizable PEFT solutions for on-device fine-tuning (e.g. LoRA - Low-rank approximation, MARS - Multi-Adapter Rank Sharing and more)
-- 🐍 **Training & Inference Scripts**: Python implementations supporting both PyTorch and ONNX Runtime, optimized for mobile hardware constraints
-- 🔬 **Evaluation Scripts**: Comprehensive benchmarking suite for trained models across diverse NLP tasks, including mobile-specific performance metrics and battery consumption analysis
+</td>
+<td width="50%" valign="top">
 
----
+<img src="docs/assets/mobiletransformers_functioncall.gif" alt="A chat reply becoming an Android alarm intent" width="100%">
 
-## 📱 Android Application: ORTransformer
+**A sentence becomes an Android action.** The model answers with a structured tool call; the app
+validates it against its own allowlist, shows the exact intent it is about to fire, and waits. Accept,
+and a real alarm appears in the clock app.
 
-The Android app is split into two main parts:
+</td>
+</tr>
+<tr>
+<td width="50%" valign="top">
 
-- 📲 **Kotlin UI Layer**  
-  A lightweight interface acting as a communication bridge, calling APIs from the backend on the mobile device
+<img src="docs/assets/mobiletransformers_rag.gif" alt="Answering from documents stored on the device" width="100%">
 
-- ⚙️ **Backend: MobileTransformers**  
-  The core engine of the entire framework, implemented in **Kotlin and C++**. Can be easily implemented in re-used in another application, pick and choose which features you need.
+**Grounded in your own documents.** Retrieval runs against a vector store on the phone and reports
+what it found — how many passages, from which files — *before* the answer streams in underneath it.
 
-🔧 Key features include:  
-  - **Modular Android Project**: Clean separation of concerns with isolated modules for **training**, **inference**, **RAG** and **weight management** 
-  - **Hardware-Accelerated Loops**: **On-device training / fine-tuning** and generation loops leveraging NNAPI, XNNPACK, and Qualcomm QNN for optimal mobile performance
-  - **Dynamic Configuration**: Real-time customization of training parameters and inference settings tailored to your Android device's capabilities
-  - **ONNX Runtime Integration**: Optimized model execution specifically tuned for mobile and edge hardware 
-  - **Weight Management**: **On-device weight merging** with automatic export to **Android filesystem**, enabling model personalization without cloud dependency
-  - **Seamless Model Loading**: Direct import of merged weights into inference graphs for immediate pocket deployment
-  - **RAG support**: Support for **Retrieval-Augmented Generation (RAG)** using **ObjectBox** as a fast **on-device vector database**
+</td>
+<td width="50%" valign="top">
 
+<img src="docs/assets/mobiletransformers_classify.gif" alt="Classifying text on the device" width="100%">
 
----
+**Not only decoders.** A DistilBERT sentiment classifier, scoring text on the device and showing the
+probability for every label. Encoders can be fine-tuned here too — that is what makes the bars move.
 
-## ✅ Key Capabilities
+</td>
+</tr>
+</table>
 
-| Feature                                     | Description                                                        |
-|---------------------------------------------|------------------------------------------------------------------|
-| ✅ Export **custom PyTorch Huggingface SLM / LLM models** | Convert Huggingface models with PEFT methods to training & ONNX inference models for on-device use |
-| ✅ On-device **fine-tuning/training** loop       | Perform parameter-efficient training (PEFT) directly on mobile devices |
-| ✅ On-device **generation** loop with KV caching | Efficient text generation using cached key-value tensors for faster autoregressive inference |
-| ✅ **Customizable** training and generation      | Flexible configuration to adapt training and generation to specific tasks and hardware |
-| ✅ On-device **weight exporting**                 | Save trained or merged weights directly on-device (mobile filesystem) |
-| ✅ On-device **weight merging**                    | Merge base and PEFT weights on-device, with optional quantization for optimized size and speed |
-| ✅ Direct inference from **merged weights**       | Load merged weights into the inference graph for seamless on-device model execution |
-| ✅ **Retrieval-Augmented Generation** (RAG)       | Fully on-device vector database integration with ObjectBox for augmented generation |
+More, capability by capability, in **[docs/SHOWCASE.md](docs/SHOWCASE.md)**.
 
 ---
 
-## 🔧 On-device example
+## What is actually here
 
-Example of a model being adapted to a personalized smartphone automation dataset where users express intents and the model recommends appropriate automatic actions to perform on the device. This task-oriented dataset is specifically designed for on-device intelligence scenarios.
+| | |
+| --- | --- |
+| **A host export pipeline** | Hugging Face → PEFT-enabled training graph + ONNX inference graph + a manifest, in one command |
+| **An Android SDK** (Kotlin + C++) | `mobiletransformers-android` — an AAR you can consume from your own app |
+| **A sample app** | The reference consumer of that SDK, and the fastest way to see the whole loop |
+| **A published model shelf** | Six packages on the Hub, each shipping both an inference and a training stage — including one exported with MARS |
+| **Custom PEFT methods** | LoRA, LoRA-XS, and **MARS** (Multi-Adapter Rank Sharing) — the project's own method |
+| **Federated adapter exchange** | Export local factors, aggregate on a host, import the average back |
 
-|🧩 Base Model	|⚙️ On-device Fine-tuned model|
-|----|----|
-|![Base on-device model](docs/base-model.gif)|![On-device trained LLM model](docs/on-device-trained.gif)|
+The two things that distinguish this from "run a small model on a phone": **training happens on the
+device**, and the trained adapter is **merged into the inference weights on the device**, so the
+personalised model is the one that then generates.
 
-> This example shows how a base model can be fine-tuned and personalized entirely on-device, meaning no data ever leaves the device. During the process, adapters are trained locally, then merged and integrated into the base model on the mobile phone to produce the final fine-tuned version.
+## Quick start
 
----
-
-## 🛠️ Built On
-
-- [**ONNX Runtime**](https://onnxruntime.ai/) for training/inference and support for mobile-optimized execution providers:  
-  - XNNPACK  
-  - NNAPI  
-  - Qualcomm QNN  
-- [**Huggingface Transformers**](https://huggingface.co/) ecosystem compatibility for model export  
-- [**ObjectBox**](https://objectbox.io/) for lightweight on-device vector databases in RAG workflows  
-
----
-
-## 🎯 Why MobileTransformers?
+```bash
+make doctor                   # what is missing, and the command that fixes each
+make setup                    # core + dev environment (uv, Python 3.10)
+make check                    # lint + typecheck + enum parity + guards + unit tests
+```
 
-- Fully **on-device** - no cloud dependency, maximizing privacy and minimizing latency 
-- Enables **parameter-efficient fine-tuning (PEFT)** on mobile hardware  
-- Modular and customizable for research and production use
-- Ready for **Android** and adaptable to other edge devices  
-- Combines cutting-edge generation techniques with practical on-device deployment  
+Export a package and put it on a phone:
 
----
+```bash
+make setup-export
+mobiletransformers export --model HuggingFaceTB/SmolLM2-135M-Instruct \
+                          --output build/pkg --genai --validate
 
-## 🔧 Extensibility and Future Work
+make device-package MODEL=HuggingFaceTB/SmolLM2-135M-Instruct TRAIN=1 RAG=1
+make device-test
+```
 
-MobileTransformers is designed as a flexible platform, allowing easy extension for advanced on-device ML workflows, such as:
+Or build the app and install a package from the Hub inside it:
 
-- Beyond text generation - classification, sentiment analysis, named entity recognition, question answering, summarization, and custom NLP tasks tailored for mobile use cases
-- On-device **reinforcement learning**  
-- **Federated learning** leveraging exported merged weights  
-- Integration with additional hardware acceleration backends  
-- Support for more PEFT methods and quantization techniques  
-- Expansion to other mobile platforms and edge systems
+```bash
+make fetch-native-deps        # the gitignored Android natives — see below
+make android-build
+```
 
----
+Dependency profiles are deliberately isolated: the `export` extra and the `ort-training-local` group
+**cannot** co-install. Always pass an explicit `--group`/`--extra` to `uv run`, and reset with
+`uv sync --frozen --group dev --python 3.10` before `make check` — a leftover profile is the single
+most common way to "break" the repo. See [docs/EXPORT.md](docs/EXPORT.md).
+
+> **A fresh clone cannot build the Android SDK on its own.** ~180 MB of prebuilt native binaries and
+> vendored headers are gitignored. `make doctor` tells you what is missing; `make fetch-native-deps`
+> gets it. See [docs/ARCHITECTURE.md ▸ Native dependencies](docs/ARCHITECTURE.md).
+
+## The model shelf
+
+Six packages under [`mobiletransformers`](https://huggingface.co/mobiletransformers) on the Hub.
+Every one ships **both an inference and a training stage** — a shelf entry that cannot be fine-tuned
+demonstrates half the framework, so `scripts/publish_catalog.sh` asserts it.
+
+| model | task | inference | total | features |
+| --- | --- | --- | --- | --- |
+| [SmolLM2-135M-Instruct](https://huggingface.co/mobiletransformers/SmolLM2-135M-Instruct) | text-generation | 663 MB | 935 MB | inference, train, rag |
+| [functiongemma-270m-it](https://huggingface.co/mobiletransformers/functiongemma-270m-it) | text-generation | 3557 MB | 3875 MB | inference, train |
+| [gemma-3-270m-it](https://huggingface.co/mobiletransformers/gemma-3-270m-it) | text-generation | 1814 MB | 2131 MB | inference, train (**MARS**) |
+| [Qwen2.5-0.5B-Instruct](https://huggingface.co/mobiletransformers/Qwen2.5-0.5B-Instruct) | text-generation | 2554 MB | 3212 MB | inference, train, rag |
+| [all-MiniLM-L6-v2](https://huggingface.co/mobiletransformers/all-MiniLM-L6-v2) | text-classification | 94 MB | 214 MB | inference, train, rag |
+| [distilbert-sst2-english](https://huggingface.co/mobiletransformers/distilbert-sst2-english) | text-classification | 270 MB | 361 MB | inference, train |
+
+Sizes are measured off each pushed package's manifest, not estimated. Start with **SmolLM2**. Full
+detail, and why the encoders are exported as `text-classification`, in
+[docs/CATALOG.md](docs/CATALOG.md).
+
+## The sample app
+
+Eight destinations, and which you see depends on what the loaded package can actually do — a chat box
+on an embedding model is a promise the package cannot keep, so it is hidden rather than greyed out.
+
+**Models** → **Chat** (streaming, grounded answers, tool calls) → **Retrieval** → **Classify** →
+**Train** (live loss curve, then merge) → **Federated** → **Configuration** → **About**.
+
+[docs/SHOWCASE.md](docs/SHOWCASE.md) is the tour: one section per capability, the package each needs,
+and what you should see.
+
+## Documentation
+
+| Page | Covers |
+| --- | --- |
+| [docs/SHOWCASE.md](docs/SHOWCASE.md) | a tour of the sample app, capability by capability |
+| [docs/CATALOG.md](docs/CATALOG.md) | the published packages: sizes, features, which to start with |
+| [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) | how the host exporter and the Android SDK fit together; native dependencies |
+| [docs/EXPORT.md](docs/EXPORT.md) | the one-command export CLI, profiles, per-task flag rules |
+| [docs/MODEL_FORMAT.md](docs/MODEL_FORMAT.md) | the manifest + `weight_handoff_map.json` on-disk contracts |
+| [docs/HUB_PACKAGE_FORMAT.md](docs/HUB_PACKAGE_FORMAT.md) | package layout on the Hub; pull/verify/install |
+| [docs/ANDROID_SDK.md](docs/ANDROID_SDK.md) | consuming the AAR: install, load, generate, classify, retrieve, train, merge |
+| [docs/COOKBOOK.md](docs/COOKBOOK.md) | copy-pasteable Kotlin per task, mirroring the app's screens |
+| [docs/ANDROID_CACHE_FORMAT.md](docs/ANDROID_CACHE_FORMAT.md) | where an installed model lives on device |
+| [docs/CONFIGURATION.md](docs/CONFIGURATION.md) | the enum vocabulary, typed configs, extension points |
+| [docs/PUBLIC_API.md](docs/PUBLIC_API.md) | the Python, CLI and Kotlin public surfaces |
+| [docs/RAG.md](docs/RAG.md) | on-device retrieval, ingestion, grounded generation |
+| [docs/FEDERATED.md](docs/FEDERATED.md) | federated adapter exchange + the Flower simulation |
+| [docs/COMPATIBILITY_MATRIX.md](docs/COMPATIBILITY_MATRIX.md) | per-model support, generated from the matrix |
+| [docs/RELEASE_CHECKLIST.md](docs/RELEASE_CHECKLIST.md) | what a release requires |
+| [docs/mobile_evaluation.md](docs/mobile_evaluation.md) | host-side evaluation of on-device runs |
+| [docs/getting-started.md](docs/getting-started.md) | three routes in: run the app, consume the SDK, export a model |
+| [docs/on-device-peft.md](docs/on-device-peft.md) | LoRA, LoRA-XS and MARS, and what each costs on a phone |
+
+**All of the above is published as a searchable site at
+[martinkorelic.github.io/mobiletransformers](https://martinkorelic.github.io/mobiletransformers/).**
+
+## Built on
+
+- [**ONNX Runtime**](https://onnxruntime.ai/) — training and inference, with XNNPACK / NNAPI /
+  Qualcomm QNN execution providers
+- [**Hugging Face Transformers**](https://huggingface.co/) + [**Optimum**](https://huggingface.co/docs/optimum/)
+  — model export
+- [**ObjectBox**](https://objectbox.io/) — the on-device vector database behind RAG
+
+## Where this is going
+
+- Beyond generation and classification: NER, question answering, summarization
+- On-device reinforcement learning
+- More PEFT methods and quantization techniques
+- Additional hardware acceleration backends, and platforms beyond Android
+
+## References
+
+- [**Original codebase**](https://gitlab.fri.uni-lj.si/lrk/mobiletransformers) — the address this
+  work was published under, and the one the citation below names.
+- [**Master's Thesis — Parameter-Efficient Tuning of Large Language Models on Mobile Devices**](https://repozitorij.uni-lj.si/IzpisGradiva.php?lang=eng&id=175561)
+  — the research behind MARS, the on-device training methodology, and the experimental results.
+- [**AI health agents on mobile**](https://link.springer.com/article/10.1186/s12919-026-00367-3#Sec27),
+  *BMC Proceedings* 2026, 20(12):A7 (EHRCON25 — openEHR International Conference).
+  The first on-device RAG prototype over openEHR personal health records: a small language model, an
+  embedding model and a vector database of vital signs, medications, allergies and lab results, all
+  running on the phone. Built on this framework.
 
 ## Citation
 
@@ -150,8 +210,6 @@ If you are using this framework for your own work, please cite:
 }
 ```
 
----
-
 ## Acknowledgements
 
-This work was supported by the Slovenian Research Agency grant no. N2-0393 approXimation for adaptable diStributed artificial intelligence and grant no. J2-3047 Context-Aware On-Device Approximate Computing.
\ No newline at end of file
+This work was supported by the Slovenian Research Agency grant no. N2-0393 approXimation for adaptable diStributed artificial intelligence and grant no. J2-3047 Context-Aware On-Device Approximate Computing.
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000..c2846a0
--- /dev/null
+++ b/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,63 @@
+# Third-party notices
+
+MobileTransformers redistributes or depends on the components below. Each remains under its own
+licence; nothing here alters the terms of [`LICENSE.md`](LICENSE.md).
+
+Vendored native binaries live under `android/MobileTransformers/MobileTransformers/src/main/jniLibs/`
+and `.../src/main/cpp/` and are **not** covered by this project's copyright.
+
+## Redistributed in the Android artifact
+
+| Component | Licence | Notes |
+| --- | --- | --- |
+| [ONNX Runtime](https://github.com/microsoft/onnxruntime) | MIT | training build (`libonnxruntime.so`) + a stock build shipped under a distinct soname (`libort_gen.so`) so the GenAI engine can coexist |
+| [ONNX Runtime GenAI](https://github.com/microsoft/onnxruntime-genai) | MIT | `libonnxruntime-genai.so`; its `dlopen` target is repointed at `libort_gen.so` |
+| [tokenizers-cpp](https://github.com/mlc-ai/tokenizers-cpp) | Apache-2.0 | native tokenizer (`libtokenizers_c`, `libtokenizers_cpp`) |
+| [HuggingFace Tokenizers](https://github.com/huggingface/tokenizers) | Apache-2.0 | via tokenizers-cpp |
+| [ObjectBox](https://objectbox.io/) | Apache-2.0 | on-device vector store (`libobjectbox-jni.so`) |
+| [nlohmann/json](https://github.com/nlohmann/json) | MIT | header-only JSON (fetched at build time) |
+
+## Build- and test-time only
+
+| Component | Licence |
+| --- | --- |
+| [googletest](https://github.com/google/googletest) | BSD-3-Clause |
+| [Robolectric](https://robolectric.org/) | MIT |
+| [OkHttp / MockWebServer](https://square.github.io/okhttp/) | Apache-2.0 |
+| [AndroidX](https://developer.android.com/jetpack/androidx) (core, appcompat, work, test) | Apache-2.0 |
+| [Kotlin stdlib / coroutines](https://kotlinlang.org/) | Apache-2.0 |
+| [Gson](https://github.com/google/gson) | Apache-2.0 |
+
+## Redistributed data
+
+| Component | Licence | Notes |
+| --- | --- | --- |
+| [`google/mobile-actions`](https://huggingface.co/datasets/google/mobile-actions) | CC-BY-4.0 | © Google. **Five records** are committed verbatim as `tests/fixtures/agent/mobile_actions_sample.jsonl` so the tool-call importer tests run offline; see that directory's `README.md`. The full corpus is not vendored — `mobiletransformers agent-dataset` fetches it on demand. |
+
+## Python dependencies
+
+| Component | Licence |
+| --- | --- |
+| [PyTorch](https://pytorch.org/) | BSD-3-Clause |
+| [Transformers](https://github.com/huggingface/transformers) | Apache-2.0 |
+| [PEFT](https://github.com/huggingface/peft) | Apache-2.0 |
+| [Optimum](https://github.com/huggingface/optimum) / optimum-onnx | Apache-2.0 |
+| [ONNX](https://onnx.ai/) | Apache-2.0 |
+| [huggingface_hub](https://github.com/huggingface/huggingface_hub) | Apache-2.0 |
+| [safetensors](https://github.com/huggingface/safetensors) | Apache-2.0 |
+| [NumPy](https://numpy.org/) | BSD-3-Clause |
+| [Pydantic](https://docs.pydantic.dev/) | MIT |
+| [PyYAML](https://pyyaml.org/) | MIT |
+| [python-dotenv](https://github.com/theskumar/python-dotenv) | BSD-3-Clause |
+| [Flower](https://flower.ai/) *(optional, installed out-of-band)* | Apache-2.0 |
+
+## Vendored source
+
+| Path | Origin | Licence |
+| --- | --- | --- |
+| `src/mobiletransformers/export/onnx_config_with_loss.py` | Optimum 1.24 (`OnnxConfigWithLoss`, removed in Optimum 2.1) | Apache-2.0 |
+| `.../cpp/onnxruntime/`, `.../cpp/onnxruntime-genai/` | upstream C API headers | MIT |
+| `.../cpp/tokenizers/` | tokenizers-cpp headers | Apache-2.0 |
+
+Run `uv tree` (Python) or `./gradlew :MobileTransformers:dependencies` (Android) for the exact resolved
+dependency set at a given version.
diff --git a/android/ORTransformer/.gitignore b/android/MobileTransformers/.gitignore
similarity index 100%
rename from android/ORTransformer/.gitignore
rename to android/MobileTransformers/.gitignore
diff --git a/android/ORTransformer/ORTransformersMobile/.gitignore b/android/MobileTransformers/MobileTransformers/.gitignore
similarity index 96%
rename from android/ORTransformer/ORTransformersMobile/.gitignore
rename to android/MobileTransformers/MobileTransformers/.gitignore
index 43f9921..d905851 100644
--- a/android/ORTransformer/ORTransformersMobile/.gitignore
+++ b/android/MobileTransformers/MobileTransformers/.gitignore
@@ -36,3 +36,4 @@ google-services.json
 src/main/jniLibs/arm64-v8a
 src/main/jniLibs/x86_64
 /src/main/cpp/includes/
+src/main/aarLibs/
diff --git a/android/MobileTransformers/MobileTransformers/build.gradle.kts b/android/MobileTransformers/MobileTransformers/build.gradle.kts
new file mode 100644
index 0000000..11aa517
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/build.gradle.kts
@@ -0,0 +1,203 @@
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.jetbrains.kotlin.android)
+    alias(libs.plugins.objectbox)
+    `maven-publish`
+}
+
+android {
+    namespace = "com.martinkorelic.mobiletransformers"
+    compileSdk = 34
+
+    buildFeatures {
+        // #22: BuildConfig carries the default-off on-device adapter-upload security flag.
+        buildConfig = true
+    }
+
+    defaultConfig {
+        minSdk = 24
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles("consumer-rules.pro")
+        // #22: on-device Hub adapter upload is disabled by default (privacy-gated); flip only behind a
+        // security review. Product path is device -> desktop sync -> Python `push-adapter`.
+        buildConfigField("boolean", "ADAPTER_UPLOAD_ENABLED", "false")
+        // #36: federated participation is OFF unless the app shipping this turns it on. Adapter
+        // factors are derived from the user's own data, so the default must be "do not send".
+        //
+        // The device round-trip suite has to turn it on, and a test-only backdoor inside
+        // FederatedConfig would weaken the very gate it is testing. So the switch stays the build
+        // switch, flipped deliberately per invocation:
+        //   ./gradlew :MobileTransformers:connectedDebugAndroidTest -PmtFederationEnabled=true
+        // Absent property == false, so nothing published from this tree carries it on by accident.
+        buildConfigField(
+            "boolean",
+            "FEDERATION_ENABLED",
+            ((project.findProperty("mtFederationEnabled") as String?)?.toBoolean() ?: false).toString(),
+        )
+        externalNativeBuild {
+            cmake {
+                cppFlags += "-std=c++17"
+                arguments += "-DJSON_BuildTests=OFF"
+            }
+        }
+        ndk {
+            // v1 ships arm64-v8a only. x86_64 is NOT buildable here: jniLibs/x86_64 has the GenAI .so
+            // but not `libonnxruntime.so`, `libtokenizers_c.a` or `libtokenizers_cpp.a`, which
+            // CMakeLists.txt links against — so `libmobiletransformers.so` has never existed for that
+            // ABI. Listing it produced an AAR with an x86_64 directory whose consumer would fail at
+            // System.loadLibrary (which scripts/android_build_aar.sh already refuses to publish), and
+            // broke every unqualified `assembleDebug`. Restoring x86_64 means building ORT-training and
+            // tokenizers-cpp for it first; see docs/ARCHITECTURE.md "ABI support".
+            abiFilters += listOf("arm64-v8a")
+        }
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+    externalNativeBuild {
+        cmake {
+            path("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
+    // The onnxruntime-genai .so is provided BOTH by the AAR (runtime) and jniLibs (CMake link input, #10);
+    // dedupe the identical native libs at packaging. Content is the same real 0.14 binary either way.
+    packaging {
+        jniLibs {
+            pickFirsts += listOf(
+                "**/libonnxruntime-genai.so",
+                "**/libonnxruntime-genai-jni.so",
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+        }
+    }
+    testOptions {
+        unitTests {
+            // Robolectric needs resources on the unit-test classpath.
+            isIncludeAndroidResources = true
+            // Anything Robolectric does NOT shadow should FAIL rather than silently return 0/null —
+            // a returned default would let a test "pass" against a method that never actually ran.
+            isReturnDefaultValues = false
+        }
+    }
+}
+
+dependencies {
+
+    // ONNX Runtime GenAI (#10/#11): the genai .so ships from jniLibs (patched to dlopen the genai-paired
+    // stock ORT as `libort_gen.so`, keeping the training ORT as `libonnxruntime.so`). Its Java classes are
+    // unused (C-API/JNI path), so the AAR is NOT a dependency — this avoids the AAR-vs-jniLibs .so conflict
+    // and lets us ship the patched binary. See spikes/genai_external_swap/README.md (ORT separation).
+
+    implementation(libs.pebble)
+    implementation(libs.gson)
+
+    // #21/#22: Hub network half — OkHttp (streaming GET/Range), WorkManager (background download), and an
+    // EXPLICIT coroutines dependency (was previously only transitive).
+    implementation(libs.okhttp)
+    implementation(libs.androidx.work.runtime.ktx)
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.kotlinx.coroutines.android)
+
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.material)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.okhttp.mockwebserver)
+    // Robolectric provides Android SDK stubs on the JVM. Without it, every class touching
+    // android.util.Log / Context / org.json failed with "Method ... not mocked", which is exactly why
+    // LLMRepository, RagRepository, FileUtil and RepositoryBackedModelSession had ZERO JVM coverage —
+    // and why several of the defects this pass fixed reached the audit unnoticed.
+    testImplementation(libs.robolectric)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(libs.androidx.test.runner)
+    androidTestImplementation(libs.kotlinx.coroutines.test)
+    androidTestImplementation(libs.androidx.work.testing)
+}
+// --- Maven publication (#30) ----------------------------------------------------------------------
+// Coordinates: com.martinkorelic.mobiletransformers:mobiletransformers-android:<version>
+// `group`/`version` come from gradle.properties and are overridable with -Pversion=<x>.
+//
+// Note: an earlier plan named the group `com.martinkorelic` while the publication plan names
+// `com.martinkorelic.mobiletransformers`. The latter wins (it is the publication plan's own contract);
+// the older doc is corrected rather than followed.
+publishing {
+    publications {
+        register<MavenPublication>("release") {
+            groupId = project.group.toString()
+            artifactId = "mobiletransformers-android"
+            version = project.version.toString()
+
+            afterEvaluate { from(components["release"]) }
+
+            pom {
+                name.set("MobileTransformers Android SDK")
+                description.set(
+                    "On-device LLM parameter-efficient fine-tuning, inference and RAG for Android."
+                )
+                url.set("https://github.com/martinkorelic/mobiletransformers")
+                licenses {
+                    license {
+                        // Kept in lockstep with LICENSE.md. The Apache-2.0 relicense (#32) needs both
+                        // rights holders in CITATION.cff; until it lands this MUST report the real
+                        // licence, because a consumer resolving this POM relies on it.
+                        name.set("Creative Commons Attribution-NonCommercial 4.0 International")
+                        url.set("https://creativecommons.org/licenses/by-nc/4.0/")
+                        distribution.set("repo")
+                    }
+                }
+                developers {
+                    developer {
+                        id.set("martinkorelic")
+                        name.set("Martin Korelič")
+                    }
+                    developer {
+                        id.set("vpejovic")
+                        name.set("Veljko Pejović")
+                    }
+                }
+                scm {
+                    url.set("https://github.com/martinkorelic/mobiletransformers")
+                    connection.set("scm:git:https://github.com/martinkorelic/mobiletransformers.git")
+                }
+            }
+        }
+    }
+}
+
+// The cross-language oracle fixtures live at the REPO root (`tests/fixtures/`), outside anything
+// Gradle knows about, and `PackagesTest` / `MobileActionsParityTest` read them by walking up from the
+// working directory. Gradle therefore considered the test task up-to-date when only a fixture changed
+// — a corrupted oracle produced `BUILD SUCCESSFUL` in 670 ms without running a single test, which is
+// the exact failure mode these parity tests exist to prevent. Declaring the directory as an input
+// makes a fixture change re-run them.
+tasks.withType<Test>().configureEach {
+    val sharedFixtures = rootProject.file("../../tests/fixtures")
+    if (sharedFixtures.isDirectory) {
+        inputs.dir(sharedFixtures)
+            .withPathSensitivity(PathSensitivity.RELATIVE)
+            .withPropertyName("sharedCrossLanguageFixtures")
+    }
+}
diff --git a/android/ORTransformer/ORTransformersMobile/consumer-rules.pro b/android/MobileTransformers/MobileTransformers/consumer-rules.pro
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/consumer-rules.pro
rename to android/MobileTransformers/MobileTransformers/consumer-rules.pro
diff --git a/android/MobileTransformers/MobileTransformers/objectbox-models/default.json b/android/MobileTransformers/MobileTransformers/objectbox-models/default.json
new file mode 100644
index 0000000..b25ebec
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/objectbox-models/default.json
@@ -0,0 +1,402 @@
+{
+  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
+  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
+  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
+  "entities": [
+    {
+      "id": "1:6312292868835490962",
+      "lastPropertyId": "7:2218360321370171021",
+      "name": "VectorEntity1024",
+      "properties": [
+        {
+          "id": "1:6129838102769740405",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:8342299575047072091",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:3121322145205345580",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:6634216677500241695",
+          "name": "content",
+          "indexId": "1:5628541363907386903",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:4591825907158956682",
+          "name": "embedding",
+          "indexId": "2:877155294817586044",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:5883788455774084256",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:2218360321370171021",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "2:6283381358651374286",
+      "lastPropertyId": "7:1968848852841404956",
+      "name": "VectorEntity128",
+      "properties": [
+        {
+          "id": "1:5769841030064880069",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:6555651120977614822",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:456208777151447776",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:3060836635260339617",
+          "name": "content",
+          "indexId": "3:1867038497503126389",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:1640322023827419600",
+          "name": "embedding",
+          "indexId": "4:4086334271468083426",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:6205081604583971125",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:1968848852841404956",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "3:7717907702316138682",
+      "lastPropertyId": "7:1219754983200035250",
+      "name": "VectorEntity1536",
+      "properties": [
+        {
+          "id": "1:5505097755916856544",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:623977696493542085",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:4996201321097165490",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:5322504698064582815",
+          "name": "content",
+          "indexId": "5:4118868854556448382",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:4409986798134442027",
+          "name": "embedding",
+          "indexId": "6:6181707195042117522",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:6940435668724064808",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:1219754983200035250",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "4:1812728196995434090",
+      "lastPropertyId": "7:3169912114904751056",
+      "name": "VectorEntity256",
+      "properties": [
+        {
+          "id": "1:6603725897690470701",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:8671809677384943785",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:7861886281468689310",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:2408473297796407407",
+          "name": "content",
+          "indexId": "7:8483254081747776322",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:8471718958668191294",
+          "name": "embedding",
+          "indexId": "8:4704596766946123242",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:4939862528551864585",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:3169912114904751056",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "5:6067543743343676272",
+      "lastPropertyId": "7:2961836472113766158",
+      "name": "VectorEntity384",
+      "properties": [
+        {
+          "id": "1:2899273423030577360",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:9144298715894567040",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:2362135959314486625",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:2036477865185213428",
+          "name": "content",
+          "indexId": "9:5052229234386694185",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:6335798492258790404",
+          "name": "embedding",
+          "indexId": "10:1221859485491922065",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:713220216528469622",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:2961836472113766158",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "6:5337009284482186103",
+      "lastPropertyId": "7:4056392251129713943",
+      "name": "VectorEntity512",
+      "properties": [
+        {
+          "id": "1:4213890617344099142",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:5114585404654391641",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:7890430420743054553",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:2373272805557915468",
+          "name": "content",
+          "indexId": "11:9121122965285287426",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:3538155769260542229",
+          "name": "embedding",
+          "indexId": "12:8537982803655308597",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:528837246711124491",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:4056392251129713943",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "7:2482969880891003204",
+      "lastPropertyId": "7:7009293217781797530",
+      "name": "VectorEntity64",
+      "properties": [
+        {
+          "id": "1:6778584485307928481",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:9178692164283023757",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:9015651743332472421",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:5088832391211888614",
+          "name": "content",
+          "indexId": "13:9206244627906675234",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:7988884859475187274",
+          "name": "embedding",
+          "indexId": "14:8896430678575507920",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:2659216331489370261",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:7009293217781797530",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    },
+    {
+      "id": "8:3777768982988066495",
+      "lastPropertyId": "7:5759813725018074825",
+      "name": "VectorEntity768",
+      "properties": [
+        {
+          "id": "1:4523762841307426321",
+          "name": "id",
+          "type": 6,
+          "flags": 1
+        },
+        {
+          "id": "2:8318212713625604469",
+          "name": "name",
+          "type": 9
+        },
+        {
+          "id": "3:1393590073543014237",
+          "name": "document",
+          "type": 9
+        },
+        {
+          "id": "4:8080388202965929501",
+          "name": "content",
+          "indexId": "15:3321529416306103978",
+          "type": 9,
+          "flags": 8
+        },
+        {
+          "id": "5:8658000558972963672",
+          "name": "embedding",
+          "indexId": "16:330532365559818907",
+          "type": 28,
+          "flags": 8
+        },
+        {
+          "id": "6:3210152950802036889",
+          "name": "metadata",
+          "type": 9
+        },
+        {
+          "id": "7:5759813725018074825",
+          "name": "timestamp",
+          "type": 6
+        }
+      ],
+      "relations": []
+    }
+  ],
+  "lastEntityId": "8:3777768982988066495",
+  "lastIndexId": "16:330532365559818907",
+  "lastRelationId": "0:0",
+  "lastSequenceId": "0:0",
+  "modelVersion": 5,
+  "modelVersionParserMinimum": 5,
+  "retiredEntityUids": [],
+  "retiredIndexUids": [],
+  "retiredPropertyUids": [],
+  "retiredRelationUids": [],
+  "version": 1
+}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/proguard-rules.pro b/android/MobileTransformers/MobileTransformers/proguard-rules.pro
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/proguard-rules.pro
rename to android/MobileTransformers/MobileTransformers/proguard-rules.pro
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ConversationResetTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ConversationResetTest.kt
new file mode 100644
index 0000000..58a97c2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ConversationResetTest.kt
@@ -0,0 +1,99 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #23 device leg: map-driven load-and-generate over a real #9 package, plus the multi-turn
+ * conversation check (validates `ORTConversationState.addAssistantMessage` rendered-offset fix +
+ * `resetConversation()` on load + the KV-cache/position-ids continuation in `GenerationInputs`).
+ *
+ * **Three turns, not two, and the assertions are non-vacuous.** The previous version asserted
+ * `tokenCount >= 0` on two turns, which is true of every possible outcome — it could only ever catch a
+ * throw. It did catch one (the 4.57.6 `Gather` out-of-bounds), but an off-by-N in the position ids that
+ * merely *degrades* output would have passed silently, and a two-turn test can pass on an off-by-N that
+ * compounds only from the third turn onward.
+ */
+@RunWith(AndroidJUnit4::class)
+class ConversationResetTest {
+
+    private companion object {
+        const val MAX_NEW_TOKENS = 4
+    }
+
+    @Test
+    fun threeSequentialPromptsEachEmitTheRequestedTokens() = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val model = MobileTransformers.fromPretrained(ctx, repoId, cacheDir = root.absolutePath)
+        try {
+            val cfg = GenerationConfig(maxNewTokens = MAX_NEW_TOKENS)
+            val prompts = listOf("Name a color.", "Name an animal.", "Name a country.")
+
+            prompts.forEachIndexed { index, prompt ->
+                val turn = index + 1
+                val result = model.generate(prompt, cfg)
+
+                // A turn that inherits a corrupted prefix either throws (what 4.57.6 did) or returns
+                // early with nothing. Both are failures, and both are invisible to `tokenCount >= 0`.
+                assertTrue(
+                    "turn $turn produced blank text — the conversation state or the KV cache is corrupt",
+                    result.text.isNotBlank(),
+                )
+                // #24 locked maxNewTokens as an EXCLUSIVE bound: N means exactly N tokens, unless the
+                // model emits EOS first (legitimate, and it truncates rather than over-runs).
+                assertTrue(
+                    "turn $turn emitted ${result.tokenCount} tokens, more than the requested $MAX_NEW_TOKENS",
+                    result.tokenCount <= MAX_NEW_TOKENS,
+                )
+                assertTrue(
+                    "turn $turn emitted no tokens at all",
+                    result.tokenCount > 0,
+                )
+            }
+        } finally {
+            model.close()
+        }
+    }
+
+    @Test
+    fun aFreshSessionDoesNotInheritThePreviousConversation() = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        // SamplingConfig defaults to GREEDY, so this is deterministic without spelling it out.
+        val cfg = GenerationConfig(maxNewTokens = MAX_NEW_TOKENS)
+
+        // Same prompt, same greedy config, two independent sessions. `load()` calls
+        // `resetConversation()`, so the second session must reproduce the first exactly. If any
+        // conversation or KV state survived `close()`, the continuation would differ.
+        val first = generateOnce(ctx, repoId, root.absolutePath, cfg)
+        val second = generateOnce(ctx, repoId, root.absolutePath, cfg)
+
+        assertEquals("a fresh session did not start from a clean conversation state", first, second)
+    }
+
+    /** One prompt through a session opened and closed for it alone. */
+    private suspend fun generateOnce(
+        ctx: android.content.Context,
+        repoId: String,
+        cacheDir: String,
+        cfg: GenerationConfig,
+    ): String {
+        val model = MobileTransformers.fromPretrained(ctx, repoId, cacheDir = cacheDir)
+        try {
+            return model.generate("Name a color.", cfg).text
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DeviceModel.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DeviceModel.kt
new file mode 100644
index 0000000..cf2d9dd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DeviceModel.kt
@@ -0,0 +1,129 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.platform.app.InstrumentationRegistry
+import java.io.File
+import org.junit.Assume.assumeTrue
+
+/**
+ * Shared locator for the device (instrumented) suites. Probes the cache dirs `make device-package` pushes
+ * a real #9 package into, and `assumeTrue`-skips (never fails) when none is present — so a device-less or
+ * un-provisioned run stays green (Android device behaviour is manual per the test taxonomy). Mirrors the
+ * `GenAISpikeTest` candidate-dir pattern.
+ */
+object DeviceModel {
+    private const val LOG_TAG = "DeviceModel"
+    const val CACHE_SUBDIR = "mt_pkg"
+
+    /**
+     * The cache root containing `<sanitizedRepoId>/{inference,train,embedding,tokenizer}`, or null.
+     *
+     * The external files dir is probed first because that is where `scripts/device_package.sh` pushes:
+     * `/data/local/tmp` is SELinux-labelled `shell_data_file`, so the app domain can neither list it on
+     * a modern Android nor write into it (which the merge/checkpoint legs need). It stays in the list
+     * for a manually-provisioned run on an older device.
+     */
+    fun cacheRoot(): File? = candidates().firstOrNull { root -> installedPackages(root).isNotEmpty() }
+
+    private fun candidates(): List<File> {
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val external = ctx.getExternalFilesDir(null)
+        return listOfNotNull(
+            external?.let { File(it, CACHE_SUBDIR) },
+            File(ctx.filesDir, CACHE_SUBDIR),
+            File("/data/local/tmp/$CACHE_SUBDIR"),
+        )
+    }
+
+    /**
+     * Skip the test unless a package is present; returns the cache root when it is.
+     *
+     * The skip message names every candidate and what was wrong with it. A bare "no package" told you
+     * nothing about *why* — and since every device suite skips rather than fails, an un-diagnosable skip
+     * reads exactly like a pass in CI output.
+     */
+    fun requireCacheRoot(): File {
+        val root = cacheRoot()
+        if (root == null) {
+            val report = candidates().joinToString("; ") { "$it -> ${describe(it)}" }
+            Log.w(LOG_TAG, "no device package found. Candidates: $report")
+            assumeTrue(
+                "no device package under '$CACHE_SUBDIR' (run `make device-package`). Candidates: $report",
+                false,
+            )
+        }
+        return root!!
+    }
+
+    /** Why a candidate root was rejected, for the skip message. */
+    private fun describe(root: File): String = when {
+        !root.exists() -> "absent"
+        !root.isDirectory -> "not a directory"
+        root.listFiles() == null -> "unreadable (permission/SELinux)"
+        installedPackages(root).isEmpty() -> {
+            val children = root.list()?.joinToString(",") { name ->
+                val child = File(root, name)
+                val inf = File(child, "inference")
+                "$name[dir=${child.isDirectory},read=${child.canRead()}," +
+                    "inference=${inf.exists()}/${inf.isDirectory}]"
+            }
+            "no package dir with inference/ (children: ${children ?: "?"})"
+        }
+        else -> "ok"
+    }
+
+    /**
+     * The (already-sanitized) repo ids installed under [root], newest first.
+     *
+     * Only directories carrying an `inference/` subtree count — a bare directory (a half-finished push,
+     * or the vector store the RAG leg writes) is not a model package, and picking one would make the
+     * suites fail with an unrelated error instead of skipping.
+     */
+    private fun installedPackages(root: File): List<File> =
+        root.listFiles { f: File -> f.isDirectory && File(f, "inference").isDirectory }
+            ?.sortedByDescending { it.lastModified() }
+            .orEmpty()
+
+    /** The (already-sanitized) repo id of the installed package under the cache root. */
+    fun repoId(root: File): String = installedPackages(root).first().name
+
+    /** True iff the installed package carries a train-capable subtree (for the train→merge→generate legs). */
+    fun hasTraining(root: File, repoId: String): Boolean =
+        File(root, "$repoId/train/training_config.json").isFile
+
+    /**
+     * The task this package's inference graph was exported for, from the `optimum_config.json` the
+     * exporter writes beside the graph. Empty when the side-car is absent (a package from before it
+     * existed) — treated as "unknown", never guessed.
+     */
+    fun selectedTask(root: File, repoId: String): String {
+        val config = File(root, "$repoId/inference/optimum_config.json")
+        if (!config.isFile) return ""
+        return runCatching {
+            org.json.JSONObject(config.readText()).optString("task", "")
+        }.getOrDefault("")
+    }
+
+    /**
+     * True iff the package is a **decoder** — i.e. the generation suites can run against it.
+     *
+     * #33 put a second model shape on the device. A `text-classification` encoder package is
+     * train-capable and installs identically, so every generation suite would previously have run
+     * against it and failed at the first `generate()` on a graph with no token loop — failures that
+     * report a task mismatch as if it were a defect. The task is the honest discriminator: an unknown
+     * task counts as a decoder, so packages predating the side-car behave exactly as before.
+     */
+    fun isDecoder(root: File, repoId: String): Boolean {
+        val task = selectedTask(root, repoId)
+        return task.isEmpty() || task.startsWith("text-generation")
+    }
+
+    /** Skip the test unless the installed package is a decoder, naming the task that caused the skip. */
+    fun requireDecoder(root: File, repoId: String) {
+        assumeTrue(
+            "installed package '$repoId' was exported for task '${selectedTask(root, repoId)}', " +
+                "which has no token loop; this suite is decoder-only",
+            isDecoder(root, repoId),
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DualEngineParityTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DualEngineParityTest.kt
new file mode 100644
index 0000000..49cd9a7
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/DualEngineParityTest.kt
@@ -0,0 +1,158 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.SamplingConfig
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.runtime.GenAiSupport
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #11 + #24 device leg (Gate 0.1 #1): the SAME `inference/` package under the Native and GenAI engines
+ * must yield the same greedy first token. Skips unless the package carries a genai_config AND GenAI is
+ * available on the device.
+ */
+@RunWith(AndroidJUnit4::class)
+class DualEngineParityTest {
+
+    @Test
+    fun nativeAndGenaiAgreeOnGreedyFirstToken() = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue(
+            "package has no genai_config.json",
+            File(root, "$repoId/inference/genai_config.json").isFile,
+        )
+        assumeTrue("GenAI engine unavailable on this device", GenAiSupport.available())
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val greedy = GenerationConfig(maxNewTokens = 1, sampling = SamplingConfig(method = SamplingMethod.GREEDY))
+
+        val native = MobileTransformers.fromPretrained(ctx, repoId, cacheDir = root.absolutePath, engine = InferenceEngine.NATIVE)
+        val nativeText = try {
+            native.generate("Hello", greedy).text
+        } finally {
+            native.close()
+        }
+
+        val genai = MobileTransformers.fromPretrained(ctx, repoId, cacheDir = root.absolutePath, engine = InferenceEngine.GENAI)
+        // ModelRuntimeFactory falls back to Native transparently when GenAI cannot load. Without this
+        // assertion the test happily compared Native with Native and reported cross-engine parity —
+        // Gate 0.1 #1 "passing" while GenAI had never run. Fail instead of proving nothing.
+        assertEquals(
+            "requested GENAI but the runtime fell back (see logcat ModelRuntimeFactory); " +
+                "this test cannot demonstrate parity",
+            InferenceEngine.GENAI,
+            genai.capabilities.engine,
+        )
+        val genaiText = try {
+            genai.generate("Hello", greedy).text
+        } finally {
+            genai.close()
+        }
+
+        assertEquals("dual-engine greedy first-token mismatch", nativeText, genaiText)
+    }
+
+    /**
+     * #11 + #24 callback-sequence parity lock.
+     *
+     * [GenerateCallback]'s docstring promises every engine drives the *identical ordered sequence* —
+     * `onStartGeneration` → N×`onPartialResult` → `onCompletion` — but nothing asserted it, so the two
+     * engines could have differed in event order, in whether the final token also arrives as a partial,
+     * or in emitting a start event at all, and every test would still have passed.
+     *
+     * Recording the ordered event names (not just counts) is the point: a sequence that emits the right
+     * events in the wrong order, or completes before its last partial, is a real API break for a caller
+     * driving a UI off these callbacks.
+     */
+    @Test
+    fun bothEnginesEmitTheSameOrderedCallbackSequence(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue(
+            "package has no genai_config.json",
+            File(root, "$repoId/inference/genai_config.json").isFile,
+        )
+        assumeTrue("GenAI engine unavailable on this device", GenAiSupport.available())
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val greedy = GenerationConfig(
+            maxNewTokens = 6,
+            sampling = SamplingConfig(method = SamplingMethod.GREEDY),
+        )
+
+        fun sequenceFor(engine: InferenceEngine): List<String> = runBlocking {
+            val model = MobileTransformers.fromPretrained(
+                ctx, repoId, cacheDir = root.absolutePath, engine = engine,
+            )
+            // An explicitly requested engine no longer falls back silently, but assert anyway: a
+            // sequence recorded off the wrong engine would "prove" parity between Native and Native.
+            assertEquals(
+                "requested $engine but got ${model.capabilities.engine}",
+                engine,
+                model.capabilities.engine,
+            )
+            val events = mutableListOf<String>()
+            try {
+                model.generate(
+                    "The capital of France is",
+                    greedy,
+                    object : GenerateCallback {
+                        override fun onStartGeneration(progress: GenerateProgress) {
+                            events.add("start")
+                        }
+
+                        override fun onPartialResult(progress: GenerateProgress) {
+                            events.add("partial")
+                        }
+
+                        override fun onCompletion(progress: GenerateProgress) {
+                            events.add("completion")
+                        }
+
+                        override fun onError(error: Throwable) {
+                            events.add("error:${error::class.java.simpleName}")
+                        }
+                    },
+                )
+            } finally {
+                model.close()
+            }
+            events
+        }
+
+        val nativeEvents = sequenceFor(InferenceEngine.NATIVE)
+        val genaiEvents = sequenceFor(InferenceEngine.GENAI)
+
+        // The contract itself, checked on the floor engine before the engines are compared — otherwise
+        // two engines that are identically wrong would pass as "parity".
+        assertTrue("native emitted no callbacks at all", nativeEvents.isNotEmpty())
+        assertEquals("sequence must open with onStartGeneration", "start", nativeEvents.first())
+        assertEquals("sequence must close with onCompletion", "completion", nativeEvents.last())
+        assertTrue(
+            "no onPartialResult between start and completion: $nativeEvents",
+            nativeEvents.count { it == "partial" } > 0,
+        )
+        assertTrue(
+            "start/completion must occur exactly once: $nativeEvents",
+            nativeEvents.count { it == "start" } == 1 && nativeEvents.count { it == "completion" } == 1,
+        )
+
+        assertEquals(
+            "cross-engine callback sequence mismatch (ordered): native=$nativeEvents genai=$genaiEvents",
+            nativeEvents,
+            genaiEvents,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/EncoderTrainStepDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/EncoderTrainStepDeviceTest.kt
new file mode 100644
index 0000000..1bb641c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/EncoderTrainStepDeviceTest.kt
@@ -0,0 +1,163 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.federated.NativeCheckpointTensorStore
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import com.martinkorelic.mobiletransformers.repository.TrainingCallback
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #33 device leg: a real training step on an **encoder** package, on hardware.
+ *
+ * Provision with:
+ * ```
+ * make device-package MODEL=sentence-transformers/all-MiniLM-L6-v2 TASK=text-classification TRAIN=1 RAG=0
+ * ```
+ *
+ * ## What makes this different from the decoder train suites
+ *
+ * The objective, and therefore the data shape. A classification head supervises **one label per
+ * sequence** (`labels[batch]`), not one per token, so this drives the `TaskPreprocessor.classLabel` →
+ * `perSequenceLabel` → unpadded-collation path that no decoder suite touches. There is no `generate()`
+ * here at all: an encoder has no token loop, and asserting on generated text would be asserting the
+ * wrong contract (the decoder suites now skip on an encoder package for the same reason —
+ * `DeviceModel.requireDecoder`).
+ *
+ * ## What is asserted
+ *
+ * That the step **moved the adapter**, read back from the ORT checkpoint by name — not merely that
+ * training returned without throwing. A run that loads the graph, computes a loss and applies nothing
+ * looks identical from the outside, and that is not hypothetical: the #36 round-trip found exactly
+ * that shape, where `gradAccumSteps` defaulting to 4 made a short run accumulate gradients it never
+ * applied.
+ *
+ * Hermetic: trains with `saveModelAtEnd = false` / `mergeWeightsAtEnd = false`, so neither the
+ * checkpoint nor the inference weights on disk are touched.
+ */
+@RunWith(AndroidJUnit4::class)
+class EncoderTrainStepDeviceTest {
+
+    @Test
+    fun oneTrainStepMovesTheEncodersAdapter(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        val task = DeviceModel.selectedTask(root, repoId)
+        assumeTrue(
+            "installed package '$repoId' was exported for task '$task'; this suite needs an encoder " +
+                "package (make device-package TASK=text-classification TRAIN=1)",
+            task == "text-classification",
+        )
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val paths = PackagePaths.forCache(root.absolutePath, repoId)
+
+        // A separable two-class set, the same fixture shape the host gate uses. `cola_cls` is the
+        // preprocessor that keeps the label a CLASS INDEX instead of stringifying it for a decoder.
+        val trainFile = "mt_encoder_cls"
+        File(paths.train, "$trainFile.jsonl").writeText(
+            listOf(
+                """{"sentence": "this film was wonderful", "label": 1}""",
+                """{"sentence": "an absolute delight to watch", "label": 1}""",
+                """{"sentence": "brilliant and moving", "label": 1}""",
+                """{"sentence": "a masterpiece of storytelling", "label": 1}""",
+                """{"sentence": "this film was terrible", "label": 0}""",
+                """{"sentence": "a complete waste of time", "label": 0}""",
+                """{"sentence": "boring and painfully dull", "label": 0}""",
+                """{"sentence": "an awful, incoherent mess", "label": 0}""",
+            ).joinToString("\n") + "\n",
+        )
+
+        val tokenizer = ORTTokenizerNative(paths.tokenizer.absolutePath)
+        tokenizer.createTokenizerModel()
+        val trainer = ORTTrainerNative(
+            ctx,
+            root.absolutePath,
+            tokenizer,
+            ORTTrainingConfig(
+                repoName = repoId,
+                taskName = "cola_cls",
+                batchSize = 2,
+                maxSteps = 2,
+                // See the #36 round-trip: `optimizerStep` fires on `globalStep % gradAccumSteps == 0`
+                // and never at step 0, so the shipping default of 4 would apply nothing in 2 steps.
+                gradAccumSteps = 1,
+                // Hermetic: leave the package exactly as pushed.
+                mergeWeightsAtEnd = false,
+                saveModelAtEnd = false,
+                loadFromState = false,
+                keepSessionAtEnd = true,
+                datasetOptions = DatasetOptions(
+                    trainFile = trainFile,
+                    datasetBatchSize = 2,
+                    maxDatasetLength = 8,
+                    maxSequenceLength = 64,
+                ),
+            ),
+        )
+
+        try {
+            assertTrue(
+                "no native training session was created for the encoder package",
+                trainer.trainingSessionHandle() != 0L,
+            )
+
+            // The trainable factors, by their checkpoint names, straight from the package's own
+            // handoff map — nothing here re-derives a layer identity.
+            val handoff = WeightHandoffMap.load(paths.weightHandoff)
+            val specs = handoff.adapterTensorSpecs()
+            assertTrue("the encoder package declares no adapter factors", specs.isNotEmpty())
+
+            val store = NativeCheckpointTensorStore(trainer)
+            val before = specs.associate { it.name to (store.read(it.name) ?: ByteArray(0)) }
+            assertTrue(
+                "no adapter factor could be read from the encoder checkpoint: " +
+                    "${specs.take(2).map { it.name }}",
+                before.values.all { it.isNotEmpty() },
+            )
+
+            val losses = mutableListOf<Float>()
+            trainer.startTraining(object : TrainingCallback {
+                override fun onStepEnd(trainingProgress: TrainingProgress) {
+                    losses += trainingProgress.stepLoss
+                }
+            })
+
+            assertTrue("no training step ran", losses.isNotEmpty())
+            assertTrue(
+                "training produced a non-finite loss: $losses",
+                losses.all { it.isFinite() },
+            )
+
+            val moved = specs.count { spec ->
+                val after = store.read(spec.name)
+                after != null && !after.contentEquals(before.getValue(spec.name))
+            }
+            assertTrue(
+                "the train step moved none of the ${specs.size} adapter factors — the graph loaded " +
+                    "and a loss was computed, but no update was applied",
+                moved > 0,
+            )
+            Log.i(
+                TAG,
+                "encoder train step: ${losses.size} step(s), losses=$losses, " +
+                    "$moved/${specs.size} adapter factors moved",
+            )
+        } finally {
+            trainer.destroySession(false)
+            File(paths.train, "$trainFile.jsonl").delete()
+        }
+    }
+
+    private companion object {
+        const val TAG = "EncoderTrainStepDeviceTest"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FacadeLoadGenerateTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FacadeLoadGenerateTest.kt
new file mode 100644
index 0000000..04d728d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FacadeLoadGenerateTest.kt
@@ -0,0 +1,35 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** #17 device leg: fromPretrained → generate one token over a pushed package. */
+@RunWith(AndroidJUnit4::class)
+class FacadeLoadGenerateTest {
+
+    @Test
+    fun fromPretrainedGeneratesAndReportsInferenceFeature() = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+        )
+        try {
+            assertTrue(model.capabilities.availableFeatures.contains(ModelFeature.Inference))
+            val result = model.generate("Hello", GenerationConfig(maxNewTokens = 1))
+            assertTrue("generation produced no tokens", result.tokenCount >= 0)
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FederatedRoundDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FederatedRoundDeviceTest.kt
new file mode 100644
index 0000000..4aa00fb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/FederatedRoundDeviceTest.kt
@@ -0,0 +1,349 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.federated.AdapterTensorCodec
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConsent
+import com.martinkorelic.mobiletransformers.federated.FederatedTrainingRepository
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.federated.NativeCheckpointTensorStore
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+/**
+ * #36 device round-trip: export adapter factors from a REAL checkpoint on hardware, and import a
+ * gateway-produced aggregate back into it.
+ *
+ * ## Why this is two tests and not one
+ *
+ * The middle of the round is a host process (`mobiletransformers federated serve`), so the seam cannot
+ * be crossed inside a single instrumentation run. `scripts/federated_round_device.sh` drives it:
+ *
+ * ```
+ * phase1ExportsUpdate  →  adb pull  →  federated serve (2 clients)  →  adb push  →  phase2ImportsAggregate
+ * ```
+ *
+ * Each phase `assumeTrue`-skips without its input, so an ordinary `make device-test` run reports them
+ * as skipped rather than failing — and running phase 2 alone, with a stale global record, is not
+ * possible: the record's tensor names, shapes and `adapterFormatVersion` are checked against this
+ * package's own handoff map.
+ *
+ * ## What is actually asserted
+ *
+ * The seam, not either half of it. Every existing check on this path — the byte golden, the codec
+ * round-trip, the gateway's own tests — verifies one side in isolation, which is exactly the failure
+ * shape this project keeps paying for. So phase 2 asserts that after the round **every declared
+ * checkpoint tensor holds the aggregate's bytes**, that they did NOT hold them beforehand (otherwise
+ * the assertion could not fail), and that the values survive a session teardown and reload — i.e. that
+ * the checkpoint on disk moved, not just an in-memory copy of it.
+ *
+ * ## Hermetic
+ *
+ * Phase 2 writes the checkpoint, and the merge/convergence suites need a pristine one. The checkpoint
+ * and training state are stashed and restored whatever happens, the same discipline
+ * `ScheduledTrainingDeviceTest` follows.
+ */
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class FederatedRoundDeviceTest {
+
+    private val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Test
+    fun phase1ExportsAnUpdateFromTheRealCheckpoint(): Unit = runBlocking {
+        val fixture = requireFederationFixture()
+
+        val trainer = openTrainer(fixture)
+        try {
+            val repository = FederatedTrainingRepository.forSession(
+                config = fixture.config,
+                handoff = fixture.handoff,
+                trainer = trainer,
+                localTraining = object : LocalRoundTraining {
+                    // "Bounded" is the caller's ORTTrainingConfig (maxSteps = 1 here); the federated
+                    // layer only guarantees training happens between the import and the export.
+                    override suspend fun trainOneRound(round: Int) = trainer.startTraining(null)
+                },
+                baseModelId = fixture.repoId,
+                packageRevision = fixture.handoff.schemaVersion,
+            )
+
+            // Round 0: nothing to import yet — a device must be able to join a cohort before any
+            // aggregate exists.
+            val result = repository.runRound(
+                globalRecord = null,
+                roundNumber = 0,
+                metrics = mapOf("numExamples" to 8.0),
+            )
+
+            val record = AdapterTensorCodec.deserialize(result.update)
+            val declared = fixture.handoff.adapterTensorSpecs()
+            assertEquals(
+                "the record must carry exactly the factors the package declares",
+                declared.size,
+                record.tensors.size,
+            )
+            assertEquals(declared.map { it.name }, record.tensors.map { it.name })
+            assertTrue("round 0 must not import anything", result.importedTensors == 0)
+            assertTrue("local training must have run", result.trainedLocally)
+
+            fixture.updateFile.parentFile?.mkdirs()
+            fixture.updateFile.writeBytes(result.update)
+
+            // The #36 DoD asks for the on-device LoRA communication size to be MEASURED. Reported here
+            // rather than asserted against a threshold: the number depends on the model, and an
+            // absolute bound would encode this one fixture.
+            Log.i(
+                TAG,
+                "round 0: ${record.tensors.size} factors, upload payload ${result.payloadBytes} B " +
+                    "(${"%.2f".format(result.payloadBytes / 1024.0 / 1024.0)} MiB) -> ${fixture.updateFile}",
+            )
+        } finally {
+            // save=false: phase 1 must not leave the package trained.
+            trainer.destroySession(false)
+        }
+    }
+
+    @Test
+    fun phase2ImportsTheAggregateIntoTheRealCheckpoint(): Unit = runBlocking {
+        val fixture = requireFederationFixture()
+        assumeTrue(
+            "no aggregated record at ${fixture.globalFile} — run scripts/federated_round_device.sh, " +
+                "which pulls phase 1's update, aggregates it with `federated serve`, and pushes the " +
+                "global record back",
+            fixture.globalFile.isFile,
+        )
+
+        val global = fixture.globalFile.readBytes()
+        val expected = AdapterTensorCodec.deserialize(global).tensors.associate { it.name to it.payload }
+        val specs = fixture.handoff.adapterTensorSpecs()
+        assertEquals(
+            "the aggregate must describe exactly this package's factors",
+            specs.size,
+            expected.size,
+        )
+
+        val trainDir = File(fixture.root, "${fixture.repoId}/train")
+        val backup = File(ctx.cacheDir, "federated_backup").apply { deleteRecursively(); mkdirs() }
+        val checkpoint = File(trainDir, "checkpoint")
+        val stateFile = File(trainDir, "training_state.json")
+        checkpoint.copyRecursively(File(backup, "checkpoint"), overwrite = true)
+        if (stateFile.isFile) stateFile.copyTo(File(backup, "training_state.json"), overwrite = true)
+
+        try {
+            importAndVerify(fixture, global, expected, specs.map { it.name })
+        } finally {
+            checkpoint.deleteRecursively()
+            File(backup, "checkpoint").copyRecursively(checkpoint, overwrite = true)
+            stateFile.delete()
+            File(backup, "training_state.json").takeIf { it.isFile }?.copyTo(stateFile, overwrite = true)
+            backup.deleteRecursively()
+            File(trainDir, "$TRAIN_FIXTURE.jsonl").delete()
+            Log.i(TAG, "restored the package's checkpoint + training state")
+        }
+    }
+
+    private suspend fun importAndVerify(
+        fixture: Fixture,
+        global: ByteArray,
+        expected: Map<String, ByteArray>,
+        names: List<String>,
+    ) {
+        var exportedAfterTraining = 0
+        val trainer = openTrainer(fixture)
+        try {
+            val store = NativeCheckpointTensorStore(trainer)
+
+            // Self-calibrating: if the checkpoint already held the aggregate, the assertion below could
+            // not fail and would prove nothing.
+            val differedBefore = names.count { name ->
+                val before = store.read(name)
+                before != null && !before.contentEquals(expected.getValue(name))
+            }
+            assertTrue(
+                "the local checkpoint already equals the aggregate for every tensor, so importing it " +
+                    "cannot be observed. Re-run phase 1 against a checkpoint that has diverged.",
+                differedBefore > 0,
+            )
+
+            val repository = FederatedTrainingRepository.forSession(
+                config = fixture.config,
+                handoff = fixture.handoff,
+                trainer = trainer,
+                localTraining = object : LocalRoundTraining {
+                    override suspend fun trainOneRound(round: Int) = trainer.startTraining(null)
+                },
+                baseModelId = fixture.repoId,
+                packageRevision = fixture.handoff.schemaVersion,
+            )
+
+            // train=false so the assertion below is EXACT. The trained round follows separately.
+            val imported = repository.runRound(global, roundNumber = 1, train = false)
+            assertEquals("every declared factor must be written", names.size, imported.importedTensors)
+
+            val mismatched = names.filter { name ->
+                val after = store.read(name)
+                after == null || !after.contentEquals(expected.getValue(name))
+            }
+            assertTrue(
+                "after the round these checkpoint tensors do not hold the aggregate's bytes: " +
+                    "${mismatched.take(3)} (${mismatched.size}/${names.size})",
+                mismatched.isEmpty(),
+            )
+            Log.i(
+                TAG,
+                "round 1: imported ${imported.importedTensors} factors from ${global.size} B; " +
+                    "$differedBefore/${names.size} tensors changed value",
+            )
+
+            // The DoD's full round on top of the imported adapter: import → bounded local train →
+            // export. The export is what a real client would upload for round 2.
+            val trained = repository.runRound(null, roundNumber = 2, train = true)
+            exportedAfterTraining = trained.payloadBytes
+
+            // Compared against round 1's EXPORT, not against the aggregate. Both records have been
+            // through the same clipping, so what differs between them is training and nothing else —
+            // comparing to the aggregate would count every tensor the clip rescaled as "trained".
+            val beforeTraining = AdapterTensorCodec.deserialize(imported.update)
+                .tensors.associate { it.name to it.payload }
+            val movedByTraining = AdapterTensorCodec.deserialize(trained.update).tensors.count { tensor ->
+                !tensor.payload.contentEquals(beforeTraining.getValue(tensor.name))
+            }
+            assertTrue(
+                "local training after the import moved no factor at all; the exported update would be " +
+                    "the global adapter handed straight back",
+                movedByTraining > 0,
+            )
+            Log.i(
+                TAG,
+                "round 2: $movedByTraining/${names.size} factors moved by local training, " +
+                    "upload payload $exportedAfterTraining B",
+            )
+        } finally {
+            // save=true: the point of this leg is that the checkpoint on DISK moved.
+            trainer.destroySession(true)
+        }
+
+        // Reload from disk. Without this the round would only be proven against an in-memory
+        // CheckpointState — `UpdateParameter` writes there, and a save that never happened would look
+        // identical from inside the same session.
+        val reopened = openTrainer(fixture)
+        try {
+            val store = NativeCheckpointTensorStore(reopened)
+            val survived = names.count { name -> store.read(name) != null }
+            assertEquals("every factor must still be readable after a reload", names.size, survived)
+            Log.i(TAG, "reloaded the saved checkpoint: $survived/${names.size} factors present")
+        } finally {
+            reopened.destroySession(false)
+        }
+        assertTrue("round 2 produced no payload", exportedAfterTraining > 0)
+    }
+
+    /** Everything both phases need, or a skip explaining which precondition is missing. */
+    private fun requireFederationFixture(): Fixture {
+        assumeTrue(
+            "this build has FEDERATION_ENABLED=false (the shipping default). Re-run with " +
+                "`-PmtFederationEnabled=true`, or use scripts/federated_round_device.sh.",
+            FederatedConfig.FEDERATION_ENABLED,
+        )
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val paths = PackagePaths.forCache(root.absolutePath, repoId)
+        val handoff = WeightHandoffMap.load(File(paths.inference, WeightHandoffMap.FILENAME))
+        val federatedDir = File(root, "federated")
+
+        // The package ships model artifacts, not data — same fixture shape as the other train suites.
+        File(paths.train, "$TRAIN_FIXTURE.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "Federated round sentence number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        return Fixture(
+            root = root,
+            repoId = repoId,
+            handoff = handoff,
+            updateFile = File(federatedDir, "client_update.bin"),
+            globalFile = File(federatedDir, "global_record.bin"),
+            config = FederatedConfig(
+                // No round in this test reaches a network — the gateway is a host process reached over
+                // adb. The URL and token are here because `requireRoundIsPermitted` demands them, and
+                // that demand is the feature under test everywhere else.
+                gatewayUrl = "https://localhost/round",
+                clientAuthToken = "device-test-token",
+                consent = FederatedConsent(
+                    granted = true,
+                    policyVersion = "1.0",
+                    grantedAtEpochMs = System.currentTimeMillis(),
+                ),
+            ),
+        )
+    }
+
+    private suspend fun openTrainer(fixture: Fixture): ORTTrainerNative {
+        val paths = PackagePaths.forCache(fixture.root.absolutePath, fixture.repoId)
+        val tokenizer = ORTTokenizerNative(paths.tokenizer.absolutePath)
+        tokenizer.createTokenizerModel()
+        return ORTTrainerNative(
+            ctx,
+            fixture.root.absolutePath,
+            tokenizer,
+            ORTTrainingConfig(
+                repoName = fixture.repoId,
+                taskName = "cola",
+                batchSize = 2,
+                // `optimizerStep` fires only on `globalStep % gradAccumSteps == 0` (and never at step
+                // 0), so the SHIPPING default of 4 accumulation steps means a 1-step round applies no
+                // update at all: the device would upload the global adapter back unchanged while every
+                // callback reported a successful training run. A bounded federated round must either
+                // exceed the accumulation window or turn accumulation off; it does the latter here.
+                maxSteps = 2,
+                gradAccumSteps = 1,
+                // All three defaults are ON and all three would mutate the shared package: the merge
+                // rewrites inference/*.bin (breaking TrainMergeGenerateTest), the save rewrites the
+                // checkpoint, and loading a previous state would make "what this round did" depend on
+                // what a previous suite left behind.
+                mergeWeightsAtEnd = false,
+                saveModelAtEnd = false,
+                loadFromState = false,
+                // #36: `startTraining` otherwise releases the session on its way out, and the export
+                // half of the round reads the checkpoint of a LIVE session. This is the seam the
+                // first device run found: training and federated export were each fine alone.
+                keepSessionAtEnd = true,
+                datasetOptions = DatasetOptions(
+                    trainFile = TRAIN_FIXTURE,
+                    datasetBatchSize = 2,
+                    maxDatasetLength = 8,
+                    maxSequenceLength = 64,
+                ),
+            ),
+        )
+    }
+
+    private data class Fixture(
+        val root: File,
+        val repoId: String,
+        val handoff: WeightHandoffMap,
+        val updateFile: File,
+        val globalFile: File,
+        val config: FederatedConfig,
+    )
+
+    private companion object {
+        const val TAG = "FederatedRoundDeviceTest"
+        const val TRAIN_FIXTURE = "mt_federated_cola"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/GenAISpikeTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/GenAISpikeTest.kt
new file mode 100644
index 0000000..50c6280
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/GenAISpikeTest.kt
@@ -0,0 +1,127 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+/**
+ * #10 Gate 0.1 device manual leg — the GenAI external-data-swap smoke.
+ *
+ * **Setup (user):** push a File #9 inference package (`model.onnx` + `genai_config.json` + external data +
+ * `weight_handoff_map.json`) to the test app's external files dir, then run this test:
+ *
+ *   adb push <inference_dir>  /sdcard/Android/data/com.martinkorelic.mobiletransformers.test/files/mt_genai_spike/inference
+ *   ./gradlew :MobileTransformers:connectedDebugAndroidTest \
+ *       -Pandroid.testInstrumentationRunnerArguments.class=com.martinkorelic.mobiletransformers.GenAISpikeTest
+ *
+ * The test skips (assumeTrue) with the exact expected path if no package is present, so the suite never
+ * hard-fails for lack of a model. When present it proves:
+ *  - GenAI resolves relative external data in the package dir (OgaCreateModel succeeds, token generated);
+ *  - a fresh OgaCreateModel reflects overwritten external `.bin` bytes (fingerprint differs) — F2 / Gate 0.1 #2,#3,#5.
+ */
+@RunWith(AndroidJUnit4::class)
+class GenAISpikeTest {
+
+    private fun candidateDirs(): List<File> {
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        // External files dir FIRST, and only writable candidates: this test mutates the package in
+        // place (it backs a weight up to `.spikebak`, perturbs it, then restores). `/data/local/tmp` is
+        // SELinux `shell_data_file` — a stale copy there was being picked ahead of the writable dir and
+        // the test died with `EACCES` on the backup, not on anything it was trying to prove.
+        return listOf(
+            File(ctx.getExternalFilesDir("mt_genai_spike"), "inference"),
+            File(ctx.filesDir, "mt_genai_spike/inference"),
+            File("/data/local/tmp/mt_genai_spike/inference"),
+        ).filter { it.parentFile?.canWrite() ?: false }
+    }
+
+    @Test
+    fun genaiResolvesExternalDataAndSwapIsObserved() {
+        val candidates = candidateDirs()
+        val dir = candidates.firstOrNull { File(it, "genai_config.json").isFile }
+        assumeTrue(
+            "push a File #9 package to one of: " +
+                candidates.joinToString { "${it.absolutePath} (found=${File(it, "genai_config.json").isFile})" } +
+                " — see class KDoc; skipping",
+            dir != null,
+        )
+        dir!!
+
+        // 1) baseline — proves relative external data resolves and a token generates
+        val base = GenAISpike.parse(GenAISpike.runOneToken(dir.absolutePath, "Hello world"))
+        assertTrue("GenAI load/generate failed: $base", base.containsKey("token"))
+        assertNotEquals("-1", base["token"]) // a real token id
+
+        // 2) perturb exactly one external weight (never frozen_base.onnx.data), then re-run FRESH
+        val target = pickExternalWeight(dir)
+        val backup = File(target.parentFile, target.name + ".spikebak")
+        target.copyTo(backup, overwrite = true)
+        try {
+            perturb(target)
+            val swap = GenAISpike.parse(GenAISpike.runOneToken(dir.absolutePath, "Hello world"))
+            assertTrue("GenAI reload failed after swap: $swap", swap.containsKey("fp"))
+            // Gate 0.1 #2/#3: overwriting external bytes changes the logits on a fresh model.
+            assertNotEquals(
+                "external swap had NO effect — trainable externals folded or copied (Gate 0.1 FAIL)",
+                base["fp"],
+                swap["fp"],
+            )
+        } finally {
+            backup.copyTo(target, overwrite = true)
+            backup.delete()
+        }
+    }
+
+    /** The per-tensor `.bin` for the first handoff entry, or the largest non-base external file. */
+    private fun pickExternalWeight(dir: File): File {
+        val handoff = File(dir, "weight_handoff_map.json")
+        if (handoff.isFile) {
+            val text = handoff.readText()
+            // cheap extract of the first externalDataLocation value (avoids a JSON dep in the test)
+            val marker = "\"externalDataLocation\""
+            val idx = text.indexOf(marker)
+            if (idx >= 0) {
+                val rel = Regex("\\\"([^\\\"]+\\.bin)\\\"").find(text.substring(idx))?.groupValues?.get(1)
+                if (rel != null) return File(dir, rel)
+            }
+        }
+        return dir.listFiles { f ->
+            (f.name.endsWith(".bin") || f.name.endsWith(".data")) && f.name != "frozen_base.onnx.data"
+        }?.maxByOrNull { it.length() } ?: error("no external weight file to perturb in $dir")
+    }
+
+    /** Simulate a merge delta: scale a wide contiguous float32 region by 1.5 (matches desktop_spike.py) so
+     *  on-path weights change measurably — a few low-mantissa flips can land entirely in unused embedding
+     *  rows and no-op. NaN/Inf clamped. Refreshes a sibling .sha256 if present. */
+    private fun perturb(target: File) {
+        val bytes = target.readBytes()
+        val n = bytes.size
+        val start = (n / 10) * 3                 // 30% in — past most of the embedding table
+        var span = minOf(8 * 1024 * 1024, n - start)
+        span -= span % 4
+        val bb = java.nio.ByteBuffer.wrap(bytes, start, span).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+        var i = 0
+        while (i < span) {
+            val v = bb.getFloat(start + i) * 1.5f
+            val clamped = when {
+                v.isNaN() -> 0f
+                v > 1e4f -> 1e4f
+                v < -1e4f -> -1e4f
+                else -> v
+            }
+            bb.putFloat(start + i, clamped)
+            i += 4
+        }
+        target.writeBytes(bytes)
+        val sha = File(target.parentFile, target.name + ".sha256")
+        if (sha.exists()) {
+            val digest = java.security.MessageDigest.getInstance("SHA-256").digest(bytes)
+            sha.writeText(digest.joinToString("") { "%02x".format(it) } + "\n")
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/HubPullDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/HubPullDeviceTest.kt
new file mode 100644
index 0000000..0952559
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/HubPullDeviceTest.kt
@@ -0,0 +1,163 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #21's missing device leg: pull a package **from the Hugging Face Hub onto the phone** and load it.
+ *
+ * ### Why this did not exist
+ *
+ * Every other device suite runs against a package `adb push`ed by `scripts/device_package.sh`, so the
+ * entire download half — [com.martinkorelic.mobiletransformers.hub.HubResolver],
+ * `DownloadPlanner`, `PackageDownloader`, `PackageDownloadWorker`, `ModelPackageInstaller` — had only
+ * ever been exercised on the JVM against MockWebServer. That is localhost, in a process with no Android
+ * permission model, which is why nothing caught that the library manifest did not declare
+ * `android.permission.INTERNET`: the code could not have worked on any device, and no test could see it.
+ *
+ * This test is the one that would have. It calls the same entry point an integrator calls, with **no
+ * package pre-installed**, so the pull is what is under test rather than an afterthought.
+ *
+ * ### Running it
+ *
+ * ```
+ * make device-hub-test REPO=<org>/<name>
+ * ```
+ *
+ * It `assumeTrue`-skips without `mtHubRepoId`, matching [DeviceModel]'s skip-don't-fail convention so
+ * `make device-test` stays green without one. A repo id that is present but wrong must **fail**, not
+ * skip — a test that skips on a bad id is indistinguishable from no test at all.
+ */
+@RunWith(AndroidJUnit4::class)
+class HubPullDeviceTest {
+
+    private companion object {
+        const val LOG_TAG = "HubPullDeviceTest"
+
+        /** Instrumentation args: `-e mtHubRepoId <id>` (+ optional `-e mtHubToken <token>`). */
+        const val ARG_REPO_ID = "mtHubRepoId"
+        const val ARG_TOKEN = "mtHubToken"
+    }
+
+    /**
+     * A cache root of this test's OWN, never the `mt_pkg` one the other suites read.
+     *
+     * Sharing it would let a Hub pull overwrite the pushed package that `PristinePackageRule` exists to
+     * keep pristine, and a 1.3 GB download landing on top of the suite's fixture would be a
+     * spectacularly confusing way to fail an unrelated test.
+     */
+    private val cacheRoot: File
+        get() = File(
+            InstrumentationRegistry.getInstrumentation().targetContext.getExternalFilesDir(null),
+            "mt_hub_pull",
+        )
+
+    @After
+    fun removeTheDownloadedPackage() {
+        // A real package is over a gigabyte. Leaving it behind would starve every later suite of the
+        // free space `scripts/device_package.sh` checks for before it will push anything.
+        cacheRoot.deleteRecursively()
+    }
+
+    @Test
+    fun pullsAPackageFromTheHubInstallsItAndGenerates() = runBlocking {
+        val args = InstrumentationRegistry.getArguments()
+        val repoId = args.getString(ARG_REPO_ID)
+        assumeFalse(
+            "no '$ARG_REPO_ID' instrumentation argument — run `make device-hub-test REPO=<org>/<name>` " +
+                "to exercise the Hub pull. Skipping is correct here: the package under test lives on " +
+                "the network, not in this checkout.",
+            repoId.isNullOrBlank(),
+        )
+        val token = args.getString(ARG_TOKEN)?.takeIf { it.isNotBlank() }
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        cacheRoot.deleteRecursively()
+        cacheRoot.mkdirs()
+
+        // Nothing is installed: this is the cold-start path a new user is on, and the only one that
+        // exercises the download at all.
+        val modelDir = File(cacheRoot, PackageFormat.sanitizeRepoId(repoId!!))
+        assertTrue("precondition: the cache must start empty", !modelDir.exists())
+
+        var lastLoggedDecile = -1
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = cacheRoot.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            hubConfig = token?.let { HubConfig(token = it) },
+            onDownloadProgress = { p ->
+                // One line per 10%: a 200-file package would otherwise bury the logcat this test is
+                // read from, and the per-file path is what makes a stall diagnosable.
+                val decile = if (p.filesTotal > 0) p.filesDone * 10 / p.filesTotal else 0
+                if (decile > lastLoggedDecile) {
+                    lastLoggedDecile = decile
+                    Log.i(LOG_TAG, "downloaded ${p.filesDone}/${p.filesTotal} — ${p.path}")
+                }
+            },
+        )
+
+        try {
+            // 1. The installer produced the layout `LLMRepository` probes, not just "some files".
+            for (expected in listOf("inference", "train", "tokenizer")) {
+                assertTrue(
+                    "installed package has no $expected/ under $modelDir " +
+                        "(present: ${modelDir.list()?.joinToString()})",
+                    File(modelDir, expected).isDirectory,
+                )
+            }
+            assertTrue(
+                "installed package has no manifest — the installer copies it, and its absence means " +
+                    "variant selection and capability reporting have nothing to read",
+                File(modelDir, PackageFormat.MANIFEST_FILENAME).isFile,
+            )
+
+            // 2. The staging trees are GONE. Both are full copies of the package, so a leak here is
+            //    over a gigabyte of dead weight per pull — it used to survive until the next pull of
+            //    the same repo.
+            val sanitized = PackageFormat.sanitizeRepoId(repoId)
+            assertTrue(
+                "download staging .download/$sanitized survived the install",
+                !File(cacheRoot, ".download/$sanitized").exists(),
+            )
+            assertTrue(
+                "install staging .staging/$sanitized survived the install",
+                !File(cacheRoot, ".staging/$sanitized").exists(),
+            )
+
+            // 3. The features that were REQUESTED are the ones reported — a train group that silently
+            //    did not download would otherwise only surface when training failed much later.
+            assertTrue(
+                "pulled package does not report Inference (features: " +
+                    "${model.capabilities.availableFeatures})",
+                ModelFeature.Inference in model.capabilities.availableFeatures,
+            )
+            assertTrue(
+                "pulled package does not report training support although the train feature was " +
+                    "requested (features: ${model.capabilities.availableFeatures})",
+                model.capabilities.supportsTraining,
+            )
+
+            // 4. It actually runs. Everything above is structural; this is the one that proves the
+            //    downloaded bytes are a working model and not a well-shaped directory.
+            val result = model.generate("Hello", GenerationConfig(maxNewTokens = 4))
+            Log.i(LOG_TAG, "generated ${result.tokenCount} tokens: ${result.text.take(120)}")
+            assertTrue("generation produced no tokens from the pulled package", result.tokenCount > 0)
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/MemoryRssTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/MemoryRssTest.kt
new file mode 100644
index 0000000..af65a6d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/MemoryRssTest.kt
@@ -0,0 +1,136 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.SamplingConfig
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.runtime.GenAiSupport
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.MemoryProbe
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #12 Gate 0.2 + #10 Gate 0.1 #4: the resident-memory table both gates are specified against.
+ *
+ * Records `VmRSS` at the four measurement points the mmap plan fixes — (1) before load, (2) after weight
+ * load, (3) after first token, (4) after release — for whichever engine and weight-load path the run is
+ * configured for, and writes one JSON row per run to the app's external files dir.
+ *
+ * **Two knobs, both outside the test process**, so the full 2x2 table is four runs joined on the host
+ * (`make device-rss` does this):
+ *  - engine: [nativeFourPointTable] / [genAiFourPointTable]
+ *  - weight load: `adb shell setprop debug.mtf.mmap_weights 1` (default off = the shipping copy path)
+ *
+ * The gate comparisons live on the host because a single process cannot hold two independent baselines:
+ * loading a second model never returns RSS to its starting point. What *is* asserted in-process is the
+ * part that needs no cross-run state — that memory actually grew at load (so a run that silently failed
+ * to load cannot be recorded as a flattering measurement), and that the mmap toggle resolved to what the
+ * operator set.
+ *
+ * The thresholds are the project's ratified memory-gate figures, restated in `scripts/device_rss.sh`
+ * where they are actually applied — this test only produces the rows.
+ */
+@RunWith(AndroidJUnit4::class)
+class MemoryRssTest {
+
+    private companion object {
+        const val LOG_TAG = "MemoryRssTest"
+
+        /** Gate 0.1 #4: GenAI may exceed the Native baseline by this ratio... */
+        const val ACCEPTED_RSS_DELTA_RATIO = 0.20
+
+        /** ...or this many KiB, whichever is larger (noise floor on a small package). */
+        const val ACCEPTED_RSS_DELTA_FLOOR_KB = 64L * 1024
+
+        /** Gate 0.2: mmap must cut peak RSS by at least this much versus the copy path. */
+        const val GATE_02_REQUIRED_REDUCTION = 0.15
+    }
+
+    private fun runTable(engine: InferenceEngine): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        assumeTrue("RSS probe unavailable (/proc/self/status unreadable)", MemoryProbe.currentRssKb() > 0)
+
+        val mmap = MemoryProbe.mmapWeightsEnabled()
+        val greedy = GenerationConfig(
+            maxNewTokens = 1,
+            sampling = SamplingConfig(method = SamplingMethod.GREEDY),
+        )
+
+        val preLoad = MemoryProbe.currentRssKb()
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            engine = engine,
+        )
+        val postLoad = MemoryProbe.currentRssKb()
+
+        // Record the engine that ACTUALLY loaded, not the one asked for. Labelling the row with the
+        // request is how two Native measurements were once published as a Native-vs-GenAI comparison.
+        // The explicit-request path now fails loudly rather than falling back, so this should never
+        // differ — assert that rather than assume it.
+        val actualEngine = model.capabilities.engine
+        assertEquals(
+            "requested $engine but the runtime provided $actualEngine; this row would misreport",
+            engine,
+            actualEngine,
+        )
+
+        val postFirstToken: Long
+        try {
+            model.generate("Hello", greedy)
+            postFirstToken = MemoryProbe.currentRssKb()
+        } finally {
+            model.close()
+        }
+        val postRelease = MemoryProbe.currentRssKb()
+
+        // A load that quietly did nothing would otherwise be recorded as an excellent RSS result.
+        assertTrue(
+            "RSS did not grow at weight load (pre=$preLoad post=$postLoad kB) — did the model load?",
+            postLoad > preLoad,
+        )
+
+        val row = """
+            {"engine":"${actualEngine.name.lowercase()}","mmapWeights":$mmap,
+             "preLoadKb":$preLoad,"postWeightLoadKb":$postLoad,
+             "postFirstTokenKb":$postFirstToken,"postReleaseKb":$postRelease,
+             "peakKb":${maxOf(postLoad, postFirstToken)},
+             "acceptedRssDeltaRatio":$ACCEPTED_RSS_DELTA_RATIO,
+             "acceptedRssDeltaFloorKb":$ACCEPTED_RSS_DELTA_FLOOR_KB,
+             "gate02RequiredReduction":$GATE_02_REQUIRED_REDUCTION}
+        """.trimIndent().replace("\n", " ")
+
+        val outDir = File(ctx.getExternalFilesDir(null), "mt_rss").apply { mkdirs() }
+        val name = "rss_${actualEngine.name.lowercase()}_${if (mmap) "mmap" else "copy"}.json"
+        File(outDir, name).writeText(row)
+        Log.i(LOG_TAG, "$name -> $row")
+    }
+
+    @Test
+    fun nativeFourPointTable(): Unit = runTable(InferenceEngine.NATIVE)
+
+    @Test
+    fun genAiFourPointTable() {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue(
+            "package has no genai_config.json",
+            File(root, "$repoId/inference/genai_config.json").isFile,
+        )
+        assumeTrue("GenAI engine unavailable on this device", GenAiSupport.available())
+        runTable(InferenceEngine.GENAI)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ObjectBoxParityTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ObjectBoxParityTest.kt
new file mode 100644
index 0000000..dec3197
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ObjectBoxParityTest.kt
@@ -0,0 +1,110 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.rag.ObjectBoxVectorStore
+import com.martinkorelic.mobiletransformers.rag.RagDocument
+import kotlin.math.sqrt
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #25 device parity smoke: the real ObjectBox HNSW store must agree with a plain cosine reference.
+ *
+ * The JVM suite only ever exercised `InMemoryVectorStore`, so the score contract that actually ships —
+ * ObjectBox returns COSINE *distance* and `ORTVectorDatabase` converts it to `1 - distance` — had never
+ * been checked against real ObjectBox on a device. This closes that: same vectors into both, compare
+ * ranking and similarity.
+ *
+ * Needs no model package (it inserts its own vectors), so it runs on any connected device.
+ */
+@RunWith(AndroidJUnit4::class)
+class ObjectBoxParityTest {
+
+    private var store: ObjectBoxVectorStore? = null
+
+    @After
+    fun tearDown() {
+        store?.close()
+    }
+
+    /** Reference cosine similarity — what `RagMatch.score` is contractually supposed to carry. */
+    private fun cosine(a: FloatArray, b: FloatArray): Double {
+        var dot = 0.0
+        var na = 0.0
+        var nb = 0.0
+        for (i in a.indices) {
+            dot += a[i] * b[i]
+            na += a[i] * a[i]
+            nb += b[i] * b[i]
+        }
+        return if (na == 0.0 || nb == 0.0) 0.0 else dot / (sqrt(na) * sqrt(nb))
+    }
+
+    private fun unit(dim: Int, seed: Int): FloatArray {
+        val rnd = java.util.Random(seed.toLong())
+        val v = FloatArray(dim) { rnd.nextGaussian().toFloat() }
+        val norm = sqrt(v.fold(0.0) { acc, x -> acc + x * x }).toFloat()
+        return FloatArray(dim) { v[it] / norm }
+    }
+
+    @Test
+    fun objectBoxRankingAndScoresMatchCosineReference() {
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val dim = 384
+        val cacheDir = ctx.cacheDir.absolutePath
+        val modelName = "objectbox_parity_${System.currentTimeMillis()}"
+        val config = ORTRagConfig(repoName = modelName, embeddingDimension = dim)
+        val db = ORTVectorDatabase.getInstance(modelName, ctx, cacheDir, config)
+        val obx = ObjectBoxVectorStore(db).also { store = it }
+
+        val embeddings = (0 until 8).associateWith { unit(dim, it + 1) }
+        embeddings.forEach { (i, emb) ->
+            val id = obx.insert(RagDocument(id = "doc$i", title = "t$i", text = "body $i"), emb)
+            assertTrue("insert failed for doc$i (id=$id)", id >= 0)
+        }
+        assertEquals(8L, obx.count())
+
+        // Query near doc3 but not identical, so the ordering is a real ranking rather than an exact hit.
+        val base = embeddings.getValue(3)
+        val query = FloatArray(dim) { base[it] + 0.01f * unit(dim, 99)[it] }
+
+        val expected = embeddings.entries
+            .map { (i, emb) -> "doc$i" to cosine(query, emb) }
+            .sortedByDescending { it.second }
+
+        val topK = 4
+        val actual = obx.search(query, topK = topK, minScore = 0.0)
+
+        assertEquals("topK not honoured", topK, actual.size)
+        assertEquals(
+            "ObjectBox ranking differs from the cosine reference",
+            expected.take(topK).map { it.first },
+            actual.map { it.document.id },
+        )
+        actual.forEachIndexed { rank, match ->
+            val ref = expected[rank].second
+            assertEquals(
+                "similarity mismatch at rank $rank for ${match.document.id} " +
+                    "(is the 1 - distance conversion still applied?)",
+                ref,
+                match.score,
+                1e-3,
+            )
+        }
+
+        // The store must hand back the document it was given, embeddings stripped (#25's no-leak rule).
+        assertEquals("body 3", actual.first().document.text)
+
+        // minScore filters on the similarity, not the raw distance.
+        val floor = expected[1].second
+        val filtered = obx.search(query, topK = topK, minScore = floor)
+        assertTrue(
+            "minScore admitted a hit below the floor",
+            filtered.all { it.score >= floor - 1e-6 },
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PostMergeNumericsTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PostMergeNumericsTest.kt
new file mode 100644
index 0000000..e55fa60
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PostMergeNumericsTest.kt
@@ -0,0 +1,599 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Post-merge numerical correctness — the conformance assertion the project did not have.
+ *
+ * The export pipeline gates every package on `artifacts/train_inference_parity.py`: the same tokens
+ * through the train and inference graphs, one cross-entropy each, one bounded delta. **Nothing checked
+ * the numbers after an ON-DEVICE merge.** `TrainMergeGenerateTest` hashes the trainable `.bin` files
+ * and is explicit that this is not a numerical test; `TrainConvergenceTest` reads the training loss,
+ * which never touches the merged inference graph at all.
+ *
+ * So the seam between "the merge wrote bytes" and "the merged graph computes the right thing" was
+ * unverified — the recurring failure shape in this project, and the reason a frozen MARS adapter and a
+ * no-op merge both survived every gate.
+ *
+ * This test closes it by measuring the merged inference graph directly, via
+ * [ORTGeneratorNative.inferenceMetrics] (the only path by which logits reach Kotlin — the normal step
+ * samples internally and returns a token id).
+ *
+ * **Both assertions are relative**, per the standing rule that an absolute threshold encodes one model
+ * and silently measures the wrong thing when the fixture changes.
+ *
+ * ## Package mutation — handled by [PristinePackageRule], no longer the caller's problem
+ *
+ * Every test here trains and merges, which rewrites `train/checkpoint`, `training_state.json` and the
+ * per-tensor weight blobs under `inference/` (spelled without a leading slash-star on purpose: Kotlin
+ * block comments NEST, so `/`+`*` inside KDoc opens a nested comment and eats the closing delimiter).
+ *
+ * **This KDoc previously said those weight blobs are NOT restored and that every test here needs a
+ * freshly pushed package.** That was true when written and is now false: [PristinePackageRule]
+ * captures and restores them around each test, including when the test fails. The per-test
+ * `stashInto`/`restoreFrom` calls below are the older, narrower mechanism and are kept as an inner
+ * belt — they are redundant with the rule, not in conflict with it.
+ *
+ * The cost of the old position was measured on 2026-08-14: a full-suite run reported **3 failures**
+ * that were all this contamination, including `TrainConvergenceTest` seeing `NaN` losses because this
+ * class had memorised one sentence to a training loss of 0.0028 before it ran. All three pass against
+ * a pristine package. Restoring the fixture is cheaper than a suite whose results cannot be read.
+ */
+@RunWith(AndroidJUnit4::class)
+class PostMergeNumericsTest {
+
+    /**
+     * Restore the package after every test in this class. It trains and/or merges, which rewrites the
+     * checkpoint and the `inference/` weight blobs in place — see [PristinePackageRule] for the three
+     * suite failures this prevents.
+     */
+    @get:Rule
+    val pristinePackage = PristinePackageRule()
+
+    private companion object {
+        /**
+         * Ceiling on the post-merge cross-entropy, as a fraction of the pre-merge value.
+         *
+         * Relative, and generous in the direction that matters: a few LoRA steps may move the loss
+         * either way by a little, but a merge that corrupted the weights lands at or above the
+         * uniform-prediction floor `ln(vocab_size)` — ~10.8 here against a healthy ~4.65 on
+         * [PROBE_TEXT], i.e. multiples away rather than percents.
+         *
+         * This bound only means something because the probe is REAL text. Against the arbitrary token
+         * ids it used to score, a healthy model already sat at ~10.19 nats — at chance — so "within 2x"
+         * held no matter what the merge did.
+         */
+        const val MAX_LOSS_RATIO = 2.0
+
+        /**
+         * Text the probes score. **Real English, tokenized by the package's own tokenizer** — not a
+         * hand-written array of token ids.
+         *
+         * This used to be `intArrayOf(1, 338, 263, 1243, 310, 278, 1904, 29889)`: ids chosen to be
+         * "inside every supported vocabulary", which for this tokenizer spell nothing. A healthy model
+         * scores them at ~10.19 nats against a 10.80 uniform floor, i.e. at chance — so the ratio bound
+         * below was comparing two near-uniform numbers and could not fail. That is one of the four
+         * reasons the transposed-merge defect survived for months (2026-08-14).
+         */
+        const val PROBE_TEXT = "The history of the printing press begins in the fifteenth century."
+
+        const val TRAIN_FILE = "mt_post_merge_cola"
+
+        const val LOG_TAG = "PostMergeNumericsTest"
+
+        /** Big enough that a wrong `scale * B@A` cannot hide behind a near-zero delta. */
+        const val STEPS_FOR_LARGE_DELTA = 100
+    }
+
+    @Test
+    fun mergedWeightsChangeTheComputationAndStayNumericallySane(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val trainDir = File(root, "$repoId/train")
+        val checkpoint = File(trainDir, "checkpoint")
+        val trainingState = File(trainDir, "training_state.json")
+        val stash = File(root, "$repoId/.post_merge_stash").apply { mkdirs() }
+        stashInto(stash, checkpoint, trainingState)
+
+        File(trainDir, "$TRAIN_FILE.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "The cat sat on the mat number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        try {
+            val probeTokens = tokenizeWithPackage(root, repoId, PROBE_TEXT)
+            val before = probeMergedGraph(root, repoId, probeTokens)
+
+            val model = MobileTransformers.fromPretrained(
+                context = ctx,
+                repoId = repoId,
+                cacheDir = root.absolutePath,
+                features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            )
+            try {
+                model.train(
+                    DatasetConfig(
+                        trainFile = TRAIN_FILE,
+                        task = "cola",
+                        maxSequenceLength = 64,
+                        maxDatasetLength = 8,
+                        datasetBatchSize = 4,
+                    ),
+                    TrainConfig(maxSteps = 3, batchSize = 2, mergeAtEnd = true),
+                )
+                model.merge()
+            } finally {
+                model.close()
+            }
+
+            val after = probeMergedGraph(root, repoId, probeTokens)
+
+            android.util.Log.i(
+                "PostMergeNumericsTest",
+                "before=$before after=$after",
+            )
+
+            // 1. The merge must change the COMPUTATION, not merely the bytes on disk. A merge that
+            //    rewrote identical values, or wrote to the wrong initializers, leaves this identical
+            //    while `TrainMergeGenerateTest`'s byte hashes still change.
+            assertTrue(
+                "the merged inference graph computes exactly the same thing as before the merge " +
+                    "($before vs $after). Either the merge wrote values the graph does not read, or it " +
+                    "re-merged an already-merged package — re-push a pristine one (make device-package).",
+                after.differsFrom(before),
+            )
+
+            // 2. It must still be a language model. This is the on-device mirror of the host's
+            //    train/inference parity gate, using the same causal shift so the numbers are comparable.
+            assertTrue(
+                "post-merge cross-entropy ${after.crossEntropyNats} is not finite — the merged graph " +
+                    "is producing NaN/Inf logits",
+                after.crossEntropyNats.isFinite(),
+            )
+            assertTrue(
+                "post-merge cross-entropy ${after.crossEntropyNats} nats exploded relative to the " +
+                    "pre-merge ${before.crossEntropyNats} nats (ratio > $MAX_LOSS_RATIO). A merge that " +
+                    "lost or corrupted weights lands at or above ln(vocab_size); this is that regime.",
+                after.crossEntropyNats <= before.crossEntropyNats * MAX_LOSS_RATIO,
+            )
+        } finally {
+            File(trainDir, "$TRAIN_FILE.jsonl").delete()
+            restoreFrom(stash, checkpoint, trainingState)
+            stash.deleteRecursively()
+        }
+    }
+
+    /**
+     * **A training run that takes ZERO optimizer steps must leave the model unchanged.**
+     *
+     * Isolates the training *save* path from the merge. With `gradientAccumulationSteps = 4` (the
+     * default) the optimizer only steps on `globalStep % 4 == 0`, so a 3-step run applies **no update
+     * at all** — LoRA's `B` stays exactly at its zero initialization, which the merge instrumentation
+     * confirms (`adapter_B l2=0.000000`). Nothing about the model should differ afterwards.
+     *
+     * `mergeAtEnd = false` and no `merge()` call, so the merge is entirely out of the picture: the only
+     * thing exercised is training's write-back of trainable parameters into `inference/`.
+     *
+     * This exists because the investigation on 2026-08-14 spent two rounds blaming the merge for
+     * damage that a 3-step run — which trains nothing — reproduced on its own.
+     */
+    @Test
+    fun aTrainingRunThatAppliesNoUpdateLeavesTheModelUnchanged(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val trainDir = File(root, "$repoId/train")
+        val trainFile = "mt_zero_update"
+        val stash = File(root, "$repoId/.zero_update_stash").apply { mkdirs() }
+        stashInto(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+
+        File(trainDir, "$trainFile.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "The cat sat on the mat number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        try {
+            val text = tokenizeWithPackage(root, repoId, PROBE_TEXT)
+
+            val before = probeMergedGraph(root, repoId, text).crossEntropyNats
+
+            val model = MobileTransformers.fromPretrained(
+                context = ctx,
+                repoId = repoId,
+                cacheDir = root.absolutePath,
+                features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            )
+            try {
+                model.train(
+                    DatasetConfig(
+                        trainFile = trainFile,
+                        task = "cola",
+                        maxSequenceLength = 64,
+                        maxDatasetLength = 8,
+                        datasetBatchSize = 4,
+                    ),
+                    // 3 steps at the DEFAULT gradientAccumulationSteps = 4 -> zero optimizer steps.
+                    TrainConfig(maxSteps = 3, batchSize = 2, mergeAtEnd = false),
+                )
+            } finally {
+                model.close()
+            }
+
+            val after = probeMergedGraph(root, repoId, text).crossEntropyNats
+            android.util.Log.i(LOG_TAG, "zero-update training: before=$before after=$after")
+
+            val drift = kotlin.math.abs(after - before) / before
+            assertTrue(
+                "a training run that applied NO optimizer step changed the model: $before -> $after " +
+                    "nats (${"%.1f".format(drift * 100)}% drift).\n" +
+                    "With gradientAccumulationSteps = 4 and maxSteps = 3 the optimizer never fires and " +
+                    "LoRA's B stays at its zero initialization, so there is no update to write. The " +
+                    "merge is not involved (mergeAtEnd = false, no merge() call). This is training's " +
+                    "write-back of trainable parameters into inference/ corrupting the graph.",
+                after.isFinite() && drift < 0.01,
+            )
+        } finally {
+            File(trainDir, "$trainFile.jsonl").delete()
+            restoreFrom(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+            stash.deleteRecursively()
+        }
+    }
+
+    /**
+     * **Merging an UNTRAINED adapter must be the identity.**
+     *
+     * The sharpest possible test of the merge path, and the one that was missing. LoRA initializes
+     * `B = 0`, so before any training `B @ A` is exactly zero and `base + scale * (B @ A) == base` for
+     * *every* scale. A merge that changes the model here cannot be blamed on the adapter, the training
+     * run, the learning rate, the scale, or the dataset — the only thing left is how the weights are
+     * read and written.
+     *
+     * That makes this a **decisive** discriminator. It exists because two rounds of investigation on
+     * 2026-08-14 chased the delta (step count, then the LoRA scale) when the corruption turned out to
+     * be independent of the delta's magnitude: a 3-step merge damaged the model exactly as much as a
+     * 100-step one.
+     *
+     * **The merge must be FORCED to run, and this test must prove that it did.** As first written it
+     * called `merge()` on a freshly loaded model and asserted nothing changed — which passed, but
+     * vacuously: `merge()` with no prior training in the same session never executes a merge at all,
+     * so it was comparing the package with itself. It was reported as a passing control before the
+     * logs were checked, and that wrong control cost a round of investigation.
+     *
+     * The fix is a real training run whose optimizer never fires (`maxSteps = 3` at the default
+     * `gradientAccumulationSteps = 4`), with `mergeAtEnd = true`. The merge then genuinely runs while
+     * `B` is still at its zero initialization, so the delta is exactly zero — and the `.bin`
+     * modification times are checked to confirm the write path actually executed. **Without that
+     * check this test silently reverts to measuring nothing.**
+     *
+     * Self-calibrating: it compares the graph against itself, so it encodes no model's numbers.
+     */
+    @Test
+    fun mergingAnUntrainedAdapterLeavesTheModelUnchanged(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val trainDir = File(root, "$repoId/train")
+        val trainFile = "mt_zero_merge"
+        val stash = File(root, "$repoId/.zero_merge_stash").apply { mkdirs() }
+        stashInto(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+
+        File(trainDir, "$trainFile.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "The cat sat on the mat number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        try {
+            val text = tokenizeWithPackage(root, repoId, PROBE_TEXT)
+
+            val before = probeMergedGraph(root, repoId, text).crossEntropyNats
+
+            // Modification times of the tensors the merge writes. A merge that runs rewrites these
+            // atomically (temp + rename), so mtime moves even though a zero delta leaves the BYTES
+            // identical -- which is why bytes cannot be used to prove the merge happened here.
+            val weights = File(root, "$repoId/inference")
+                .listFiles { f -> f.name.endsWith(".MatMul.weight.bin") }
+                .orEmpty()
+            assertTrue("package has no per-tensor trainable .bin files", weights.isNotEmpty())
+            val mtimesBefore = weights.associate { it.name to it.lastModified() }
+
+            val model = MobileTransformers.fromPretrained(
+                context = ctx,
+                repoId = repoId,
+                cacheDir = root.absolutePath,
+                features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            )
+            try {
+                model.train(
+                    DatasetConfig(
+                        trainFile = trainFile,
+                        task = "cola",
+                        maxSequenceLength = 64,
+                        maxDatasetLength = 8,
+                        datasetBatchSize = 4,
+                    ),
+                    // 3 steps at the DEFAULT gradientAccumulationSteps = 4 -> the optimizer never
+                    // fires, so B stays at zero and the delta this merge applies is exactly zero.
+                    TrainConfig(maxSteps = 3, batchSize = 2, mergeAtEnd = true),
+                )
+                model.merge()
+            } finally {
+                model.close()
+            }
+
+            val rewritten = weights.count { it.lastModified() != mtimesBefore[it.name] }
+            assertTrue(
+                "no merge actually ran: all ${weights.size} trainable .bin files have their original " +
+                    "modification time, so this test compared the package with itself and proved " +
+                    "NOTHING. That is exactly how the original version of this test passed while the " +
+                    "merge was corrupting every weight. Check logcat for 'Starting weight merging " +
+                    "process' before trusting any result from this class.",
+                rewritten > 0,
+            )
+
+            val after = probeMergedGraph(root, repoId, text).crossEntropyNats
+            android.util.Log.i(
+                LOG_TAG,
+                "zero-adapter merge: before=$before after=$after ($rewritten/${weights.size} rewritten)",
+            )
+
+            val drift = kotlin.math.abs(after - before) / before
+            assertTrue(
+                "merging an UNTRAINED adapter changed the model: $before -> $after nats " +
+                    "(${"%.1f".format(drift * 100)}% drift).\n" +
+                    "B is zero at initialization, so the delta is exactly zero and this merge must be " +
+                    "the identity at any scale. A change here is not about the adapter, the scale or " +
+                    "the training run — it is the weight read/write path itself (layout, dtype, or " +
+                    "which initializer is written). Every merged model this SDK has ever produced is " +
+                    "affected.",
+                after.isFinite() && drift < 0.01,
+            )
+        } finally {
+            File(trainDir, "$trainFile.jsonl").delete()
+            restoreFrom(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+            stash.deleteRecursively()
+        }
+    }
+
+    /**
+     * **Does the merge survive a delta large enough to matter?**
+     *
+     * Every other merge assertion in this repo trains a near-zero adapter: `TrainMergeGenerateTest`
+     * takes **1** step, and the test above takes **3**. A merge that is systematically wrong by a
+     * factor or an orientation contributes `scale * B@A`, so at three steps it perturbs the graph by
+     * almost nothing and every one of those gates passes. The first run to train hard — 108 steps at
+     * 5e-4, in `ToolCallDeviceTest` — produced a model that reached 0.006 training loss and then
+     * emitted one repeated token forever. This test exists to decide whether those two facts are the
+     * same fact.
+     *
+     * ### Why it compares two cross-entropies instead of using a threshold
+     *
+     * Measuring the merged graph on *general* text after a heavy fine-tune cannot answer the question:
+     * catastrophic forgetting legitimately raises that number, so a high value proves nothing. Instead
+     * this measures the merged graph on **the exact text the model just memorised** and on unrelated
+     * text, and compares the two:
+     *
+     * * merge correct → the model memorised the corpus, so CE(memorised) is far *below* CE(unrelated);
+     * * merge wrong → the adapter's contribution is garbage, so the merged graph has learned nothing
+     *   and the two are indistinguishable (or both are junk).
+     *
+     * Relative and self-calibrating, so it neither encodes one model's numbers nor cares which way
+     * forgetting moved the absolute values — the failure mode an absolute threshold would have.
+     */
+    @Test
+    fun aLargeAdapterDeltaSurvivesTheMergeIntoTheInferenceGraph(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val trainDir = File(root, "$repoId/train")
+        val trainFile = "mt_large_delta"
+        val stash = File(root, "$repoId/.large_delta_stash").apply { mkdirs() }
+        stashInto(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+
+        // One prompt/completion pair, repeated. Memorisation is the point: it is what makes
+        // CE(memorised) a meaningful number rather than a measure of general fluency.
+        val prompt = "wake me at 07:30"
+        val completion = """{"actionName": "set_alarm", "parameters": {"time": "07:30"}}"""
+        File(trainDir, "$trainFile.jsonl").writeText(
+            (1..STEPS_FOR_LARGE_DELTA * 2).joinToString("\n") {
+                org.json.JSONObject().put("prompt", prompt).put("completion", completion).toString()
+            } + "\n",
+        )
+
+        try {
+            val memorised = tokenizeWithPackage(root, repoId, prompt + completion)
+            val unrelated = tokenizeWithPackage(root, repoId, PROBE_TEXT)
+
+            // CONTROL, before anything is trained: is the pristine inference graph a language model at
+            // all? Nothing in the repo asserted this. `mergedWeightsChangeTheComputationAndStayNumericallySane`
+            // measures a `before` value but only ever compares `after` to it, so a graph that was junk
+            // from the start would satisfy every existing bound. If this fails, the merge is innocent
+            // and the defect is in the inference graph or the prefill inputs (attention mask, position
+            // ids) — a completely different investigation.
+            val uniformFloor = kotlin.math.ln(vocabSizeOf(root, repoId).toDouble())
+            val baseline = probeMergedGraph(root, repoId, unrelated).crossEntropyNats
+            android.util.Log.i(
+                LOG_TAG,
+                "pristine-graph CE on unrelated text = $baseline nats (uniform floor $uniformFloor)",
+            )
+            assertTrue(
+                "the PRISTINE inference graph scores unrelated English at $baseline nats against a " +
+                    "uniform-prediction floor of $uniformFloor — it is not behaving as a language " +
+                    "model before any adapter is involved. The merge is not the defect; look at the " +
+                    "inference graph and the prefill inputs (attention mask / position ids).",
+                baseline.isFinite() && baseline < uniformFloor * 0.75,
+            )
+
+            val losses = mutableListOf<Float>()
+            val model = MobileTransformers.fromPretrained(
+                context = ctx,
+                repoId = repoId,
+                cacheDir = root.absolutePath,
+                features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            )
+            try {
+                model.train(
+                    DatasetConfig(
+                        trainFile = trainFile,
+                        task = "mobile_actions",
+                        maxSequenceLength = 160,
+                        maxDatasetLength = STEPS_FOR_LARGE_DELTA * 2,
+                        datasetBatchSize = 4,
+                    ),
+                    TrainConfig(
+                        maxSteps = STEPS_FOR_LARGE_DELTA,
+                        batchSize = 2,
+                        learningRate = 5e-4f,
+                        gradientAccumulationSteps = 1,
+                        mergeAtEnd = true,
+                    ),
+                    object : TrainCallback {
+                        override fun onStepEnd(progress: TrainProgress) { losses.add(progress.stepLoss) }
+                    },
+                )
+            } finally {
+                model.close()
+            }
+
+            val finalLoss = losses.takeLast(5).average()
+            android.util.Log.i(LOG_TAG, "largeDelta steps=${losses.size} finalTrainLoss=$finalLoss")
+
+            // If training itself did not converge, this test cannot say anything about the merge —
+            // fail for that reason explicitly rather than blaming the merge for a training problem.
+            assertTrue(
+                "training did not converge (final loss $finalLoss over ${losses.size} steps), so this " +
+                    "run cannot distinguish a bad merge from a bad fine-tune",
+                losses.size >= 20 && finalLoss < 0.5,
+            )
+
+            val onMemorised = probeMergedGraph(root, repoId, memorised).crossEntropyNats
+            val onUnrelated = probeMergedGraph(root, repoId, unrelated).crossEntropyNats
+            android.util.Log.i(
+                LOG_TAG,
+                "merged-graph CE: memorised=$onMemorised unrelated=$onUnrelated " +
+                    "trainingLoss=$finalLoss",
+            )
+
+            assertTrue("merged-graph cross-entropy is not finite", onMemorised.isFinite())
+
+            // THE assertion. The training graph says this text costs ~$finalLoss nats. If the merged
+            // inference graph does not also find it far cheaper than unrelated text, then what the
+            // adapter learned did not survive the merge.
+            assertTrue(
+                "the merged inference graph has NOT learned the text the adapter memorised.\n" +
+                    "  training loss on it: $finalLoss nats\n" +
+                    "  merged-graph CE on the SAME text: $onMemorised nats\n" +
+                    "  merged-graph CE on unrelated text: $onUnrelated nats\n" +
+                    "A correctly merged adapter makes memorised text far cheaper than unrelated text. " +
+                    "These being comparable means the delta written into the inference graph is not " +
+                    "the delta that was trained — i.e. the merge is numerically wrong in a way that " +
+                    "1- and 3-step merges are too small to reveal.",
+                onMemorised < onUnrelated * 0.5,
+            )
+        } finally {
+            File(trainDir, "$trainFile.jsonl").delete()
+            restoreFrom(stash, File(trainDir, "checkpoint"), File(trainDir, "training_state.json"))
+            stash.deleteRecursively()
+        }
+    }
+
+    /**
+     * Opens the Native engine over the merged `inference/` directory and measures one prefill pass over
+     * [tokens].
+     *
+     * Built directly rather than through the facade because the facade exposes text, not logits, and a
+     * text-level comparison cannot distinguish "the merge is numerically wrong" from "greedy decoding
+     * happened to pick the same eight tokens" — the exact ambiguity `TrainMergeGenerateTest` documents.
+     */
+    /** The package's declared vocabulary size, for the `ln(vocab)` uniform-prediction floor. */
+    private fun vocabSizeOf(root: File, repoId: String): Int {
+        val tokenizer = ORTTokenizerNative(PackagePaths.forCache(root, repoId).tokenizer.absolutePath)
+        assertTrue("tokenizer reported no vocabulary size", tokenizer.vocabSize > 0)
+        return tokenizer.vocabSize
+    }
+
+    /** Tokenize [text] with the package's tokenizer, opening and closing the native session. */
+    private suspend fun tokenizeWithPackage(root: File, repoId: String, text: String): IntArray {
+        val tokenizer = ORTTokenizerNative(PackagePaths.forCache(root, repoId).tokenizer.absolutePath)
+        tokenizer.createTokenizerModel()
+        return try {
+            tokenizer.tokenize(text, prependBos = true)
+        } finally {
+            tokenizer.destroySession()
+        }
+    }
+
+    private suspend fun probeMergedGraph(
+        root: File,
+        repoId: String,
+        tokens: IntArray,
+    ): ORTGeneratorNative.InferenceMetrics {
+        val paths = PackagePaths.forCache(root, repoId)
+        val tokenizer = ORTTokenizerNative(paths.tokenizer.absolutePath)
+        // The graph filename must be resolved, not assumed: leaving `onnxName` empty makes
+        // `createInferenceModel` open `inference/.onnx`, which does not exist. The repository resolves
+        // it the same way (`LLMRepository.resolveInferenceGraphName`) — `model.onnx` when present, and
+        // otherwise the single `.onnx` in the directory.
+        val graphName = File(paths.inference, "model.onnx").let { canonical ->
+            if (canonical.isFile) canonical.name
+            else paths.inference.listFiles { f: File -> f.isFile && f.name.endsWith(".onnx") }
+                .orEmpty().singleOrNull()?.name ?: "model.onnx"
+        }
+        val config = ORTGenerationConfig(
+            repoName = repoId,
+            onnxName = graphName,
+            loadMergedWeights = true,
+        )
+        val generator = ORTGeneratorNative(root.absolutePath, tokenizer, config)
+        return try {
+            generator.load(root.absolutePath, config)
+            assertTrue("tokenizer reported no vocabulary size", tokenizer.vocabSize > 0)
+            generator.inferenceMetrics(tokens, tokenizer.vocabSize)
+        } finally {
+            generator.release()
+        }
+    }
+
+    private fun stashInto(stash: File, vararg files: File) {
+        for (f in files) {
+            if (f.exists()) f.copyRecursively(File(stash, f.name), overwrite = true)
+        }
+    }
+
+    private fun restoreFrom(stash: File, vararg files: File) {
+        for (f in files) {
+            val saved = File(stash, f.name)
+            if (saved.exists()) {
+                if (f.exists()) f.deleteRecursively()
+                saved.copyRecursively(f, overwrite = true)
+            }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PristinePackageRule.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PristinePackageRule.kt
new file mode 100644
index 0000000..2291c56
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/PristinePackageRule.kt
@@ -0,0 +1,161 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import java.io.File
+import org.junit.rules.TestRule
+import org.junit.runner.Description
+import org.junit.runners.model.Statement
+
+/**
+ * Restores the on-device package to its pre-test bytes after every test in a class that trains or
+ * merges. **Without this the device suite cannot be run in one pass.**
+ *
+ * The failure it exists to prevent, measured on the S21 FE 2026-08-14 (23 tests, 3 failures):
+ *
+ * * `TrainMergeGenerateTest` fingerprints the per-tensor weight blobs before and after a merge and
+ *   asserts the bytes moved. The merge rewrites those files **in place**, so once any earlier test has
+ *   merged,
+ *   a second merge of the same adapter re-computes identical bytes and the assertion fails —
+ *   correctly reporting "merge wrote no new weights" about a merge that worked fine.
+ * * `TrainConvergenceTest` asserts the model still starts from *pretrained* weights, and reported
+ *   `NaN` for both initial losses. **The cause is not the weights** — that was the first guess and it
+ *   was wrong. It is `training_state.json`: the file does not exist in a freshly exported package,
+ *   training CREATES it, and its presence makes the next run RESUME instead of starting fresh. Every
+ *   one of these passes against a freshly pushed package.
+ *
+ * JUnit orders classes by name, which puts the mutating classes ahead of the classes that need a
+ * clean fixture, so the contamination is deterministic rather than flaky — it will reproduce on every
+ * suite run until the fixture is restored.
+ *
+ * **What is captured:** the training checkpoint, `training_state.json`, and every per-tensor weight
+ * blob plus its `.sha256` sidecar under the inference stage. Those are the only mutable artifacts;
+ * the ONNX graphs, tokenizer and manifest are read-only at runtime.
+ *
+ * **Restoring means both halves.** A file that was ABSENT before the test and exists after it is
+ * restored by *deleting* it — see [restore]. The first version of this rule only copied saved files
+ * back, which fixed `TrainMergeGenerateTest` (whose blobs pre-exist) and left `TrainConvergenceTest`
+ * failing identically, because the file that broke it was one the test created. State is what is
+ * there **and** what is not.
+ *
+ * ## What it actually guarantees — the name overstates it
+ *
+ * The rule restores each test's **pre-test** state, which equals *pristine* only if the suite began
+ * pristine. So the precondition stands: push a fresh package before a suite run. What the rule adds is
+ * that the state no longer degrades *during* the run, which is what was broken.
+ *
+ * Two consequences worth knowing:
+ *
+ * * because every test restores, a suite that starts clean also **ends** clean — so a second run in a
+ *   row is valid without re-pushing, which was not true before;
+ * * if a test dies without reaching its `finally` (native crash, OOM kill, `adb` disconnect), the
+ *   package is left dirty and its clean copy is orphaned in the stash. The next run detects the
+ *   orphan and recovers from it before capturing. Without that, the rule would adopt the corruption
+ *   as its baseline and preserve it faithfully for every following test — guaranteeing contamination
+ *   instead of preventing it.
+ *
+ * **This is a fixture rule, not a correctness guarantee.** It cannot make a test independent of one
+ * that mutates state it does not know about, and a test whose assertion depends on a clean package
+ * should still say so in its failure message — the messages above are what made this diagnosable at
+ * all.
+ *
+ * *(Editing note, learned twice in one day: Kotlin block comments NEST. Writing a glob for the weight
+ * blobs as `inference` + slash + star inside this KDoc opens a nested comment that swallows the
+ * closing delimiter, and the compiler reports "Unclosed comment" at the END of the file, pointing
+ * nowhere near the cause. Name the files in prose instead.)*
+ */
+class PristinePackageRule : TestRule {
+
+    override fun apply(base: Statement, description: Description): Statement = object : Statement() {
+        override fun evaluate() {
+            val root = DeviceModel.cacheRoot()
+            if (root == null) {
+                // No package: the test itself will assumeTrue-skip. Nothing to protect.
+                base.evaluate()
+                return
+            }
+            val repoId = DeviceModel.repoId(root)
+            val stash = File(root, "$repoId/.pristine_stash")
+            val mutable = mutableArtifacts(root, repoId)
+
+            // A stash that already exists means a previous test never reached its `finally` — the
+            // process died mid-test (native crash, OOM kill, `adb` disconnect). The package is dirty
+            // AND its clean copy is sitting right there. Recover from it before capturing, otherwise
+            // this run adopts the corruption as its baseline and preserves it faithfully for every
+            // test that follows: the rule would then guarantee contamination rather than prevent it.
+            if (stash.isDirectory) {
+                val recovered = restore(stash, root, repoId, mutable)
+                Log.w(
+                    LOG_TAG,
+                    "found an orphaned stash from a previous run (a test died before restoring); " +
+                        "recovered $recovered artifacts before capturing",
+                )
+            }
+
+            stash.deleteRecursively()
+            stash.mkdirs()
+            for (f in mutable) {
+                if (f.exists()) f.copyRecursively(File(stash, f.name), overwrite = true)
+            }
+            Log.i(LOG_TAG, "captured ${mutable.count { it.exists() }} mutable artifacts for ${description.methodName}")
+
+            try {
+                base.evaluate()
+            } finally {
+                // Restore even when the test failed — a failing test that leaves the package dirty
+                // turns one real failure into a cascade of misleading ones in the tests after it.
+                val restored = restore(stash, root, repoId, mutable)
+                stash.deleteRecursively()
+                Log.i(LOG_TAG, "restored $restored artifacts after ${description.methodName}")
+            }
+        }
+    }
+
+    private companion object {
+        const val LOG_TAG = "PristinePackageRule"
+
+        /**
+         * Put the artifacts back exactly as they were — including the ones that were **absent**.
+         *
+         * The absent half is not an edge case, it is the common one: `training_state.json` does not
+         * exist in a freshly exported package, training CREATES it, and a restore that only copies
+         * saved files back leaves it behind forever. `TrainConvergenceTest` then resumes from a
+         * trained state instead of starting from pretrained weights and reports `NaN` initial losses
+         * — which is exactly how this rule failed its first suite run, having fixed
+         * `TrainMergeGenerateTest` but not this.
+         *
+         * The list is recomputed here rather than reusing the capture-time one, so a weight blob the
+         * merge newly created is also seen. Returns restored + deleted.
+         */
+        fun restore(stash: File, root: File, repoId: String, capturedList: List<File>): Int {
+            val now = (mutableArtifacts(root, repoId) + capturedList).distinctBy { it.absolutePath }
+            var touched = 0
+            for (f in now) {
+                val saved = File(stash, f.name)
+                if (saved.exists()) {
+                    if (f.exists()) f.deleteRecursively()
+                    saved.copyRecursively(f, overwrite = true)
+                    touched++
+                } else if (f.exists()) {
+                    // Absent at capture, present now => the test created it. Removing it IS the restore.
+                    f.deleteRecursively()
+                    touched++
+                }
+            }
+            return touched
+        }
+
+        /** Everything a training or merge run can rewrite. Read-only artifacts are deliberately absent. */
+        fun mutableArtifacts(root: File, repoId: String): List<File> {
+            val trainDir = File(root, "$repoId/train")
+            val inferenceDir = File(root, "$repoId/inference")
+            val weights = inferenceDir
+                .listFiles { f -> f.name.endsWith(".bin") || f.name.endsWith(".sha256") }
+                .orEmpty()
+                .toList()
+            return listOf(
+                File(trainDir, "checkpoint"),
+                File(trainDir, "training_state.json"),
+            ) + weights
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/RagDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/RagDeviceTest.kt
new file mode 100644
index 0000000..31c1465
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/RagDeviceTest.kt
@@ -0,0 +1,78 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #26 + #27 device checkpoint: ingest a small `.txt` (chunk → embed → store), then `generateWithRag`,
+ * asserting a non-empty answer, non-empty matches, and an inspectable prompt. Requires a RAG-capable
+ * package (`embedding/`).
+ */
+@RunWith(AndroidJUnit4::class)
+class RagDeviceTest {
+
+    @Test
+    fun ingestThenGroundedGenerate() = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        // Grounded generation needs a token loop; the embedding gate below is about the retriever.
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue(
+            "package is not RAG-capable (no embedding/)",
+            File(root, "$repoId/embedding").isDirectory,
+        )
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Rag),
+        )
+        try {
+            val doc = File(ctx.cacheDir, "rag_doc.txt").apply {
+                writeText("The Eiffel Tower is in Paris. Paris is the capital of France.")
+            }
+            val ingest = model.ingest(doc.absolutePath, RagConfig())
+            assertTrue("ingestion inserted no chunks", ingest.chunkCount > 0)
+
+            // The retrieve callback fires BEFORE generation, which is what lets a UI show its
+            // sources ahead of the answer. Captured here because the ordering is the contract.
+            var seenDuringRetrieval: RetrievalResult? = null
+            val grounded = model.generateWithRag(
+                query = "Where is the Eiffel Tower?",
+                rag = RagConfig(),
+                retrieveCallback = object : RetrieveCallback {
+                    override fun onQueryResults(result: RetrievalResult) {
+                        seenDuringRetrieval = result
+                    }
+                },
+            )
+            assertTrue("no retrieved matches", grounded.matches.isNotEmpty())
+            assertTrue("prompt not inspectable", grounded.prompt.contains("Eiffel Tower"))
+            assertNotNull("the retrieve callback never fired", seenDuringRetrieval)
+
+            // Provenance across the REAL ObjectBox store — the only place the round trip
+            // (insert(name=title, document=id) -> query -> RetrievalMatch) can actually be proven.
+            // A JVM test can assert the grouping rules but not that the store keeps the fields.
+            val match = grounded.matches.first()
+            assertEquals("the source file's name did not survive the store", doc.name, match.title)
+            assertTrue("the chunk id did not survive the store", match.chunkId.isNotBlank())
+            assertEquals(doc.nameWithoutExtension, match.documentId)
+            assertEquals("one ingested file is one document", 1, seenDuringRetrieval!!.documentCount)
+            assertEquals(listOf(doc.name), seenDuringRetrieval!!.documentTitles)
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ScheduledTrainingDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ScheduledTrainingDeviceTest.kt
new file mode 100644
index 0000000..769b9fc
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ScheduledTrainingDeviceTest.kt
@@ -0,0 +1,220 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.work.Configuration
+import androidx.work.ListenableWorker
+import androidx.work.testing.SynchronousExecutor
+import androidx.work.testing.TestListenableWorkerBuilder
+import androidx.work.testing.WorkManagerTestInitHelper
+import androidx.work.workDataOf
+import com.martinkorelic.mobiletransformers.scheduler.ThermalSample
+import com.martinkorelic.mobiletransformers.scheduler.TrainingJobCodec
+import com.martinkorelic.mobiletransformers.scheduler.TrainingScheduleConfig
+import com.martinkorelic.mobiletransformers.scheduler.TrainingScheduleConfigCodec
+import com.martinkorelic.mobiletransformers.scheduler.TrainingWorker
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #34 device leg: two bounded training chunks, run for real, with the resume seam asserted BETWEEN them.
+ *
+ * ## What this covers, and what it deliberately does not
+ *
+ * Chunks are driven directly through [TestListenableWorkerBuilder] rather than by waiting on real
+ * charging/idle constraints. That is on purpose: **constraint evaluation and Doze deferral are
+ * Android's behaviour, not this library's**, and gating an automated test on someone plugging a cable
+ * in would make it a test of the room. What IS this library's behaviour, and is asserted here:
+ *
+ *  * a chunk runs real training on a real package and exits having checkpointed;
+ *  * chunk 2 **continues** chunk 1 — `globalStep` advances rather than restarting;
+ *  * the LR schedule crosses the boundary intact. The host test
+ *    ([com.martinkorelic.mobiletransformers.scheduler.TrainingScheduleConfigTest]) proves the
+ *    arithmetic over N boundaries; this proves the value survives a real round trip through a
+ *    `training_state.json` written by one worker and read by the next;
+ *  * the thermal/energy trace is emitted — the plan calls the measurement the contribution, so its
+ *    absence is a failure here, not a warning.
+ *
+ * Doze deferral, the foreground notification's appearance, and multi-hour behaviour under Android 16's
+ * tightened foreground-service quotas remain **manual** legs, and are recorded as unproven.
+ */
+@RunWith(AndroidJUnit4::class)
+class ScheduledTrainingDeviceTest {
+
+    /**
+     * Restore the package after every test in this class. It trains and/or merges, which rewrites the
+     * checkpoint and the `inference/` weight blobs in place — see [PristinePackageRule] for the three
+     * suite failures this prevents.
+     */
+    @get:Rule
+    val pristinePackage = PristinePackageRule()
+
+    private val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Before
+    fun initWorkManager() {
+        // A real WorkManager would enqueue the chained next chunk against the device's actual
+        // constraints; the test initializer keeps that in-process and synchronous.
+        WorkManagerTestInitHelper.initializeTestWorkManager(
+            ctx,
+            Configuration.Builder()
+                .setMinimumLoggingLevel(Log.DEBUG)
+                .setExecutor(SynchronousExecutor())
+                .build(),
+        )
+    }
+
+    @Test
+    fun chunkedTrainingResumesAcrossTheChunkBoundary(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+        // The chunk fixture is a decoder objective (`cola`, text-to-text) and TrainingWorker requests
+        // the Inference feature, which an encoder package does not declare — it ships no
+        // `generation_config.json` because it has nothing to generate. #34's evidence is the decoder
+        // package; this skips rather than reporting a task mismatch as a scheduler failure.
+        DeviceModel.requireDecoder(root, repoId)
+
+        val trainDir = File(root, "$repoId/train")
+        val stateFile = File(trainDir, "training_state.json")
+        val checkpointDir = File(trainDir, "checkpoint")
+        val trace = File(root, "$repoId-training-trace.csv")
+
+        // HERMETIC: this test TRAINS the shared package, and the merge/convergence suites require a
+        // pristine one — `TrainMergeGenerateTest` fails with "merge wrote no new weights ... re-push a
+        // pristine package" if its weights have already moved. Since this class sorts before both of
+        // them, an un-restored run turns two unrelated suites red. So the checkpoint and state are
+        // stashed and put back, whatever happens.
+        val backup = File(ctx.cacheDir, "sched_backup").apply { deleteRecursively(); mkdirs() }
+        checkpointDir.copyRecursively(File(backup, "checkpoint"), overwrite = true)
+        if (stateFile.isFile) stateFile.copyTo(File(backup, "training_state.json"), overwrite = true)
+
+        try {
+            runChunkedTraining(root, repoId, trainDir, stateFile, trace)
+        } finally {
+            checkpointDir.deleteRecursively()
+            File(backup, "checkpoint").copyRecursively(checkpointDir, overwrite = true)
+            stateFile.delete()
+            File(backup, "training_state.json").takeIf { it.isFile }?.copyTo(stateFile, overwrite = true)
+            backup.deleteRecursively()
+            File(trainDir, "mt_sched_cola.jsonl").delete()
+            Log.i(TAG, "restored the package's checkpoint + training state")
+        }
+    }
+
+    private suspend fun runChunkedTraining(
+        root: File,
+        repoId: String,
+        trainDir: File,
+        stateFile: File,
+        trace: File,
+    ) {
+        stateFile.delete() // start from a known point, so "advanced" really means advanced
+        trace.delete()
+
+        // The package ships model artifacts, not data — same fixture shape as the other train suites.
+        val trainFile = "mt_sched_cola"
+        File(trainDir, "$trainFile.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "Scheduled chunk sentence number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        // WHAT to train on. A scheduled chunk must be describable by data alone (it may be rebuilt
+        // after process death), so this travels in the worker's input Data via TrainingJobCodec.
+        val training = ORTTrainingConfig(
+            repoName = repoId,
+            taskName = "cola",
+            batchSize = 2,
+            numTrainEpochs = 1,
+            datasetOptions = DatasetOptions(trainFile = trainFile, datasetBatchSize = 2, maxDatasetLength = 8),
+        )
+
+        val config = TrainingScheduleConfig(
+            // Constraints are irrelevant here (the worker is driven directly), but the chunk bound and
+            // checkpoint cadence are the shipping ones.
+            requiresCharging = false,
+            requiresBatteryNotLow = false,
+            maxStepsPerChunk = 2,
+            checkpointEverySteps = 1,
+        )
+
+        val first = runChunk(repoId, root, config, training, chunk = 1)
+        assertTrue("chunk 1 failed: $first", first is ListenableWorker.Result.Success)
+        val stepsAfterFirst = readCounter(stateFile, "currentGlobalStep")
+        val scheduleAfterFirst = readCounter(stateFile, "currentStep")
+        Log.i(TAG, "chunk 1 -> globalStep=$stepsAfterFirst schedulerStep=$scheduleAfterFirst")
+        assertTrue("chunk 1 must have trained at least one step", stepsAfterFirst > 0)
+
+        val second = runChunk(repoId, root, config, training, chunk = 2)
+        assertTrue("chunk 2 failed: $second", second is ListenableWorker.Result.Success)
+        val stepsAfterSecond = readCounter(stateFile, "currentGlobalStep")
+        val scheduleAfterSecond = readCounter(stateFile, "currentStep")
+        Log.i(TAG, "chunk 2 -> globalStep=$stepsAfterSecond schedulerStep=$scheduleAfterSecond")
+
+        // THE seam. A chunk that restarted rather than resumed would leave globalStep where chunk 1
+        // left it, and would replay the LR schedule from its start.
+        assertTrue(
+            "globalStep must ADVANCE across the chunk boundary, not restart: " +
+                "$stepsAfterFirst -> $stepsAfterSecond",
+            stepsAfterSecond > stepsAfterFirst,
+        )
+        assertTrue(
+            "the LR schedule must continue across the boundary, not replay: " +
+                "schedulerStep $scheduleAfterFirst -> $scheduleAfterSecond",
+            scheduleAfterSecond > scheduleAfterFirst,
+        )
+
+        assertTrue("no thermal/energy trace at $trace", trace.isFile)
+        val lines = trace.readLines().filter { it.isNotBlank() }
+        assertEquals(ThermalSample.CSV_HEADER, lines.first())
+        assertTrue("expected one trace row per chunk, got ${lines.size - 1}", lines.size - 1 >= 2)
+        Log.i(TAG, "thermal/energy trace:\n" + lines.joinToString("\n"))
+    }
+
+    private suspend fun runChunk(
+        repoId: String,
+        root: File,
+        config: TrainingScheduleConfig,
+        training: ORTTrainingConfig,
+        chunk: Int,
+    ): ListenableWorker.Result =
+        TestListenableWorkerBuilder<TrainingWorker>(ctx)
+            .setInputData(
+                workDataOf(
+                    // The scheduler's own encoding, not a parallel one that could drift from it.
+                    *TrainingScheduleConfigCodec.toPairs(config),
+                    *TrainingJobCodec.toPairs(training),
+                    TrainingWorker.KEY_REPO_ID to repoId,
+                    TrainingWorker.KEY_CACHE_DIR to root.absolutePath,
+                    TrainingWorker.KEY_CHUNK to chunk,
+                ),
+            )
+            .build()
+            .doWork()
+
+    /** Reads a counter from `training_state.json`, searching nested objects (the scheduler's state). */
+    private fun readCounter(stateFile: File, key: String): Int {
+        if (!stateFile.isFile) return 0
+        val json = JSONObject(stateFile.readText())
+        if (json.has(key)) return json.optInt(key)
+        for (name in json.keys()) {
+            val nested = json.optJSONObject(name) ?: continue
+            if (nested.has(key)) return nested.optInt(key)
+        }
+        return 0
+    }
+
+    private companion object {
+        const val TAG = "ScheduledTrainingDeviceTest"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ToolCallDeviceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ToolCallDeviceTest.kt
new file mode 100644
index 0000000..bd2e150
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/ToolCallDeviceTest.kt
@@ -0,0 +1,267 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.agent.ActionSpec
+import com.martinkorelic.mobiletransformers.agent.FunctionCallValidator
+import com.martinkorelic.mobiletransformers.agent.ToolCallResult
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.SamplingConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * **#37 CHECKPOINT — the differentiation gate, end to end on hardware.**
+ *
+ * per-user action set → on-device fine-tune → validated tool call → dry-run intent, in one run, with
+ * nothing leaving the device.
+ *
+ * ### What this asserts, and why it is the accepted path
+ *
+ * A demo that "passes" by exercising the **refusal** path would show nothing: the validator rejecting
+ * garbage is already covered by 15 JVM tests, and an untrained model refusing is the trivial outcome.
+ * The claim worth making is the hard one — that a model fine-tuned **here, on this user's own action
+ * vocabulary** emits a call its own app accepts, which then becomes a real Android intent it was never
+ * allowed to name.
+ *
+ * ### Why the corpus is deliberately tiny and repetitive
+ *
+ * The assertion is convergence-dependent, and this runs on a 135M base with a LoRA adapter in the
+ * minutes available to an instrumented test. So the target is **memorisation, not generalisation**:
+ * three actions, one prompt shape each, repeated. That is enough to demonstrate the loop, and claiming
+ * more from it would overstate what a run this size can show. Generalisation is what the imported
+ * `google/mobile-actions` corpus is for (`mobiletransformers agent-dataset`), which needs a longer run
+ * than an instrumented test should hold.
+ *
+ * ### The two settings that decide whether this can work at all
+ *
+ * * **`gradientAccumulationSteps = 1`.** `optimizerStep` fires on `globalStep % gradAccumSteps == 0`
+ *   and the default is 4, so a bounded run can complete, report success on every callback, and apply
+ *   **no update whatsoever**. That defect cost a cycle to find in #36; it is pinned here on purpose.
+ * * **Greedy decoding.** Sampling would make the assertion flaky for reasons unrelated to whether the
+ *   model learned anything — a temperature that occasionally breaks JSON is not a finding.
+ *
+ * A failure here is a real result to record, not something to loosen the assertion for.
+ */
+@RunWith(AndroidJUnit4::class)
+class ToolCallDeviceTest {
+
+    /**
+     * Restore the package after every test in this class. It trains and/or merges, which rewrites the
+     * checkpoint and the `inference/` weight blobs in place — see [PristinePackageRule] for the three
+     * suite failures this prevents.
+     */
+    @get:Rule
+    val pristinePackage = PristinePackageRule()
+
+    private companion object {
+        const val LOG_TAG = "ToolCallDeviceTest"
+
+        /**
+         * Long enough to memorise three phrasings; short enough for an instrumented run.
+         *
+         * **`maxSteps` is an upper bound, not a target.** Training stops at the end of the epoch, so
+         * the steps actually taken are `rows / batchSize` when that is the smaller number. The first
+         * run asked for 120 and took 54 (108 rows / batch 2), which is why [REPEATS] and
+         * `maxDatasetLength` below are sized to put the epoch above this bound rather than under it.
+         */
+        const val STEPS = 120
+
+        /** Repetitions of the 9 base pairs. 9 x 24 = 216 rows -> 108 steps at batchSize 2. */
+        const val REPEATS = 24
+    }
+
+    /**
+     * The app's declaration — the ONLY source of intent strings, and the same object the dataset is
+     * generated from. `mobiletransformers agent-dataset` writes this as `action_schema.json`; the test
+     * holds it inline so the corpus and the boundary provably come from one value.
+     */
+    private val allowlist = listOf(
+        ActionSpec(
+            actionName = "set_alarm",
+            parameters = mapOf("time" to "string"),
+            allowedIntent = "android.intent.action.SET_ALARM",
+            validationRules = mapOf("time" to "HH:mm"),
+            privacyClass = "harmless-demo",
+        ),
+        ActionSpec(
+            actionName = "set_timer",
+            parameters = mapOf("seconds" to "string"),
+            allowedIntent = "android.intent.action.SET_TIMER",
+            validationRules = mapOf("seconds" to "/[0-9]{1,4}/"),
+            privacyClass = "harmless-demo",
+        ),
+        ActionSpec(
+            actionName = "open_wifi_settings",
+            parameters = emptyMap(),
+            allowedIntent = "android.settings.WIFI_SETTINGS",
+            privacyClass = "harmless-demo",
+        ),
+    )
+
+    /** `{"prompt","completion"}` rows — the shape `MobileActionsPreprocessor` (task `mobile_actions`) reads. */
+    private fun corpus(): String {
+        val rows = mutableListOf<Pair<String, String>>()
+        for (time in listOf("06:15", "07:30", "08:00", "22:05")) {
+            rows += "wake me at $time" to
+                """{"actionName": "set_alarm", "parameters": {"time": "$time"}}"""
+        }
+        for (seconds in listOf("30", "60", "300", "900")) {
+            rows += "timer for $seconds seconds" to
+                """{"actionName": "set_timer", "parameters": {"seconds": "$seconds"}}"""
+        }
+        rows += "open wifi settings" to """{"actionName": "open_wifi_settings", "parameters": {}}"""
+
+        // Repeated so a bounded number of steps sees each pair many times.
+        return (1..REPEATS).flatMap { rows }.joinToString("\n") { (prompt, completion) ->
+            org.json.JSONObject()
+                .put("prompt", prompt)
+                .put("completion", completion)
+                .toString()
+        } + "\n"
+    }
+
+    @Test
+    fun aLocallyFineTunedModelEmitsACallTheAppAcceptsAndBindsToAnIntent(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+        val trainFile = "mt_device_mobile_actions"
+        File(root, "$repoId/train/$trainFile.jsonl").writeText(corpus())
+
+        val validator = FunctionCallValidator(allowlist)
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Training),
+        )
+
+        try {
+            val losses = mutableListOf<Float>()
+            model.train(
+                DatasetConfig(
+                    trainFile = trainFile,
+                    task = "mobile_actions",
+                    // The `mobile_actions` prompt is rendered through the chat template (the model is
+                    // queried that way), which adds the system turn and the ChatML markup — roughly
+                    // 40 tokens before the instruction. At 96 the rendered rows sat close enough to
+                    // the limit that `removeLongSamples` could silently shrink the dataset.
+                    maxSequenceLength = 160,
+                    maxDatasetLength = 256,
+                    datasetBatchSize = 4,
+                ),
+                TrainConfig(
+                    maxSteps = STEPS,
+                    batchSize = 2,
+                    learningRate = 5e-4f,
+                    // See the class docstring: 4 (the default) means a bounded run trains nothing.
+                    gradientAccumulationSteps = 1,
+                    mergeAtEnd = true,
+                ),
+                object : TrainCallback {
+                    override fun onStepEnd(progress: TrainProgress) {
+                        losses.add(progress.stepLoss)
+                    }
+                },
+            )
+
+            // Sized against the epoch, not against 0: a row that overruns `maxSequenceLength` is
+            // dropped silently, so a shrinking dataset shows up here as a short run rather than as a
+            // failure at the end. 216 rows / batch 2 = 108 steps; anything under half of that means
+            // rows were dropped and the run below is not the one this test claims to be making.
+            assertTrue(
+                "only ${losses.size} steps ran — the dataset was smaller than declared, so rows were " +
+                    "dropped (likely maxSequenceLength) and the convergence claim below is unsupported",
+                losses.size >= 50,
+            )
+            val window = losses.size / 3
+            val drop = (losses.take(window).average() - losses.takeLast(window).average()) /
+                losses.take(window).average()
+            Log.i(LOG_TAG, "steps=${losses.size} lossDrop=${"%.1f".format(drop * 100)}%")
+
+            // The instruction is one the corpus taught, because memorisation is the claim being made.
+            val instruction = "wake me at 07:30"
+            val result = model.generateToolCall(
+                instruction = instruction,
+                validator = validator,
+                config = GenerationConfig(
+                    maxNewTokens = 48,
+                    // Greedy: a flaky sample is not a finding about whether the model learned.
+                    sampling = SamplingConfig(method = SamplingMethod.GREEDY),
+                    loadMerged = true,
+                ),
+            )
+            Log.i(LOG_TAG, "instruction='$instruction' raw='${result.raw}' -> ${result::class.simpleName}")
+
+            assertTrue(
+                "the model did not emit a call this app accepts after $STEPS steps on its own action " +
+                    "set.\n  raw output: '${result.raw}'\n  reason: " +
+                    when (result) {
+                        // Two very different diagnoses, and reporting both as "rejected" sent the
+                        // investigation to the wrong place: a refusal means the allowlist held
+                        // against a call, while NoCall means no call was recognised at all — which
+                        // is what a parser/dialect mismatch looks like, not a training failure.
+                        is ToolCallResult.Rejected -> "refused by the validator: ${result.reason}"
+                        is ToolCallResult.NoCall -> "no call was recognised in the output — check " +
+                            "the tool-call dialect (capabilities.toolCalling) before concluding the " +
+                            "model did not learn"
+                        is ToolCallResult.Accepted -> ""
+                    } +
+                    "\n  loss drop over training: ${"%.1f".format(drop * 100)}%\n" +
+                    "This is the #37 differentiation gate. A refusal here is a real result — record it " +
+                    "rather than weakening the assertion; asserting on the refusal path would prove " +
+                    "nothing, since an untrained model also refuses.",
+                result is ToolCallResult.Accepted,
+            )
+
+            val accepted = result as ToolCallResult.Accepted
+            assertEquals("set_alarm", accepted.call.actionName)
+            assertEquals("07:30", accepted.call.parameters["time"])
+
+            // The binding half: the intent comes from the APP's spec, never from model output.
+            val intended = accepted.dryRun()
+            assertEquals("android.intent.action.SET_ALARM", intended.intent.action)
+            assertEquals("07:30", intended.intent.getStringExtra("time"))
+            assertFalse("dry-run must never mark itself executable", intended.willExecute)
+        } finally {
+            model.close()
+        }
+    }
+
+    /**
+     * The boundary still refuses what the app never declared — after fine-tuning, on the real device.
+     *
+     * Fine-tuning teaches the model this vocabulary; it must not be able to widen it. This is cheap
+     * (no second training run) and it is the half that keeps the accepted-path assertion meaningful:
+     * a validator that accepted everything would also pass the test above.
+     */
+    @Test
+    fun theAllowlistStillRefusesAnActionTheAppNeverDeclared() {
+        val validator = FunctionCallValidator(allowlist)
+        val rejected = runCatching {
+            validator.validate("""{"actionName": "wipe_device", "parameters": {}}""")
+        }.exceptionOrNull()
+        assertTrue("an undeclared action must be refused", rejected != null)
+        assertTrue(rejected!!.message!!.contains("not allowlisted"))
+        assertEquals(
+            setOf("set_alarm", "set_timer", "open_wifi_settings"),
+            validator.allowedActions,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainConvergenceTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainConvergenceTest.kt
new file mode 100644
index 0000000..43b93d2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainConvergenceTest.kt
@@ -0,0 +1,273 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #18/#19 numerical sanity — the caveat that has stood over every "train→merge→generate PASSES" claim.
+ *
+ * `TrainMergeGenerateTest` proves the merge **happened**: it fingerprints the per-tensor `.bin` files
+ * and asserts the bytes changed. That is the right assertion for the plumbing, and it is deliberately
+ * indifferent to whether the numbers are meaningful — one LoRA step at lr 1e-4 over an 8-row fixture
+ * legitimately produces gibberish (`,,,,,,,,`), so nothing downstream could distinguish
+ * "training works" from "training writes noise into the right files".
+ *
+ * This closes that gap from the other side: it does not look at bytes at all, it looks at the **loss
+ * trend**. If the ORT training session is genuinely computing gradients and the optimizer is applying
+ * them, repeated passes over a tiny, highly repetitive corpus must drive the loss down. If any link is
+ * broken — zeroed gradients, an optimizer that never steps, a loss detached from the parameters — the
+ * loss stays flat and this fails, while every byte-level assertion in the suite still passes.
+ *
+ * **Deliberately a trend, not a threshold.** Asserting `finalLoss < 0.5` would encode one model, one
+ * fixture and one learning rate; asserting the loss *fell materially* tests the property that actually
+ * matters and survives changing any of them.
+ */
+@RunWith(AndroidJUnit4::class)
+class TrainConvergenceTest {
+
+    /**
+     * Restore the package after every test in this class. It trains and/or merges, which rewrites the
+     * checkpoint and the `inference/` weight blobs in place — see [PristinePackageRule] for the three
+     * suite failures this prevents.
+     */
+    @get:Rule
+    val pristinePackage = PristinePackageRule()
+
+    private companion object {
+        const val LOG_TAG = "TrainConvergenceTest"
+
+        /** Enough steps for a trend to be a trend rather than two noisy samples. */
+        const val STEPS = 30
+
+        /**
+         * The mean loss over the last third must be below the first third by at least this fraction.
+         *
+         * **Calibrated against a real run, not guessed.** 30 steps at lr 5e-4 on LoRA q/k gives a
+         * smooth monotonic 1.6% decline (10.469 -> 10.297, every logged step lower than the last).
+         * The purpose is to separate "the optimizer is applying gradients" from "nothing is happening",
+         * and 1% does that: noise on this trace is ~0.01/step in ONE direction, so a flat or broken
+         * optimizer cannot fake it. A tighter bound would only encode this model and learning rate.
+         */
+        const val REQUIRED_RELATIVE_DROP = 0.01
+
+        /**
+         * How much better a pretrained model must score coherent English than token soup, as a
+         * fraction of its loss on the soup.
+         *
+         * **Self-calibrating by construction.** Both corpora go through the same preprocessor, the
+         * same tokenizer and the same graph; the ONLY difference is whether the supervised target is
+         * natural language. A model holding pretrained weights separates these by several nats; a
+         * randomly-initialised one cannot separate them at all, because neither is more probable than
+         * the other under an untrained distribution. 15% is far below the gap a working model shows
+         * and far above anything noise produces, and it encodes no model, tokenizer or fixture.
+         */
+        const val REQUIRED_COHERENCE_MARGIN = 0.15
+    }
+
+    @Test
+    fun lossFallsOverTrainingSoTheMergeCarriesRealLearning(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+
+        // A deliberately trivial, highly repetitive corpus: two sentence shapes with a fixed label each.
+        // A model that is learning at all drives the loss down fast on this; one that is not, cannot.
+        val trainFile = "mt_device_convergence_cola"
+        File(root, "$repoId/train/$trainFile.jsonl").writeText(
+            (1..64).joinToString("\n") { i ->
+                if (i % 2 == 0) """{"sentence": "the cat sat on the mat.", "label": 1}"""
+                else """{"sentence": "cat the mat on sat the.", "label": 0}"""
+            } + "\n",
+        )
+
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Training),
+        )
+        try {
+            val losses = mutableListOf<Float>()
+            val result = model.train(
+                DatasetConfig(
+                    trainFile = trainFile,
+                    task = "cola",
+                    maxSequenceLength = 64,
+                    maxDatasetLength = 64,
+                    datasetBatchSize = 4,
+                ),
+                TrainConfig(maxSteps = STEPS, batchSize = 2, learningRate = 5e-4f, mergeAtEnd = false),
+                object : TrainCallback {
+                    override fun onStepEnd(progress: TrainProgress) {
+                        losses.add(progress.stepLoss)
+                    }
+                },
+            )
+
+            assertTrue(
+                "no per-step losses were reported — onStepEnd never fired, so the trend cannot be " +
+                    "measured and training cannot be shown to do anything",
+                losses.size >= 6,
+            )
+            assertTrue(
+                "every reported loss was 0/NaN (${losses.take(5)}) — the loss is not connected to the " +
+                    "parameters being trained",
+                losses.any { it.isFinite() && it > 0f },
+            )
+
+            val window = losses.size / 3
+            val first = losses.take(window).average()
+            val last = losses.takeLast(window).average()
+            val drop = (first - last) / first
+
+            Log.i(
+                LOG_TAG,
+                "steps=${losses.size} firstThirdMean=$first lastThirdMean=$last drop=${"%.1f".format(drop * 100)}% " +
+                    "finalLoss=${result.finalLoss}",
+            )
+
+            assertTrue(
+                "loss did not fall: first-third mean=$first, last-third mean=$last " +
+                    "(${"%.1f".format(drop * 100)}%, need ${(REQUIRED_RELATIVE_DROP * 100).toInt()}%). " +
+                    "The train→merge plumbing can pass its byte-level assertions while the optimizer " +
+                    "does nothing; this is the check that separates the two.",
+                drop >= REQUIRED_RELATIVE_DROP,
+            )
+        } finally {
+            model.close()
+        }
+    }
+
+    /**
+     * The training graph starts from the **pretrained** weights, not random ones.
+     *
+     * ### Why this is a comparison and not a threshold
+     *
+     * This test previously asserted `initialLoss < 6.0`, reasoning that a pretrained 135M model on
+     * English sits near 3 and the uniform-prediction floor is `ln(49152) = 10.80`. It failed at ~14.25
+     * and was recorded as a v1 blocker: "two thirds of the model is in neither artifact", from reading
+     * the 176 MB checkpoint as `176MB / 4 bytes ≈ 44M` fp32 parameters.
+     *
+     * **Both halves of that were wrong.** ~90% of the checkpoint tensors are uint8, not fp32; the
+     * training graph carries all 135,436,911 parameters (verified against the shipped artifact, and
+     * now gated on the host by `artifacts/parameter_budget.py`). And the threshold measured something
+     * other than what it claimed: `ORTDataCurator` masks every prompt token to `-100`, and under
+     * `CoLAPreprocessor` the answer `"acceptable"` is a **single token** following a trailing-space
+     * prompt — so "initial loss" was the cross-entropy of one improbable token, not a sequence LM
+     * loss. ~14 is the correct value for that, and it reproduces from the fp32 *inference* graph.
+     *
+     * An absolute bound cannot distinguish "not pretrained" from "this particular answer string is
+     * unlikely". So this asserts the property that actually implies pretrained weights and needs no
+     * model-specific constant: **coherent English must cost materially less than token soup.** Only a
+     * model carrying real weights can tell them apart; an untrained one scores both alike, because
+     * under a near-uniform distribution neither is more probable.
+     *
+     * The two corpora are matched deliberately — same preprocessor, same field, same approximate token
+     * length — so the only variable is coherence.
+     */
+    @Test
+    fun trainingStartsFromPretrainedWeightsNotRandomOnes(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+
+        // The SUPERVISED text, not the prompt: `ORTDataCurator` masks prompt tokens to -100, so only
+        // this side reaches the loss. `mini_recommendation` supervises its `recommendation` field
+        // verbatim, which is why this test uses it rather than `cola` (whose target is one of two
+        // fixed words chosen by `label`, and so cannot be varied at all).
+        val coherent = "open the calendar app and create a meeting for tomorrow morning at nine"
+        val soup = "gzt qwx vbn plok zrf mjud xqi wbe trng kvo phz lmq brx qynt"
+
+        val coherentLoss = initialLossFor(ctx, root, repoId, "mt_device_coherent", coherent)
+        val soupLoss = initialLossFor(ctx, root, repoId, "mt_device_soup", soup)
+        val margin = (soupLoss - coherentLoss) / soupLoss
+
+        Log.i(
+            LOG_TAG,
+            "initial loss: coherent=$coherentLoss soup=$soupLoss " +
+                "margin=${"%.1f".format(margin * 100)}%",
+        )
+
+        assertTrue(
+            "both initial losses must be finite and positive (coherent=$coherentLoss soup=$soupLoss) " +
+                "— otherwise the loss is not connected to the parameters and neither number means " +
+                "anything",
+            coherentLoss.isFinite() && soupLoss.isFinite() && coherentLoss > 0.0 && soupLoss > 0.0,
+        )
+        assertTrue(
+            "the training graph scores coherent English (loss=$coherentLoss) no better than random " +
+                "token soup (loss=$soupLoss) — margin ${"%.1f".format(margin * 100)}%, need " +
+                "${(REQUIRED_COHERENCE_MARGIN * 100).toInt()}%. A model holding its pretrained " +
+                "weights separates these by several nats; one starting from random weights cannot " +
+                "separate them at all. Check the training-stage export: the host-side parameter " +
+                "budget and train/inference parity gates in artifacts/ should have caught this first.",
+            margin >= REQUIRED_COHERENCE_MARGIN,
+        )
+    }
+
+    /**
+     * Initial (step-0) training loss over a corpus of one repeated sentence.
+     *
+     * A fresh model per corpus: `mergeAtEnd = false` leaves the on-disk checkpoint untouched, so each
+     * call genuinely starts from the packaged weights rather than from the previous call's updates.
+     */
+    private suspend fun initialLossFor(
+        ctx: android.content.Context,
+        root: File,
+        repoId: String,
+        trainFile: String,
+        supervisedText: String,
+    ): Double {
+        // Identical prompt in both corpora so the only variable is the supervised continuation.
+        File(root, "$repoId/train/$trainFile.jsonl").writeText(
+            (1..16).joinToString("\n") {
+                """{"prompt": "what should I do next?", "recommendation": "$supervisedText"}"""
+            } + "\n",
+        )
+
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Training),
+        )
+        return try {
+            val losses = mutableListOf<Float>()
+            model.train(
+                DatasetConfig(
+                    trainFile = trainFile,
+                    task = "mini_recommendation",
+                    maxSequenceLength = 64,
+                    maxDatasetLength = 16,
+                    datasetBatchSize = 4,
+                ),
+                TrainConfig(maxSteps = 1, batchSize = 2, mergeAtEnd = false),
+                object : TrainCallback {
+                    override fun onStepEnd(progress: TrainProgress) {
+                        losses.add(progress.stepLoss)
+                    }
+                },
+            )
+            losses.firstOrNull()?.toDouble() ?: Double.NaN
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainMergeGenerateTest.kt b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainMergeGenerateTest.kt
new file mode 100644
index 0000000..f711808
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/androidTest/java/com/martinkorelic/mobiletransformers/TrainMergeGenerateTest.kt
@@ -0,0 +1,148 @@
+package com.martinkorelic.mobiletransformers
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * #18 + #19 device checkpoint: baseline generate → train(maxSteps=1) → merge() → generate; assert the
+ * merged output diverges from the pre-train baseline. Requires a train-capable package (`train/`).
+ */
+@RunWith(AndroidJUnit4::class)
+class TrainMergeGenerateTest {
+
+    /**
+     * Restore the package after every test in this class. It trains and/or merges, which rewrites the
+     * checkpoint and the `inference/` weight blobs in place — see [PristinePackageRule] for the three
+     * suite failures this prevents.
+     */
+    @get:Rule
+    val pristinePackage = PristinePackageRule()
+
+    @Test
+    // Explicit `: Unit`. With expression-body syntax the return type is inferred from the block's
+    // last expression, so ending it with something non-Unit (a `Log.i`, which returns Int) silently
+    // makes the method non-void and JUnit rejects the whole class with
+    // "Method ... should be void" — surfacing as a runner-instantiation failure, not a test failure.
+    fun trainMergeGenerateDivergesFromBaseline(): Unit = runBlocking {
+        val root = DeviceModel.requireCacheRoot()
+        val repoId = DeviceModel.repoId(root)
+        DeviceModel.requireDecoder(root, repoId)
+        assumeTrue("package is not train-capable (no train/ stage)", DeviceModel.hasTraining(root, repoId))
+
+        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+
+        // The package ships model artifacts, not training data, so the caller supplies both the dataset
+        // and the preprocessor that parses it (`DatasetConfig.task`). ORTDataCurator reads
+        // `<cacheDir>/<repo>/train/<trainFile>.jsonl`; `cola` is the simplest supported schema.
+        val trainFile = "mt_device_test_cola"
+        File(root, "$repoId/train/$trainFile.jsonl").writeText(
+            (1..8).joinToString("\n") { i ->
+                """{"sentence": "The cat sat on the mat number $i.", "label": ${i % 2}}"""
+            } + "\n",
+        )
+
+        val model = MobileTransformers.fromPretrained(
+            context = ctx,
+            repoId = repoId,
+            cacheDir = root.absolutePath,
+            features = setOf(ModelFeature.Inference, ModelFeature.Training),
+        )
+        try {
+            val gen = GenerationConfig(maxNewTokens = 8, loadMerged = true)
+            val baseline = model.generate("The capital of France is", gen).text
+
+            // Fingerprint the trainable tensors BEFORE training. The merge writes new weights into
+            // these per-tensor `.bin` files in place (#9), so their bytes changing is the direct
+            // evidence that train -> merge -> handoff actually moved weights.
+            //
+            // Asserting only that the generated text changes does NOT test that: one LoRA step on q/k
+            // at lr 1e-4 legitimately leaves 8 greedy tokens identical, so a text-only assertion fails
+            // on a good merge and would equally pass if the merge silently wrote nothing.
+            val binNames = ArrayList<String>()
+            val beforeHashes = HashMap<String, Int>()
+            val listed = File(root, repoId + "/inference").listFiles()
+            if (listed != null) {
+                for (f in listed) {
+                    if (f.name.endsWith(".MatMul.weight.bin")) {
+                        binNames.add(f.name)
+                        beforeHashes[f.name] = f.readBytes().contentHashCode()
+                    }
+                }
+            }
+            assertTrue("package has no per-tensor trainable .bin files", binNames.size > 0)
+
+            model.train(
+                DatasetConfig(
+                    trainFile = trainFile,
+                    task = "cola",
+                    maxSequenceLength = 64,
+                    maxDatasetLength = 8,
+                    datasetBatchSize = 4,
+                ),
+                TrainConfig(maxSteps = 1, batchSize = 2, mergeAtEnd = true),
+            )
+            model.merge()
+
+            var changed = 0
+            for (name in binNames) {
+                val h = File(root, repoId + "/inference/" + name).readBytes().contentHashCode()
+                if (h != beforeHashes[name]) changed++
+            }
+            assertTrue(
+                "merge wrote no new weights: all " + binNames.size + " trainable .bin files are " +
+                    "unchanged. The merge rewrites these files IN PLACE, so a package that has " +
+                    "already been merged re-merges to identical bytes — this test therefore needs a " +
+                    "package no earlier test has merged. PristinePackageRule restores it around every " +
+                    "mutating class, so if you are seeing this, either the rule is not applied to a " +
+                    "class that merges, or the merge genuinely wrote nothing (check logcat for " +
+                    "'Starting weight merging process').",
+                changed > 0,
+            )
+
+            // Generation must still work off the merged weights. The text is reported rather than
+            // asserted *different*: after a single step the argmax may legitimately be unchanged.
+            val after = model.generate("The capital of France is", gen).text
+
+            // `after.isNotEmpty()` was the whole assertion here until 2026-08-14, and it is far too
+            // weak: a model whose weights the merge had destroyed emitted 48 consecutive newlines,
+            // which is non-empty. That is not a hypothetical — the merge was writing every weight
+            // TRANSPOSED for months and this test passed throughout.
+            //
+            // Still deliberately behavioural rather than exact: this suite trains ONE step, so the
+            // output legitimately varies. What a corrupted model does is degenerate — a single
+            // character or token repeated, or pure whitespace — so that is what is excluded.
+            // `PostMergeNumericsTest` owns the numerical assertion; this one owns "did the text
+            // survive at all".
+            assertTrue("generation returned nothing after merge", after.isNotEmpty())
+            assertTrue(
+                "generation after merge produced only whitespace (${after.length} chars) — the classic " +
+                    "signature of a model whose merged weights are corrupt. Raw: <$after>",
+                after.isNotBlank(),
+            )
+            val distinctNonSpace = after.filterNot { it.isWhitespace() }.toSet().size
+            assertTrue(
+                "generation after merge produced $distinctNonSpace distinct non-whitespace character(s) " +
+                    "in ${after.length} chars — a degenerate repeated token, not text. This is what a " +
+                    "corrupted merge looks like, and what `isNotEmpty()` used to accept. Raw: <$after>",
+                distinctNonSpace >= 2,
+            )
+            android.util.Log.i(
+                "TrainMergeGenerateTest",
+                "merged " + changed + "/" + binNames.size + " tensors; baseline=<" + baseline + "> after=<" + after + ">",
+            )
+        } finally {
+            model.close()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/AndroidManifest.xml b/android/MobileTransformers/MobileTransformers/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..7454358
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/AndroidManifest.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!--
+      #34 scheduled training. Declared in the LIBRARY, not left to the consuming app to discover:
+      a foreground WorkManager worker cannot start without these, and a consumer that only calls
+      TrainingScheduler.schedule() has no way to know that.
+
+      * FOREGROUND_SERVICE          — required for any foreground service.
+      * FOREGROUND_SERVICE_DATA_SYNC — API 34+ requires the permission matching the service TYPE the
+                                       worker declares (ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC).
+      * POST_NOTIFICATIONS          — API 33+; the persistent progress notification is mandatory for a
+                                       foreground worker, and this feature is deliberately visible.
+      * WAKE_LOCK                   — held by WorkManager for the duration of a chunk.
+
+      The dataSync service type is also declared on WorkManager's own SystemForegroundService so the
+      merged manifest carries the type for the worker that calls setForeground().
+    -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <!--
+      #21/#22 Hub I/O. Declared in the LIBRARY for the same reason as the block above: `HubDownloader`
+      -> `PackageDownloader` -> OkHttp is reached from `MobileTransformers.fromPretrained` whenever the
+      requested package is not installed, so an app that only ever calls the documented entry point
+      would otherwise crash on a permission it was never told it needed.
+
+      This was MISSING for the entire life of the feature. The whole #21 download stack — resolver,
+      planner, streaming downloader with Range-resume and sha256 verification, WorkManager worker,
+      installer — is complete and JVM-tested against MockWebServer, and had never once been able to run
+      on a device: the first real GET throws SecurityException. That is why #21's on-device leg stayed
+      open. `tests/unit/test_guards.py::test_the_library_manifest_declares_internet` now pins it.
+    -->
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application>
+        <service
+            android:name="androidx.work.impl.foreground.SystemForegroundService"
+            android:foregroundServiceType="dataSync"
+            tools:node="merge"
+            xmlns:tools="http://schemas.android.com/tools" />
+    </application>
+
+</manifest>
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/CMakeLists.txt b/android/MobileTransformers/MobileTransformers/src/main/cpp/CMakeLists.txt
similarity index 87%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/CMakeLists.txt
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/CMakeLists.txt
index 6d53fa7..4860144 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/CMakeLists.txt
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/CMakeLists.txt
@@ -9,7 +9,7 @@ cmake_minimum_required(VERSION 3.22.1)
 # Since this is the top level CMakeLists.txt, the project name is also accessible
 # with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level
 # build script scope).
-project("ortmobile")
+project("mobiletransformers")
 
 # Creates and names a library, sets it as either STATIC
 # or SHARED, and provides the relative paths to its source code.
@@ -31,10 +31,13 @@ add_library(${CMAKE_PROJECT_NAME} SHARED
         train.cpp
         inference.cpp
         native-lib.cpp
-        weight_serializer.cpp
         weight_merger.cpp
         sampling.cpp
-        proto/onnx.pb.cc)
+        genai_spike.cpp
+        genai_runtime.cpp)
+# NOTE: proto/onnx.pb.cc + protobuf-lite were dropped with weight_serializer.cpp (#23). The flat
+# per-tensor <name>.bin files are RAW external-data bytes, not serialized TensorProtos, so nothing on
+# device parses ONNX protobuf any more — which also retires the vendored cpp/includes/google headers.
 
 target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/onnxruntime)
 target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/includes)
@@ -60,6 +63,5 @@ target_link_libraries(${CMAKE_PROJECT_NAME}
         tokenizers_cpp
         onnxruntime
         onnxruntime-genai
-        protobuf-lite
         nlohmann_json::nlohmann_json
 )
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/constants/merger_variant.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/constants/merger_variant.h
new file mode 100644
index 0000000..635e159
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/constants/merger_variant.h
@@ -0,0 +1,49 @@
+//
+// #6: C++ mirror of the MergerVariant enum owned by
+// src/mobiletransformers/config/constants.py (and mirrored in Kotlin at
+// constants/MergerVariant.kt). Wire values are checked against Python by
+// `make parity` — do not edit them by hand without regenerating.
+//
+// This replaces the raw `merger_type == "lora"` string dispatch that used to live in
+// weight_merger.cpp. The variant is RESOLVED data (adapter shape + quantization), and
+// weight_handoff_map.json's `mergerModels` is keyed by exactly these wire values, so the merger
+// session is now selected by a typed tag rather than by a manufactured string that had to
+// coincidentally match the map's keys.
+//
+
+#ifndef MOBILETRANSFORMERS_MERGER_VARIANT_H
+#define MOBILETRANSFORMERS_MERGER_VARIANT_H
+
+#include <optional>
+#include <string>
+#include <utility>
+
+enum class MergerVariant {
+    LORA,
+    LORA_Q,
+    MARS_Q,
+};
+
+// The single wire-value table (parity-checked against ENUM_REGISTRY["MergerVariant"]).
+inline constexpr std::pair<MergerVariant, const char*> kMergerVariantWire[] = {
+        {MergerVariant::LORA, "lora"},
+        {MergerVariant::LORA_Q, "lora_q"},
+        {MergerVariant::MARS_Q, "mars_q"},
+};
+
+inline const char* to_wire(MergerVariant v) {
+    for (const auto& [value, wire] : kMergerVariantWire) {
+        if (value == v) return wire;
+    }
+    return "";  // unreachable: MergerVariant is a closed enum
+}
+
+// Fail-closed parse: an unknown tag yields nullopt rather than a silent default.
+inline std::optional<MergerVariant> merger_variant_from_wire(const std::string& wire) {
+    for (const auto& [value, w] : kMergerVariantWire) {
+        if (wire == w) return value;
+    }
+    return std::nullopt;
+}
+
+#endif  // MOBILETRANSFORMERS_MERGER_VARIANT_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_runtime.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_runtime.cpp
new file mode 100644
index 0000000..e56523d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_runtime.cpp
@@ -0,0 +1,177 @@
+// GenAI ModelRuntime engine (#11) — promoted from genai_spike.cpp. A session-handle wrapper over the stable
+// ONNX Runtime GenAI C API with token-by-token streaming, so ORTGeneratorGenAI.kt can drive the SAME
+// GenerationCallback/InferenceProgress sequence as the Native engine (loop in Kotlin, one JNI call per
+// token). GenAI runs on the genai-paired stock ORT shipped as libort_gen.so (see
+// spikes/genai_external_swap/README.md — ORT separation); no OgaCreateModelWithInitializers (fork-only).
+
+#include <jni.h>
+#include <android/log.h>
+#include <string>
+
+#include "onnxruntime-genai/ort_genai_c.h"
+
+#define LOG_TAG "GenAIRuntime"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+struct GenAISession {
+    OgaModel* model = nullptr;
+    OgaTokenizer* tok = nullptr;
+    OgaTokenizerStream* stream = nullptr;
+    OgaGeneratorParams* params = nullptr;
+    OgaGenerator* gen = nullptr;
+    int last_token = -1;
+    // sampling (applied at start): 0 greedy, 1 top_k, 2 top_p
+    int method = 0;
+    float temperature = 1.0f;
+    int top_k = 10;
+    float top_p = 0.9f;
+    int seed = 42;
+};
+
+bool oga_failed(OgaResult* r, const char* where) {
+    if (r == nullptr) return false;
+    const char* msg = OgaResultGetError(r);
+    LOGE("%s: %s", where, msg ? msg : "(null)");
+    OgaDestroyResult(r);
+    return true;
+}
+
+void reset_generation(GenAISession* s) {
+    if (s->gen) { OgaDestroyGenerator(s->gen); s->gen = nullptr; }
+    if (s->params) { OgaDestroyGeneratorParams(s->params); s->params = nullptr; }
+}
+
+GenAISession* handle(jlong h) { return reinterpret_cast<GenAISession*>(h); }
+
+}  // namespace
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeCreate(
+    JNIEnv* env, jobject, jstring jdir) {
+    const char* dir = env->GetStringUTFChars(jdir, nullptr);
+    auto* s = new GenAISession();
+    bool ok = false;
+    try {
+        if (!oga_failed(OgaCreateModel(dir, &s->model), "OgaCreateModel") &&
+            !oga_failed(OgaCreateTokenizer(s->model, &s->tok), "OgaCreateTokenizer") &&
+            !oga_failed(OgaCreateTokenizerStream(s->tok, &s->stream), "OgaCreateTokenizerStream")) {
+            ok = true;
+        }
+    } catch (...) {
+        LOGE("nativeCreate: exception (ORT/GenAI ABI?)");
+    }
+    env->ReleaseStringUTFChars(jdir, dir);
+    if (!ok) {
+        if (s->stream) OgaDestroyTokenizerStream(s->stream);
+        if (s->tok) OgaDestroyTokenizer(s->tok);
+        if (s->model) OgaDestroyModel(s->model);
+        delete s;
+        return 0;
+    }
+    return reinterpret_cast<jlong>(s);
+}
+
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeSetSampling(
+    JNIEnv*, jobject, jlong h, jint method, jfloat temperature, jint topK, jfloat topP, jint seed) {
+    auto* s = handle(h);
+    if (!s) return;
+    s->method = method;
+    s->temperature = temperature;
+    s->top_k = topK;
+    s->top_p = topP;
+    s->seed = seed;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeStart(
+    JNIEnv* env, jobject, jlong h, jstring jprompt, jint maxNewTokens) {
+    auto* s = handle(h);
+    if (!s) return JNI_FALSE;
+    const char* prompt = env->GetStringUTFChars(jprompt, nullptr);
+    OgaSequences* seqs = nullptr;
+    bool ok = false;
+    try {
+        reset_generation(s);
+        if (oga_failed(OgaCreateSequences(&seqs), "OgaCreateSequences")) goto done;
+        if (oga_failed(OgaTokenizerEncode(s->tok, prompt, seqs), "OgaTokenizerEncode")) goto done;
+        {
+            size_t prompt_len = OgaSequencesGetSequenceCount(seqs, 0);
+            if (oga_failed(OgaCreateGeneratorParams(s->model, &s->params), "OgaCreateGeneratorParams")) goto done;
+            OgaGeneratorParamsSetSearchNumber(s->params, "max_length", (double)(prompt_len + maxNewTokens));
+            OgaGeneratorParamsSetSearchBool(s->params, "do_sample", s->method != 0);
+            if (s->method == 1) OgaGeneratorParamsSetSearchNumber(s->params, "top_k", s->top_k);
+            if (s->method == 2) OgaGeneratorParamsSetSearchNumber(s->params, "top_p", s->top_p);
+            if (s->method != 0) OgaGeneratorParamsSetSearchNumber(s->params, "temperature", s->temperature);
+            if (oga_failed(OgaCreateGenerator(s->model, s->params, &s->gen), "OgaCreateGenerator")) goto done;
+            if (oga_failed(OgaGenerator_AppendTokenSequences(s->gen, seqs), "AppendTokenSequences")) goto done;
+            ok = true;
+        }
+    } catch (...) {
+        LOGE("nativeStart: exception");
+    }
+done:
+    if (seqs) OgaDestroySequences(seqs);
+    env->ReleaseStringUTFChars(jprompt, prompt);
+    return ok ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeIsDone(JNIEnv*, jobject, jlong h) {
+    auto* s = handle(h);
+    if (!s || !s->gen) return JNI_TRUE;
+    return OgaGenerator_IsDone(s->gen) ? JNI_TRUE : JNI_FALSE;
+}
+
+// Generate one token; return its decoded (streamed) piece. Empty string on error/no-token.
+JNIEXPORT jstring JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeStep(JNIEnv* env, jobject, jlong h) {
+    auto* s = handle(h);
+    if (!s || !s->gen) return env->NewStringUTF("");
+    std::string piece;
+    try {
+        if (oga_failed(OgaGenerator_GenerateNextToken(s->gen), "GenerateNextToken")) return env->NewStringUTF("");
+        const int32_t* next = nullptr;
+        size_t count = 0;
+        if (!oga_failed(OgaGenerator_GetNextTokens(s->gen, &next, &count), "GetNextTokens") && next && count > 0) {
+            s->last_token = next[count - 1];
+            const char* out = nullptr;
+            if (!oga_failed(OgaTokenizerStreamDecode(s->stream, s->last_token, &out), "StreamDecode") && out) {
+                piece = out;  // 'out' is owned by the stream; copy before returning
+            }
+        }
+    } catch (...) {
+        LOGE("nativeStep: exception");
+    }
+    return env->NewStringUTF(piece.c_str());
+}
+
+JNIEXPORT jint JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeLastToken(JNIEnv*, jobject, jlong h) {
+    auto* s = handle(h);
+    return s ? s->last_token : -1;
+}
+
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorGenAI_nativeRelease(JNIEnv*, jobject, jlong h) {
+    auto* s = handle(h);
+    if (!s) return;
+    reset_generation(s);
+    if (s->stream) OgaDestroyTokenizerStream(s->stream);
+    if (s->tok) OgaDestroyTokenizer(s->tok);
+    if (s->model) OgaDestroyModel(s->model);
+    delete s;
+}
+
+// genaiAvailable() native probe (#11 / Gate 0.1): the genai stack is linked and OgaCreateModel resolves,
+// otherwise this library would not have loaded. Gate 0.1 passed (see spikes/genai_external_swap).
+JNIEXPORT jboolean JNICALL
+Java_com_martinkorelic_mobiletransformers_runtime_GenAiSupport_nativeGenAiAvailable(JNIEnv*, jobject) {
+    return JNI_TRUE;
+}
+
+}  // extern "C"
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_spike.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_spike.cpp
new file mode 100644
index 0000000..1077189
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/genai_spike.cpp
@@ -0,0 +1,132 @@
+// GenAI external-data-swap spike (#10, Gate 0.1) — minimal JNI over the stable ONNX Runtime GenAI C API.
+//
+// Proves finding F2 on-device: OgaCreateModel(<inference dir>) resolves the package's relative external
+// data, generates one token, and a FRESH model reflects overwritten external .bin bytes (no graph rewrite,
+// no fork — OgaCreateModelWithInitializers is confirmed fork-only/absent, see check_symbols.sh). This is the
+// seed of the File #11 GenAI engine wrapper that replaces the abandoned onnx-genai.cpp.
+//
+// runOneToken(dir, prompt) returns "token=<id>;fp=<logits fingerprint>;rssPre=<kB>;rssLoaded=<kB>;rssTok=<kB>".
+// The instrumented test (GenAISpikeTest.kt) calls it before and after perturbing one external weight and
+// asserts the fingerprint changes (swap observed).
+
+#include <jni.h>
+#include <android/log.h>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "onnxruntime-genai/ort_genai_c.h"
+
+#define LOG_TAG "GenAISpike"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+long rss_kb() {  // VmRSS from /proc/self/status (Android/Linux)
+    std::ifstream s("/proc/self/status");
+    std::string k;
+    while (s >> k) {
+        if (k == "VmRSS:") {
+            long v = -1;
+            s >> v;
+            return v;
+        }
+    }
+    return -1;
+}
+
+std::string g_last_error;  // last GenAI error text, surfaced back to the test
+
+// Throw-free error surfacing: capture + log the GenAI error and return whether the call failed.
+bool failed(OgaResult* r, const char* where) {
+    if (r == nullptr) return false;
+    const char* msg = OgaResultGetError(r);
+    g_last_error = std::string(where) + ": " + (msg ? msg : "(null)");
+    LOGE("%s", g_last_error.c_str());
+    OgaDestroyResult(r);
+    return true;
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_martinkorelic_mobiletransformers_GenAISpike_runOneToken(
+    JNIEnv* env, jobject /*thiz*/, jstring jdir, jstring jprompt) {
+    const char* dir = env->GetStringUTFChars(jdir, nullptr);
+    const char* prompt = env->GetStringUTFChars(jprompt, nullptr);
+    std::string out = "error";
+    g_last_error.clear();
+
+  try {  // catch C++ exceptions crossing the C-API boundary so the test fails cleanly (not SIGABRT)
+    long rss_pre = rss_kb();  // (1) before load
+
+    OgaModel* model = nullptr;
+    OgaTokenizer* tok = nullptr;
+    OgaSequences* seqs = nullptr;
+    OgaGeneratorParams* params = nullptr;
+    OgaGenerator* gen = nullptr;
+    OgaTensor* logits = nullptr;
+
+    do {
+        if (failed(OgaCreateModel(dir, &model), "OgaCreateModel")) break;
+        long rss_loaded = rss_kb();  // (2) after load — mmap ~= file size, copy ~= 2x
+
+        if (failed(OgaCreateTokenizer(model, &tok), "OgaCreateTokenizer")) break;
+        if (failed(OgaCreateSequences(&seqs), "OgaCreateSequences")) break;
+        if (failed(OgaTokenizerEncode(tok, prompt, seqs), "OgaTokenizerEncode")) break;
+
+        size_t prompt_len = OgaSequencesGetSequenceCount(seqs, 0);
+        if (failed(OgaCreateGeneratorParams(model, &params), "OgaCreateGeneratorParams")) break;
+        OgaGeneratorParamsSetSearchNumber(params, "max_length", (double)(prompt_len + 1));
+        OgaGeneratorParamsSetSearchBool(params, "do_sample", false);
+        if (failed(OgaCreateGenerator(model, params, &gen), "OgaCreateGenerator")) break;
+        if (failed(OgaGenerator_AppendTokenSequences(gen, seqs), "AppendTokenSequences")) break;
+        if (failed(OgaGenerator_GenerateNextToken(gen), "GenerateNextToken")) break;
+        long rss_tok = rss_kb();  // (3) after first token
+
+        // Logits fingerprint (order-sensitive) so the test can detect a swap without shipping the vector.
+        double fp = 0.0;
+        if (!failed(OgaGenerator_GetLogits(gen, &logits), "GetLogits") && logits) {
+            void* data = nullptr;
+            size_t rank = 0;
+            OgaTensorGetShapeRank(logits, &rank);
+            std::vector<int64_t> shape(rank);
+            OgaTensorGetShape(logits, shape.data(), rank);
+            size_t count = 1;
+            for (size_t i = 0; i < rank; ++i) count *= (size_t)shape[i];
+            if (!failed(OgaTensorGetData(logits, &data), "GetData") && data) {
+                const float* f = static_cast<const float*>(data);
+                for (size_t i = 0; i < count; ++i) fp += (double)f[i] * (double)((i % 1024) + 1);
+            }
+        }
+
+        size_t seq_len = OgaGenerator_GetSequenceCount(gen, 0);
+        const int32_t* seq = OgaGenerator_GetSequenceData(gen, 0);
+        int token = (seq && seq_len > 0) ? seq[seq_len - 1] : -1;
+
+        LOGI("dir=%s token=%d fp=%.6f rss pre=%ld loaded=%ld tok=%ld", dir, token, fp, rss_pre, rss_loaded, rss_tok);
+        out = "token=" + std::to_string(token) + ";fp=" + std::to_string(fp) +
+              ";rssPre=" + std::to_string(rss_pre) + ";rssLoaded=" + std::to_string(rss_loaded) +
+              ";rssTok=" + std::to_string(rss_tok);
+    } while (false);
+
+    if (logits) OgaDestroyTensor(logits);
+    if (gen) OgaDestroyGenerator(gen);
+    if (params) OgaDestroyGeneratorParams(params);
+    if (seqs) OgaDestroySequences(seqs);
+    if (tok) OgaDestroyTokenizer(tok);
+    if (model) OgaDestroyModel(model);
+  } catch (const std::exception& e) {
+    g_last_error = std::string("exception: ") + e.what();
+    LOGE("%s", g_last_error.c_str());
+  } catch (...) {
+    g_last_error = "exception: non-std (ORT/GenAI ABI mismatch?)";
+    LOGE("%s", g_last_error.c_str());
+  }
+
+    if (out == "error") out = "error=" + g_last_error;
+    env->ReleaseStringUTFChars(jdir, dir);
+    env->ReleaseStringUTFChars(jprompt, prompt);
+    return env->NewStringUTF(out.c_str());
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/handoff_io.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/handoff_io.h
new file mode 100644
index 0000000..9672461
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/handoff_io.h
@@ -0,0 +1,146 @@
+//
+// #23: the ONE reader of weight_handoff_map.json (#8 schema), shared by the merger WRITE side
+// (weight_merger.cpp) and the inference LOAD side (session_cache.h) so tensor identity is derived from
+// a single place on device — no second reader, no <dirname>.<filestem> name reconstruction.
+//
+// Deliberately ORT-free (JSON + POD only): turning the declared per-role dtype/shape into an Ort::Value
+// belongs to the load side (session_cache.h), which has the ORT types. Checksums are the primary responsibility
+// of the Kotlin precondition (HandoffPrecondition.loadMergedWeightsReady) which runs BEFORE the session
+// is created; this reader + the load side add the map-driven naming + dtype/shape fail-closed check.
+//
+
+#ifndef MOBILETRANSFORMERS_HANDOFF_IO_H
+#define MOBILETRANSFORMERS_HANDOFF_IO_H
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <unordered_map>
+#include <fstream>
+#include <nlohmann/json.hpp>
+#include "logging.h"
+
+// One entry of weight_handoff_map.json (#8 schema / #9 write + #23 load consumer): the SINGLE source of
+// tensor identity for the on-device merge AND load. externalDataLocation[role] is the per-tensor .bin;
+// inferenceInitializerNames[role] is the canonical graph initializer name. No string-rewrite on device.
+struct HandoffEntry {
+    std::string trainingBaseLayerName;
+    std::unordered_map<std::string, std::string> externalDataLocation;   // role -> "<name>.bin"
+    std::unordered_map<std::string, std::string> inferenceInitializerNames; // role -> canonical name
+    std::string dtype;                    // entry-level (weight-like role) dtype
+    std::vector<int64_t> shape;           // entry-level (weight-like role) shape
+    // Per-role on-disk dtype/shape. REQUIRED by the load side: each <name>.bin holds RAW external-data
+    // bytes with no header, so this map is the only description of a packed weight_quantized/scale/
+    // zero_point tensor, whose layout differs from the entry-level weight's. Empty for maps written
+    // before the field existed -> the entry-level pair is the fallback (sound for a single fp role).
+    std::unordered_map<std::string, std::string> tensorDtypes;            // role -> dtype
+    std::unordered_map<std::string, std::vector<int64_t>> tensorShapes;   // role -> shape
+    std::string transposePolicy;
+    bool has_quantization = false;
+
+    // On-disk dtype/shape of [role], falling back to the entry-level pair.
+    const std::string& dtype_for(const std::string& role) const {
+        auto it = tensorDtypes.find(role);
+        return it != tensorDtypes.end() ? it->second : dtype;
+    }
+    const std::vector<int64_t>& shape_for(const std::string& role) const {
+        auto it = tensorShapes.find(role);
+        return it != tensorShapes.end() ? it->second : shape;
+    }
+};
+
+// ---- Semver gate mirroring mobiletransformers/artifacts/versioning.py::check_compat (F1). ----
+inline bool parse_version(const std::string& v, int& major, int& minor) {
+    auto dot = v.find('.');
+    if (dot == std::string::npos) return false;
+    try {
+        major = std::stoi(v.substr(0, dot));
+        minor = std::stoi(v.substr(dot + 1));
+    } catch (...) { return false; }
+    return major >= 0 && minor >= 0;
+}
+
+inline bool check_compat(const std::string& docSchema, const std::string& docMinReader,
+                         const std::string& readerSchema) {
+    int dMaj, dMin, rqMaj, rqMin, rMaj, rMin;
+    if (!parse_version(docSchema, dMaj, dMin) || !parse_version(docMinReader, rqMaj, rqMin) ||
+        !parse_version(readerSchema, rMaj, rMin)) {
+        return false;
+    }
+    if (dMaj > rMaj) return false;                                   // doc needs a newer major SDK
+    if (rMaj < rqMaj || (rMaj == rqMaj && rMin < rqMin)) return false; // reader below doc minReaderVersion
+    return true;
+}
+
+// Load + version-gate weight_handoff_map.json into [out] keyed by trainingBaseLayerName. Optionally
+// collects mergerModels (MergerVariant tag -> ONNX filename). Returns false (and leaves [out] empty) on
+// open/parse/schema failure — the caller fails closed.
+inline bool load_handoff_entries(const std::string& json_path, const std::string& readerVersion,
+                                 std::unordered_map<std::string, HandoffEntry>& out,
+                                 std::unordered_map<std::string, std::string>* merger_models = nullptr) {
+    using nlohmann::json;
+    out.clear();
+    if (merger_models) merger_models->clear();
+    try {
+        std::ifstream file(json_path);
+        if (!file.is_open()) {
+            LOGE("Failed to open handoff map: %s", json_path.c_str());
+            return false;
+        }
+        json j;
+        file >> j;
+
+        const std::string docSchema = j.value("schemaVersion", "");
+        const std::string docMinReader = j.value("minReaderVersion", "");
+        if (!check_compat(docSchema, docMinReader, readerVersion)) {
+            LOGE("handoff map schema %s (minReader %s) incompatible with reader %s",
+                 docSchema.c_str(), docMinReader.c_str(), readerVersion.c_str());
+            return false;
+        }
+
+        if (merger_models && j.contains("mergerModels")) {
+            for (const auto& [variant, filename] : j["mergerModels"].items())
+                (*merger_models)[variant] = filename.get<std::string>();
+        }
+
+        for (const auto& entry_json : j.value("entries", json::array())) {
+            HandoffEntry entry;
+            entry.trainingBaseLayerName = entry_json.value("trainingBaseLayerName", "");
+            entry.dtype = entry_json.value("dtype", "");
+            entry.transposePolicy = entry_json.value("transposePolicy", "no_transpose");
+            entry.has_quantization =
+                entry_json.contains("quantization") && !entry_json["quantization"].is_null();
+            if (entry_json.contains("shape")) {
+                for (const auto& d : entry_json["shape"]) entry.shape.push_back(d.get<int64_t>());
+            }
+            if (entry_json.contains("tensorDtypes")) {
+                for (const auto& [role, dt] : entry_json["tensorDtypes"].items())
+                    entry.tensorDtypes[role] = dt.get<std::string>();
+            }
+            if (entry_json.contains("tensorShapes")) {
+                for (const auto& [role, dims] : entry_json["tensorShapes"].items()) {
+                    std::vector<int64_t> shape;
+                    for (const auto& d : dims) shape.push_back(d.get<int64_t>());
+                    entry.tensorShapes[role] = std::move(shape);
+                }
+            }
+            if (entry_json.contains("externalDataLocation")) {
+                for (const auto& [role, loc] : entry_json["externalDataLocation"].items())
+                    entry.externalDataLocation[role] = loc.get<std::string>();
+            }
+            if (entry_json.contains("inferenceInitializerNames")) {
+                for (const auto& [role, name] : entry_json["inferenceInitializerNames"].items())
+                    entry.inferenceInitializerNames[role] = name.get<std::string>();
+            }
+            out[entry.trainingBaseLayerName] = entry;
+        }
+        LOGI("Loaded handoff map: %zu entries", out.size());
+        return !out.empty();
+    } catch (const std::exception& e) {
+        LOGE("Error loading handoff map: %s", e.what());
+        out.clear();
+        return false;
+    }
+}
+
+#endif //MOBILETRANSFORMERS_HANDOFF_IO_H
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/inference.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/inference.cpp
similarity index 73%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/inference.cpp
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/inference.cpp
index ee4097e..26ad72c 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/inference.cpp
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/inference.cpp
@@ -109,6 +109,35 @@ namespace inference {
 
         Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
 
+        // The attention mask MUST cover every token the model can attend to: the cached prefix plus the
+        // new tokens in this pass. (`sequence_length` is the mask extent; `past_sequence_length` is the
+        // number of NEW tokens — the parameter names are historical and do not mean what they say.)
+        //
+        // A mask one entry short used to fail deep inside ORT with a message naming neither the mask nor
+        // the cache:
+        //
+        //   "Gather node. Name:'/model/Gather_5' indices element out of data bounds, idx=5 ... [-5,4]"
+        //
+        // That node exists only in graphs exported by transformers >= 4.57 (verified by exporting the
+        // same model under 4.46.2 and 4.57.6 and diffing: `/model/Gather_4` and `/model/Gather_5` are
+        // present only in the newer graph, and they index the FLATTENED attention mask at absolute
+        // positions derived from the cache length). The older graph tolerated a short mask silently,
+        // which means the bookkeeping was already wrong and simply unobserved.
+        //
+        // Checking it here converts "some ONNX node is unhappy" into a statement of the actual
+        // disagreement, which is the difference between a five-minute fix and an export→push→run cycle.
+        const int64_t cached_tokens = session_cache->pastSequenceLength();
+        const int64_t required_mask = cached_tokens + past_sequence_length;
+        if (sequence_length < required_mask) {
+            throw std::runtime_error(
+                    "attention mask is too short for the KV cache: mask covers " +
+                    std::to_string(sequence_length) + " tokens but the cache holds " +
+                    std::to_string(cached_tokens) + " and this pass adds " +
+                    std::to_string(past_sequence_length) + " (need at least " +
+                    std::to_string(required_mask) + "). The caller's idea of the cache length has "
+                    "drifted from the session's — derive the mask from the session, not from a counter.");
+        }
+
         std::vector<const char *> input_names = session_cache->input_names;
         size_t input_count = input_names.size();
 
@@ -155,13 +184,34 @@ namespace inference {
         logTensorMemoryUsage(input_values);
         output_values.emplace_back(nullptr);
 
+        // Fail closed on an input-count mismatch. `Run` is handed `input_count` (the graph's input
+        // count) and reads that many values out of `input_values`; if the KV cache was never
+        // initialized — which happens when the graph carries no `num_layers` metadata — this reads
+        // past the end of the vector and segfaults inside ORT with an unrelated-looking stack. An
+        // exception naming the two counts points straight at the exporter.
+        if (input_values.size() != input_count) {
+            throw std::runtime_error(
+                    "inference input count mismatch: graph expects " + std::to_string(input_count) +
+                    " inputs but " + std::to_string(input_values.size()) + " were bound (" +
+                    std::to_string(session_cache->past_key_values.size()) +
+                    " KV tensors). The graph is missing the num_layers/num_kv_heads/head_dim metadata "
+                    "the KV cache is sized from — re-export the package.");
+        }
+        if (output_values.size() != output_count) {
+            throw std::runtime_error(
+                    "inference output count mismatch: graph declares " + std::to_string(output_count) +
+                    " outputs but " + std::to_string(output_values.size()) + " slots were prepared.");
+        }
+
         auto session_run_opts = Ort::RunOptions();
-        
+
         // Get the logits
         session_cache->inference_session->Run(session_run_opts, input_names.data(), input_values.data(),
                                               input_count, output_names.data(), output_values.data(), output_count);
 
-        std::unique_ptr<Ort::Value> output = std::make_unique<Ort::Value>(std::move(output_values.front()));
+        // Owned by the session, NOT by a local: a local unique_ptr dies at the `return` below and the
+        // returned pointer would dangle. See InferenceSessionCache::last_output.
+        session_cache->last_output = std::make_unique<Ort::Value>(std::move(output_values.front()));
 
         if (!output_values.empty()) {
             output_values.erase(output_values.begin());
@@ -179,7 +229,7 @@ namespace inference {
         input_values.clear();
         output_values.clear();
 
-        return output->GetTensorMutableData<float>();
+        return session_cache->last_output->GetTensorMutableData<float>();
     }
 
     float* generateEmbedding(EmbeddingSessionCache* session_cache,
@@ -235,13 +285,16 @@ namespace inference {
         session_cache->embedding_session->Run(session_run_opts, input_names.data(), input_values.data(),
                                               input_count, output_names.data(), output_values.data(), output_count);
 
-        std::unique_ptr<Ort::Value> output = std::make_unique<Ort::Value>(std::move(output_values.front()));
+        // Hand the tensor to the cache rather than a local: a local is destroyed at the `return`
+        // below, and the pointer we hand back would point into freed memory. See
+        // `EmbeddingSessionCache::last_output` — same defect and same fix as the generation path.
+        session_cache->last_output = std::make_unique<Ort::Value>(std::move(output_values.front()));
 
         // Explicitly release input values to free memory
         input_values.clear();
         output_values.clear();
 
-        return output->GetTensorMutableData<float>();
+        return session_cache->last_output->GetTensorMutableData<float>();
     }
 
 } // namespace inference
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/inference.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/inference.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/inference.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/inference.h
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/layer_name.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/layer_name.h
new file mode 100644
index 0000000..857504c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/layer_name.h
@@ -0,0 +1,153 @@
+#ifndef MOBILETRANSFORMERS_LAYER_NAME_H
+#define MOBILETRANSFORMERS_LAYER_NAME_H
+
+#include <string>
+#include <vector>
+
+/**
+ * @file layer_name.h
+ * ONE definition of how an adapted layer is spelled, for every C++ consumer.
+ *
+ * ## Why this exists
+ *
+ * The same layer carries five different names across this system, and every consumer used to re-derive
+ * the conversion inline:
+ *
+ * | space                    | spelling                                                        |
+ * |--------------------------|-----------------------------------------------------------------|
+ * | inference graph          | `model.layers.0.self_attn.q_proj.MatMul.weight`                  |
+ * | ORT checkpoint           | `backbone.model.layers.0.self_attn.q_proj.base_layer.weight`     |
+ * | `peft_mapping` key (raw) | `base_model.model.model.layers.0.self_attn.q_proj`               |
+ * | handoff-map key          | `base_model.model.model.layers.0.self_attn.q_proj.base_layer`     |
+ * | merger runtime           | `backbone.model.layers.0.self_attn.q_proj`                        |
+ *
+ * Five separate defects were one of these forms being compared against another, each time in a code
+ * path that could only be exercised on a device:
+ *
+ *  - the checkpoint lookup omitted `.base_layer`, so *no* layer's base weight was ever found;
+ *  - `find_handoff_entry` handled the suffix difference but not the prefix one, so all 60 merges wrote
+ *    nothing while reporting success;
+ *  - `peft_mapping_[adjusted]` queried a raw-keyed map with an adjusted name, so `operator[]`
+ *    default-inserted mid-iteration — corrupting the traversal *and* zeroing `alpha`, which made the
+ *    merger compute `weight + 0 * (B @ A)` and emit byte-identical output.
+ *
+ * Each was found by running it, not by reading it, because the conversions were scattered literals with
+ * no single place to be wrong in. Routing every lookup through here is what makes the next one a
+ * compile-time or one-site concern.
+ *
+ * ## Contract
+ *
+ * This is the C++ twin of Python's `artifacts/handoff_map.py::_strip_wrapper_prefixes` +
+ * `candidate_inference_names`, and it deliberately uses the same vocabulary. **If you change the
+ * wrapper set here, change it there too** — they describe one wire format, and `weight_handoff_map.json`
+ * is the artifact they must agree about.
+ *
+ * Pure string transforms: no ORT types, no I/O, so it is unit-testable on the host (see
+ * `cpp_tests/test_layer_name.cpp`).
+ */
+namespace layer_name {
+
+/**
+ * peft's module wrapper, as it appears in `training_config.json`'s `peft_mapping` keys.
+ *
+ * The WRAPPER only — not the model's own first module. This pair used to read
+ * `base_model.model.model.` / `backbone.model.`, i.e. the same rule with a decoder's `model.layers…`
+ * baked in; it is identical for every decoder and matches nothing for an encoder, whose path is
+ * `bert.encoder.layer…`.
+ */
+inline constexpr const char* kRawPrefix = "base_model.model.";
+
+/** ORT's training-graph wrapper, as parameters are named inside the CheckpointState. */
+inline constexpr const char* kCheckpointPrefix = "backbone.";
+
+/** peft wraps the original `Linear` as `base_layer`; the adapters sit beside it. */
+inline constexpr const char* kBaseLayerSuffix = ".base_layer";
+
+/** Replace @p old_prefix with @p new_prefix when present; otherwise return @p name unchanged. */
+inline std::string replace_prefix(const std::string& name,
+                                  const std::string& old_prefix,
+                                  const std::string& new_prefix) {
+    if (name.compare(0, old_prefix.size(), old_prefix) == 0) {
+        return new_prefix + name.substr(old_prefix.size());
+    }
+    return name;
+}
+
+inline bool has_suffix(const std::string& name, const std::string& suffix) {
+    return name.size() >= suffix.size() &&
+           name.compare(name.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+/**
+ * raw (`peft_mapping` key) -> checkpoint/merger space.
+ * `base_model.model.model.layers.9.self_attn.q_proj` -> `backbone.model.layers.9.self_attn.q_proj`
+ * `base_model.model.bert.encoder.layer.9.attention.self.query` ->
+ *     `backbone.bert.encoder.layer.9.attention.self.query`
+ */
+inline std::string to_checkpoint(const std::string& raw_name) {
+    return replace_prefix(raw_name, kRawPrefix, kCheckpointPrefix);
+}
+
+/**
+ * checkpoint/merger space -> raw (`peft_mapping` / handoff-map key) space. Inverse of to_checkpoint.
+ *
+ * Needed because the merge loop works in checkpoint space while `peft_mapping_` and the handoff map are
+ * both keyed raw. Querying one with the other is the single most repeated bug in this file's history.
+ */
+inline std::string to_raw(const std::string& checkpoint_name) {
+    return replace_prefix(checkpoint_name, kCheckpointPrefix, kRawPrefix);
+}
+
+/** Append `.base_layer` unless already present. Idempotent, so it cannot double up. */
+inline std::string with_base_layer(const std::string& name) {
+    return has_suffix(name, kBaseLayerSuffix) ? name : name + kBaseLayerSuffix;
+}
+
+/** Strip a trailing `.base_layer` if present. */
+inline std::string without_base_layer(const std::string& name) {
+    return has_suffix(name, kBaseLayerSuffix)
+               ? name.substr(0, name.size() - std::string(kBaseLayerSuffix).size())
+               : name;
+}
+
+/**
+ * The checkpoint parameter holding a layer's frozen base weight.
+ *
+ * peft keeps the original `Linear` under `.base_layer`, so the weight is
+ * `<layer>.base_layer.weight` — NOT `<layer>.weight`, which matches nothing for any layer and was the
+ * "Missing base weight for LoRA merger" failure.
+ */
+inline std::string checkpoint_weight_param(const std::string& layer, const std::string& role = "weight") {
+    return with_base_layer(layer) + "." + role;
+}
+
+/**
+ * Every key the handoff map might legitimately use for @p layer, in probe order.
+ *
+ * Two independent axes vary — prefix (raw vs checkpoint) and suffix (with vs without `.base_layer`) —
+ * so a lookup that fixes only one of them misses. Returning all four from one place means a caller
+ * cannot handle three of them and forget the fourth, which is exactly what happened.
+ */
+inline std::vector<std::string> candidate_handoff_keys(const std::string& layer) {
+    const std::string raw = to_raw(layer);
+    std::vector<std::string> keys{
+        layer,
+        with_base_layer(layer),
+        raw,
+        with_base_layer(raw),
+    };
+    // De-duplicate while preserving probe order (`layer` may already carry the suffix, or already be raw).
+    std::vector<std::string> unique;
+    for (const auto& k : keys) {
+        bool seen = false;
+        for (const auto& u : unique) {
+            if (u == k) { seen = true; break; }
+        }
+        if (!seen) unique.push_back(k);
+    }
+    return unique;
+}
+
+}  // namespace layer_name
+
+#endif  // MOBILETRANSFORMERS_LAYER_NAME_H
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/logging.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/logging.h
similarity index 76%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/logging.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/logging.h
index 57284a1..2d8cfdb 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/logging.h
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/logging.h
@@ -2,12 +2,12 @@
 // Created by martinkorelic on 20. 07. 25.
 //
 
-#ifndef ORTTRANSFORMER_LOGGING_H
-#define ORTTRANSFORMER_LOGGING_H
+#ifndef MOBILETRANSFORMERS_LOGGING_H
+#define MOBILETRANSFORMERS_LOGGING_H
 
 #include <android/log.h>
 
-#define LOG_TAG "ORTransformersMobile"
+#define LOG_TAG "MobileTransformers"
 
 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
@@ -15,4 +15,4 @@
 #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
 #define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
 
-#endif //ORTTRANSFORMER_LOGGING_H
+#endif //MOBILETRANSFORMERS_LOGGING_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/logits_metrics.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/logits_metrics.h
new file mode 100644
index 0000000..a20984f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/logits_metrics.h
@@ -0,0 +1,162 @@
+#ifndef MOBILETRANSFORMERS_LOGITS_METRICS_H
+#define MOBILETRANSFORMERS_LOGITS_METRICS_H
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+/**
+ * @file logits_metrics.h
+ * Numbers read off an inference forward pass, so the device can assert what the host already asserts.
+ *
+ * ## Why this exists
+ *
+ * The export pipeline gates a package on `artifacts/train_inference_parity.py` — the same tokens through
+ * the train and inference graphs, one cross-entropy each, one bounded delta. **Nothing did that after an
+ * on-device merge.** `TrainMergeGenerateTest` hashes the trainable `.bin` files and says so in its own
+ * comment: proving the bytes changed is not proving the numbers are right. A merge that wrote plausible
+ * bytes to the correct filenames and corrupted the values would pass every gate this project had.
+ *
+ * That is the recurring failure shape: two halves each verified alone (the bytes moved; the loss falls),
+ * with the seam between them — do the merged weights actually compute the right thing? — unverified.
+ *
+ * ## What is here
+ *
+ * `causal_cross_entropy` is a **deliberate mirror** of the host's `causal_cross_entropy`, down to the
+ * shift convention: `logits[:, :-1]` against `input_ids[:, 1:]`. The host docstring records why that
+ * matters — pre-shifting once already inflated every printed loss, and a device number computed under a
+ * different convention is not comparable to a host number, which defeats the point of measuring it.
+ *
+ * Accumulation is `double` for the same reason the host casts to float64: a broken graph emits logits in
+ * the 1e8 range, and the stable-log-softmax subtraction loses precision at those magnitudes in float32.
+ *
+ * ## Why it is ORT-free
+ *
+ * Same reason as `layer_name.h`, `handoff_io.h`, `training_inputs.h` and `constants/merger_variant.h`:
+ * the decision is host-testable, so it is pinned by googletest rather than only by a phone. Every one of
+ * those headers exists because a defect in exactly this kind of pure logic survived to a device run.
+ */
+namespace logits_metrics {
+
+    /**
+     * A stable reduction of one logits row, used to answer "did the numbers move?".
+     *
+     * Four independent statistics rather than one: a merge that shifts every logit by a constant leaves
+     * `argmax` untouched, and a merge that permutes values leaves `sum` untouched. Together they do not
+     * have a plausible common blind spot.
+     */
+    struct Fingerprint {
+        //: Index of the largest logit — the token greedy decoding would emit.
+        int64_t argmax = -1;
+        //: The largest logit value itself.
+        double max_logit = 0.0;
+        //: Sum over the vocabulary. Order-dependent in principle, but the order is fixed.
+        double sum = 0.0;
+        //: Sum of squares — moves when values are redistributed without changing the sum.
+        double sum_of_squares = 0.0;
+    };
+
+    /**
+     * Reduces the logits of the LAST position, which is the row generation actually samples from.
+     *
+     * @param logits           `[batch, seq, vocab]`, contiguous, as `generateWithKVCache` returns it.
+     * @param sequence_length  number of positions in this pass.
+     * @param vocab_size       vocabulary width.
+     * @throws std::invalid_argument on a non-positive dimension or a null pointer — a caller that has
+     *   lost track of the shape must fail here rather than read past the buffer, which is the failure
+     *   mode `generateWithKVCache`'s own input-count guard was added for.
+     */
+    inline Fingerprint fingerprint_last_position(const float *logits,
+                                                 int64_t sequence_length,
+                                                 int64_t vocab_size) {
+        if (logits == nullptr) {
+            throw std::invalid_argument("logits fingerprint: null logits pointer");
+        }
+        if (sequence_length <= 0 || vocab_size <= 0) {
+            throw std::invalid_argument(
+                    "logits fingerprint: non-positive dimension (sequence_length=" +
+                    std::to_string(sequence_length) + ", vocab_size=" + std::to_string(vocab_size) + ")");
+        }
+
+        const float *row = logits + (sequence_length - 1) * vocab_size;
+
+        Fingerprint fp;
+        fp.max_logit = -std::numeric_limits<double>::infinity();
+        for (int64_t v = 0; v < vocab_size; ++v) {
+            const double value = static_cast<double>(row[v]);
+            fp.sum += value;
+            fp.sum_of_squares += value * value;
+            if (value > fp.max_logit) {
+                fp.max_logit = value;
+                fp.argmax = v;
+            }
+        }
+        return fp;
+    }
+
+    /**
+     * Mean next-token cross-entropy in nats, under the SAME causal shift as the host gate.
+     *
+     * Position `t` of the logits predicts token `t+1` of the input, so the last position has no target
+     * and is dropped — exactly `logits[:, :-1]` vs `input_ids[:, 1:]`.
+     *
+     * @param logits           `[1, sequence_length, vocab_size]`, contiguous. Batch is 1 on device.
+     * @param input_ids        the `sequence_length` token ids that produced those logits.
+     * @param sequence_length  must be >= 2, or there is no (prediction, target) pair to score.
+     * @param vocab_size       vocabulary width.
+     * @throws std::invalid_argument on a null pointer, `sequence_length < 2`, or a target id outside
+     *   the vocabulary. The last one is worth failing on rather than clamping: an out-of-range target
+     *   means the tokenizer and the graph disagree about the vocabulary, which is a real package defect
+     *   and silently scoring it would report a plausible-looking loss for a broken pairing.
+     */
+    inline double causal_cross_entropy(const float *logits,
+                                       const int64_t *input_ids,
+                                       int64_t sequence_length,
+                                       int64_t vocab_size) {
+        if (logits == nullptr || input_ids == nullptr) {
+            throw std::invalid_argument("causal cross-entropy: null pointer");
+        }
+        if (vocab_size <= 0) {
+            throw std::invalid_argument("causal cross-entropy: non-positive vocab_size");
+        }
+        if (sequence_length < 2) {
+            throw std::invalid_argument(
+                    "causal cross-entropy needs at least 2 positions to form one (prediction, target) "
+                    "pair, got sequence_length=" + std::to_string(sequence_length));
+        }
+
+        double total = 0.0;
+        for (int64_t t = 0; t + 1 < sequence_length; ++t) {
+            const float *row = logits + t * vocab_size;
+            const int64_t target = input_ids[t + 1];
+            if (target < 0 || target >= vocab_size) {
+                throw std::invalid_argument(
+                        "causal cross-entropy: target token id " + std::to_string(target) +
+                        " at position " + std::to_string(t + 1) + " is outside the vocabulary [0, " +
+                        std::to_string(vocab_size) + ") — the tokenizer and the graph disagree.");
+            }
+
+            // Stable log-softmax: subtract the row max before exponentiating, in double.
+            double row_max = -std::numeric_limits<double>::infinity();
+            for (int64_t v = 0; v < vocab_size; ++v) {
+                const double value = static_cast<double>(row[v]);
+                if (value > row_max) {
+                    row_max = value;
+                }
+            }
+            double sum_exp = 0.0;
+            for (int64_t v = 0; v < vocab_size; ++v) {
+                sum_exp += std::exp(static_cast<double>(row[v]) - row_max);
+            }
+            const double target_log_prob =
+                    (static_cast<double>(row[target]) - row_max) - std::log(sum_exp);
+            total += -target_log_prob;
+        }
+        return total / static_cast<double>(sequence_length - 1);
+    }
+
+} // namespace logits_metrics
+
+#endif //MOBILETRANSFORMERS_LOGITS_METRICS_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/mem_probe.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/mem_probe.h
new file mode 100644
index 0000000..f9f2a30
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/mem_probe.h
@@ -0,0 +1,81 @@
+//
+// #12: process RSS probe for the memory-mapping experiments (Gate 0.2). Mirrors the Python sampler
+// spikes/genai_external_swap/measure_rss.py (VmRSS from /proc/self/status). Header-only, no deps.
+//
+
+#ifndef MOBILETRANSFORMERS_MEM_PROBE_H
+#define MOBILETRANSFORMERS_MEM_PROBE_H
+
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <fstream>
+#ifdef __ANDROID__
+#include <sys/system_properties.h>
+#endif
+#include "logging.h"
+
+namespace memprobe {
+
+// Resident set size in KiB from /proc/self/status (VmRSS). Returns -1 if unavailable.
+inline int64_t read_rss_kb() {
+    std::ifstream status("/proc/self/status");
+    if (!status.is_open()) return -1;
+    std::string key;
+    while (status >> key) {
+        if (key == "VmRSS:") {
+            int64_t value = -1;
+            status >> value;  // value is in kB
+            return value;
+        }
+        std::string rest;
+        std::getline(status, rest);
+    }
+    return -1;
+}
+
+// Parse VmRSS (kB) out of a /proc/self/status-shaped string. Unit-testable without /proc.
+inline int64_t parse_vmrss_kb(const std::string& status_text) {
+    const std::string needle = "VmRSS:";
+    auto pos = status_text.find(needle);
+    if (pos == std::string::npos) return -1;
+    pos += needle.size();
+    // skip spaces
+    while (pos < status_text.size() && (status_text[pos] == ' ' || status_text[pos] == '\t')) ++pos;
+    int64_t value = 0;
+    bool any = false;
+    while (pos < status_text.size() && status_text[pos] >= '0' && status_text[pos] <= '9') {
+        value = value * 10 + (status_text[pos] - '0');
+        any = true;
+        ++pos;
+    }
+    return any ? value : -1;
+}
+
+// #12 (Gate 0.2) toggle for the zero-copy weight load. Default OFF — the shipping path is #23's copy.
+//
+// An instrumented test cannot set an environment variable in the app process it is measuring, so the
+// four-point RSS table (base/merged x copy/mmap) was unreachable while this was env-only. The switch is
+// therefore also a system property:
+//
+//     adb shell setprop debug.mtf.mmap_weights 1
+//
+// The env var stays as the desktop/spike override and still wins, so existing spike scripts are
+// unaffected. Reads the property on every call: the test flips it between session constructions.
+inline bool mmap_weights_enabled() {
+    if (std::getenv("MTF_MMAP_WEIGHTS") != nullptr) return true;
+#ifdef __ANDROID__
+    char value[PROP_VALUE_MAX] = {0};
+    if (__system_property_get("debug.mtf.mmap_weights", value) > 0) {
+        return value[0] == '1' || value[0] == 't' || value[0] == 'T' || value[0] == 'y' || value[0] == 'Y';
+    }
+#endif
+    return false;
+}
+
+}  // namespace memprobe
+
+#define LOG_RSS(tag) LOGI("[rss] %s: %lld kB", (tag), (long long) memprobe::read_rss_kb())
+
+#endif  // MOBILETRANSFORMERS_MEM_PROBE_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/mmap_tensor.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/mmap_tensor.h
new file mode 100644
index 0000000..66d40fc
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/mmap_tensor.h
@@ -0,0 +1,84 @@
+//
+// #12: RAII memory-mapped file region for zero-copy external-initializer loading (Gate 0.2 experiment).
+// Owned by the weight cache and unmapped in its destructor — NOT eagerly freed (the mapped bytes must
+// outlive any Ort::Value that points into them). Default-off; the copy path stays the shipping default.
+//
+
+#ifndef MOBILETRANSFORMERS_MMAP_TENSOR_H
+#define MOBILETRANSFORMERS_MMAP_TENSOR_H
+
+#include <cstddef>
+#include <string>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "logging.h"
+
+// A single mmap'd file. Move-only; unmaps on destruction.
+class MmapRegion {
+public:
+    MmapRegion() = default;
+
+    // Map the whole file read-only/private. On failure, data() == nullptr and size() == 0.
+    explicit MmapRegion(const std::string& path) {
+        int fd = ::open(path.c_str(), O_RDONLY);
+        if (fd < 0) {
+            LOGE("mmap: open failed for %s", path.c_str());
+            return;
+        }
+        struct stat st{};
+        if (::fstat(fd, &st) != 0 || st.st_size <= 0) {
+            ::close(fd);
+            LOGE("mmap: fstat failed / empty for %s", path.c_str());
+            return;
+        }
+        size_ = static_cast<size_t>(st.st_size);
+        void* p = ::mmap(nullptr, size_, PROT_READ, MAP_PRIVATE, fd, 0);
+        ::close(fd);  // the mapping keeps its own reference; fd can close.
+        if (p == MAP_FAILED) {
+            data_ = nullptr;
+            size_ = 0;
+            LOGE("mmap: mmap failed for %s", path.c_str());
+            return;
+        }
+        data_ = p;
+    }
+
+    ~MmapRegion() { reset(); }
+
+    MmapRegion(MmapRegion&& other) noexcept : data_(other.data_), size_(other.size_) {
+        other.data_ = nullptr;
+        other.size_ = 0;
+    }
+    MmapRegion& operator=(MmapRegion&& other) noexcept {
+        if (this != &other) {
+            reset();
+            data_ = other.data_;
+            size_ = other.size_;
+            other.data_ = nullptr;
+            other.size_ = 0;
+        }
+        return *this;
+    }
+    MmapRegion(const MmapRegion&) = delete;
+    MmapRegion& operator=(const MmapRegion&) = delete;
+
+    bool valid() const { return data_ != nullptr && size_ > 0; }
+    const void* data() const { return data_; }
+    size_t size() const { return size_; }
+
+private:
+    void reset() {
+        if (data_ != nullptr) {
+            ::munmap(data_, size_);
+            data_ = nullptr;
+            size_ = 0;
+        }
+    }
+
+    void* data_ = nullptr;
+    size_t size_ = 0;
+};
+
+#endif  // MOBILETRANSFORMERS_MMAP_TENSOR_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/native-lib.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/native-lib.cpp
new file mode 100644
index 0000000..c8d6b2b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/native-lib.cpp
@@ -0,0 +1,991 @@
+//
+// Created by martinkorelic on 31/08/2024
+//
+
+#include <jni.h>
+#include <string>
+#include "onnxruntime/onnxruntime_training_cxx_api.h"
+#include "inference.h"
+#include "tokenization.h"
+#include "train.h"
+#include "utils.h"
+#include "sampling.h"
+#include "mem_probe.h"
+#include "logits_metrics.h"
+#include <android/log.h>
+
+#define LOG_TAG "MobileTransformers"
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_martinkorelic_mobiletransformers_app_MainActivity_stringFromJNI(
+        JNIEnv* env,
+        jobject /* this */) {
+    std::string hello = "Hello from C++";
+    return env->NewStringUTF(hello.c_str());
+}
+
+// #12 (Gate 0.2): expose the native RSS sampler so an instrumented test can build the four-point
+// base/merged x copy/mmap table. Debug.getPss() would measure the JVM's view; the weights are mapped
+// by native code, so VmRSS from /proc/self/status is the number the gate is specified against.
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_martinkorelic_mobiletransformers_runtime_MemoryProbe_nativeCurrentRssKb(
+        JNIEnv* /* env */,
+        jobject /* this */) {
+    return static_cast<jlong>(memprobe::read_rss_kb());
+}
+
+// Whether the zero-copy weight load is currently switched on (env var or `debug.mtf.mmap_weights`).
+// The RSS harness asserts it actually flipped rather than trusting setprop to have taken effect.
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_martinkorelic_mobiletransformers_runtime_MemoryProbe_nativeMmapWeightsEnabled(
+        JNIEnv* /* env */,
+        jobject /* this */) {
+    return memprobe::mmap_weights_enabled() ? JNI_TRUE : JNI_FALSE;
+}
+
+void ReleaseTrainingSession(jlong session, jboolean saveCheckpoint) {
+    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    if (saveCheckpoint) {
+        // Include optimizer state?
+        Ort::CheckpointState::SaveCheckpoint(session_cache->checkpoint_state, session_cache->artifact_paths.checkpoint_path, true);
+    }
+
+    delete session_cache;
+    session_cache = nullptr;
+}
+
+void ReleaseWeightSession(jlong session) {
+    auto *session_cache = reinterpret_cast<WeightSessionCache *>(session);
+
+    delete session_cache;
+    session_cache = nullptr;
+}
+
+void ReleaseTokenizerSession(jlong session) {
+    auto *session_cache = reinterpret_cast<TokenizerSessionCache *>(session);
+
+    delete session_cache;
+    session_cache = nullptr;
+}
+
+extern "C"
+JNIEXPORT float JNICALL
+/**
+ * Performs the training step with the gradient update and optimizer step.
+ *
+ * Inputs are bound BY NAME inside `training::train_step`, from the names the training graph itself
+ * declares — so the same entry point serves a decoder (which asks for `position_ids`) and an encoder
+ * classifier (which asks for `token_type_ids` and per-sequence `labels`). `position_ids` and
+ * `token_type_ids` are synthesized there, and only if the graph asks for them.
+ *
+ * The label RANK is derived from how many label elements the caller actually supplied, which is why
+ * the array length is read here and passed down.
+ *
+ * @param env
+ * @param session
+ * @param input_ids
+ * @param batch_size
+ * @param sequence_length
+ *
+ * @return Loss value
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_performTraining(
+        JNIEnv *env, jobject /* this */,
+        jlong session,
+        jlongArray input_ids, jlongArray labels, jlongArray attention_mask, jint batch_size, jint sequence_length) {
+    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    // Get the input_ids array from the Java environment
+    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
+    jlong* label_elements = env->GetLongArrayElements(labels, nullptr);
+    jlong* attention_elements = env->GetLongArrayElements(attention_mask, nullptr);
+
+    // What the caller actually supplied — the ground truth for the label rank, rather than a
+    // declared constant that can drift away from the data.
+    const jsize labels_count = env->GetArrayLength(labels);
+
+    float loss = 0.0f;
+    std::string error;
+    try {
+        // Update the model parameters using this batch of inputs.
+        loss = training::train_step(session_cache, input_ids_elements, attention_elements,
+                                    label_elements, batch_size, sequence_length, labels_count);
+    } catch (const std::exception& e) {
+        error = e.what();
+    }
+
+    env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
+    env->ReleaseLongArrayElements(labels, label_elements, JNI_ABORT);
+    env->ReleaseLongArrayElements(attention_mask, attention_elements, JNI_ABORT);
+
+    if (!error.empty()) {
+        // A C++ exception crossing JNI calls std::terminate and kills the WHOLE instrumentation run,
+        // so later tests never report. Convert it, after releasing the arrays.
+        jclass runtime_exception = env->FindClass("java/lang/RuntimeException");
+        if (runtime_exception != nullptr) {
+            env->ThrowNew(runtime_exception, (std::string("training step failed: ") + error).c_str());
+        }
+        return 0.0f;
+    }
+
+    return loss;
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+/**
+ * Creates the training session from the given artifact paths.
+ *
+ * @param env
+ * @param thiz
+ * @param checkpoint_path
+ * @param train_model_path
+ * @param eval_model_path
+ * @param optimizer_model_path
+ * @param cache_dir_path
+ * @param requires_grad
+ *
+ * @return Training session native model handle.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_createTrainingSession(JNIEnv *env, jobject thiz,
+                                                           jstring checkpoint_path,
+                                                           jstring train_model_path,
+                                                           jstring eval_model_path,
+                                                           jstring optimizer_model_path,
+                                                           jstring cache_dir_path,
+                                                           jobjectArray requires_grad,
+                                                           jstring memory_config_id,
+                                                           jstring core_config_id,
+                                                           jstring execution_provider,
+                                                           jboolean enable_profiling) {
+
+    // Get the size of the input array
+    jsize arrayLength = env->GetArrayLength(requires_grad);
+
+    std::unique_ptr<TrainingSessionCache> session_cache = std::make_unique<TrainingSessionCache>(
+            utils::JString2String(env, checkpoint_path),
+            utils::JString2String(env, train_model_path),
+            utils::JString2String(env, eval_model_path),
+            utils::JString2String(env, optimizer_model_path),
+            utils::JString2String(env, cache_dir_path),
+            utils::JString2String(env, memory_config_id),
+            utils::JString2String(env, core_config_id),
+            utils::JString2String(env, execution_provider),
+            enable_profiling);
+
+    for (jsize i = 0; i < arrayLength; ++i) {
+        auto jstr = (jstring) (env->GetObjectArrayElement(requires_grad, i));
+        const char *cstr = env->GetStringUTFChars(jstr, nullptr);
+        session_cache->requires_grad.emplace_back(cstr);
+
+        // Release the string
+        env->ReleaseStringUTFChars(jstr, cstr);
+        env->DeleteLocalRef(jstr);
+    }
+
+    return reinterpret_cast<long>(session_cache.release());
+}
+
+
+
+extern "C" JNIEXPORT jlong JNICALL
+/**
+ * Creates normal inference session from the given inference model path.
+ * This inference is a custom made inference which is ready to be used for generation with KV caching.
+ *
+ * If load_merged_weights is enabled:
+ * 1. Transfer the weights to the inference session options with the weights from the weights that were merged and saved.
+ * 2. Load the inference model
+ * 3. The model is ready for inference with the merged weights.
+ *
+ * @param env
+ * @param inference_model_path
+ * @param inference_model_name
+ * @param load_merged_weights - Whether to load merged weights as flat per-tensor external initializers
+ *        from ".../inference/" keyed by weight_handoff_map.json (#23; the /merged subdir is retired)
+ * @return
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_createInferenceSession(
+        JNIEnv *env, jobject /* this */,
+        jstring inference_model_path,
+        jstring inference_model_name,
+        jstring cache_dir_path,
+        jboolean load_merged_weights,
+        jstring core_config_id,
+        jstring memory_config_id,
+        jstring execution_provider,
+        jboolean enable_profiling
+        ) {
+
+    // #23: session construction FAILS CLOSED when merged weights were requested but could not be
+    // loaded (missing/mis-shaped tensor, or ORT rejecting the external initializers). Returning 0
+    // rather than a session built from the frozen base weights is the whole point — a silent downgrade
+    // yields an untrained model that looks healthy. Kotlin turns the 0 into MissingArtifactException.
+    // A C++ exception must not cross the JNI boundary, so it is converted here.
+    try {
+        std::unique_ptr<InferenceSessionCache> session_cache = std::make_unique<InferenceSessionCache>(
+                utils::JString2String(env, inference_model_path),
+                utils::JString2String(env, inference_model_name),
+                utils::JString2String(env, cache_dir_path),
+                utils::JString2String(env, memory_config_id),
+                utils::JString2String(env, core_config_id),
+                utils::JString2String(env, execution_provider),
+                load_merged_weights,
+                enable_profiling);
+
+        session_cache->initializeKVCache(1);
+
+        return reinterpret_cast<long>(session_cache.release());
+    } catch (const std::exception& e) {
+        LOGE("createInferenceSession failed: %s", e.what());
+        return 0;
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL
+/**
+ * Deletes the current inference session.
+ *
+ * @param env
+ * @param session
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_releaseInferenceSession(
+        JNIEnv *env, jobject /* this */,
+        jlong session) {
+    // A 0 handle means the session was never created — `createInferenceSession` returns 0 on failure,
+    // and `destroySession()` is still reached through the normal `finally`/`release()` path. Without
+    // this guard that path dereferenced a null pointer (`SIGSEGV`, fault addr 0x8 — the offset of
+    // `inference_session`), which kills the ENTIRE instrumentation run rather than failing one test.
+    // That is the same class of hazard as the C++ exception that used to cross JNI and call
+    // std::terminate: a recoverable error taking the process with it.
+    if (session == 0) {
+        return;
+    }
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+
+    delete session_cache->inference_session;
+    delete session_cache;
+    session_cache = nullptr;
+}
+
+extern "C"
+JNIEXPORT jdoubleArray JNICALL
+/**
+ * One forward pass, reduced to numbers a test can assert on. A PROBE: it leaves no state behind.
+ *
+ * Exists because nothing checked post-merge numerical correctness on device. The export pipeline gates
+ * a package on `train_inference_parity.py` (same tokens, both graphs, one bounded delta), but the
+ * device only ever hashed the merged `.bin` files — `TrainMergeGenerateTest` says so itself, and a
+ * merge that wrote plausible bytes with corrupted values passed every gate the project had.
+ *
+ * `performInferenceStep` cannot serve this: it samples internally and returns only a token id, so the
+ * logits never reach Kotlin. Rather than marshal a vocab-sized float array across JNI on every call,
+ * this returns the reduction.
+ *
+ * @return `[argmax, maxLogit, sum, sumOfSquares, causalCrossEntropyNats]` for a single prefill pass.
+ *   The cross-entropy uses the SAME causal shift as the host gate, so the two numbers are comparable;
+ *   computing it under a different convention would make the measurement decorative.
+ *
+ * The KV cache is reset afterwards because `generateWithKVCache` updates it — a measurement that
+ * silently advanced the conversation would corrupt whatever ran next, which is exactly the
+ * package-mutation hazard the device suite already has to work around.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_nativeInferenceMetrics(
+        JNIEnv *env, jobject /* this */,
+        jlong session,
+        jlongArray input_ids,
+        jlongArray attention_mask,
+        jlongArray position_ids,
+        jint batch_size,
+        jint sequence_length,
+        jint new_token_count,
+        jint vocab_size) {
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+
+    jlong *input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
+    jlong *attention_mask_elements = env->GetLongArrayElements(attention_mask, nullptr);
+    jlong *position_ids_elements = env->GetLongArrayElements(position_ids, nullptr);
+
+    auto release = [&]() {
+        env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(attention_mask, attention_mask_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(position_ids, position_ids_elements, JNI_ABORT);
+    };
+
+    try {
+        float *logits = inference::generateWithKVCache(session_cache,
+                                                       input_ids_elements,
+                                                       attention_mask_elements,
+                                                       position_ids_elements,
+                                                       batch_size,
+                                                       sequence_length,
+                                                       new_token_count);
+
+        // Same clamp as performInferenceStep, and for the same reason: these two also stride by
+        // vocab_size to find the row. A measurement taken over the wrong stride is not a measurement.
+        const int metric_vocab_size =
+                sampling::effectiveVocabSize(vocab_size, session_cache->lastLogitsWidth());
+
+        const auto fp = logits_metrics::fingerprint_last_position(logits, new_token_count, metric_vocab_size);
+        const double loss = logits_metrics::causal_cross_entropy(
+                logits, input_ids_elements, new_token_count, metric_vocab_size);
+
+        // A probe must not advance the conversation.
+        session_cache->initializeKVCache(batch_size);
+
+        release();
+
+        jdouble values[5] = {
+                static_cast<jdouble>(fp.argmax),
+                fp.max_logit,
+                fp.sum,
+                fp.sum_of_squares,
+                loss,
+        };
+        jdoubleArray out = env->NewDoubleArray(5);
+        if (out != nullptr) {
+            env->SetDoubleArrayRegion(out, 0, 5, values);
+        }
+        return out;
+    } catch (const std::exception &e) {
+        release();
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "nativeInferenceMetrics failed: %s", e.what());
+        jclass runtime_exception = env->FindClass("java/lang/RuntimeException");
+        if (runtime_exception != nullptr) {
+            env->ThrowNew(runtime_exception,
+                          (std::string("inference metrics failed: ") + e.what()).c_str());
+        }
+        return nullptr;
+    }
+}
+
+extern "C"
+JNIEXPORT jint JNICALL
+/**
+ * How many tokens the session's KV cache actually holds.
+ *
+ * The session is the single authority on this. Kotlin previously kept its own counter
+ * (`pastAttentionMaskLength = attentionMask.size - 1`) and built the next turn's attention mask from
+ * it; the two could drift, and a mask shorter than `cache + new` fails inside ORT on a transformers
+ * >= 4.57 graph with a message naming neither. Reading it back removes the second source of truth.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_nativePastSequenceLength(
+        JNIEnv *env, jobject /* this */,
+        jlong session) {
+    if (session == 0) {
+        return 0;
+    }
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+    return static_cast<jint>(session_cache->pastSequenceLength());
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+/**
+ * Drops the KV cache back to an empty (zero-length past) state for a new conversation.
+ *
+ * Re-initialises rather than merely clearing: `generateWithKVCache` binds one value per graph input,
+ * so an EMPTY `past_key_values` vector would under-bind and read past the end. `initializeKVCache`
+ * recreates the zero-length tensors a `*-with-past` graph expects on a first pass.
+ *
+ * Before this existed, `resetConversation()` reset only Kotlin's counter and history — the native
+ * cache survived, so "reset" left the two halves disagreeing about how many tokens were cached.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_nativeResetKvCache(
+        JNIEnv *env, jobject /* this */,
+        jlong session) {
+    if (session == 0) {
+        return;
+    }
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+    try {
+        session_cache->initializeKVCache(1);
+    } catch (const std::exception &e) {
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "nativeResetKvCache failed: %s", e.what());
+        jclass runtime_exception = env->FindClass("java/lang/RuntimeException");
+        if (runtime_exception != nullptr) {
+            env->ThrowNew(runtime_exception, (std::string("kv cache reset failed: ") + e.what()).c_str());
+        }
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_releaseTrainingSession(
+        JNIEnv *env, jobject,
+        jlong session, jboolean saveCheckpoint) {
+    ReleaseTrainingSession(session, saveCheckpoint);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+/**
+ * Utility function, example of inspecting weights in the model from the checkpoint state.
+ * */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_inspectWeights(JNIEnv *env, jobject thiz,
+                                                            jlong session, jstring layer) {
+    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    Ort::Value parameter = session_cache->checkpoint_state.GetParameter(utils::JString2String(env, layer));
+
+    auto type_info = parameter.GetTypeInfo();
+    auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
+
+    // Get tensor dimensions
+    std::vector<int64_t> dimensions = tensor_info.GetShape();
+    // Get the data type
+    ONNXTensorElementDataType dtype = tensor_info.GetElementType();
+
+    __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Type: type=%u", dtype);
+    for (auto dim: dimensions) {
+        __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Dimension: type=%ld", dim);
+    }
+}
+
+
+extern "C"
+JNIEXPORT jbyteArray JNICALL
+/**
+ * Raw little-endian bytes of ONE checkpoint parameter, or null when the checkpoint has no such name.
+ *
+ * ## Why this, and not `exportTrainableTensors(session, handoffMapPath) -> ByteArray`
+ *
+ * The federated plan names that wider signature — the whole record built in C++. This deliberately
+ * does less, for one reason: the record's byte layout is **already owned** by
+ * `federated/AdapterTensorCodec.kt`, which is pinned byte-for-byte against
+ * `tests/federated/fixtures/federated_record.golden.bin`. Building the record here would be a SECOND
+ * implementation of the exact format that golden exists to keep from drifting, and it would need
+ * `handoff_io.h` extended to model the adapter fields plus a JSON writer reproducing Python's
+ * `sort_keys` separators. Two implementations of one wire format is the failure this project keeps
+ * paying for.
+ *
+ * So C++ moves tensor bytes and Kotlin owns the format: `AdapterTensorCodec.build(payloadFor = ...)`
+ * composes them, and the order/naming/dtype all still come from `weight_handoff_map.json`.
+ *
+ * Returns **null** rather than throwing on a missing name: the caller (the codec) already fails closed
+ * with a message naming the tensor and explaining that the package and checkpoint disagree, and that
+ * message is better than one from here.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_nativeExportCheckpointTensor(
+        JNIEnv *env, jobject /* this */,
+        jlong session, jstring name) {
+    if (session == 0) {
+        return nullptr;
+    }
+    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+    const std::string parameter_name = utils::JString2String(env, name);
+
+    try {
+        Ort::Value parameter = session_cache->checkpoint_state.GetParameter(parameter_name);
+        auto tensor_info = parameter.GetTypeInfo().GetTensorTypeAndShapeInfo();
+
+        const size_t element_count = tensor_info.GetElementCount();
+        const ONNXTensorElementDataType dtype = tensor_info.GetElementType();
+        size_t element_size;
+        switch (dtype) {
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT:   element_size = 4; break;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16: element_size = 2; break;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_DOUBLE:  element_size = 8; break;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:   element_size = 4; break;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8:
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8:   element_size = 1; break;
+            default:
+                // An unsupported dtype must not be silently re-interpreted as bytes — the receiver
+                // would decode a plausible-looking tensor of the wrong type.
+                __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
+                                    "nativeExportCheckpointTensor: '%s' has unsupported dtype %u",
+                                    parameter_name.c_str(), dtype);
+                return nullptr;
+        }
+
+        const size_t byte_length = element_count * element_size;
+        jbyteArray out = env->NewByteArray(static_cast<jsize>(byte_length));
+        if (out == nullptr) {
+            return nullptr;
+        }
+        env->SetByteArrayRegion(out, 0, static_cast<jsize>(byte_length),
+                                reinterpret_cast<const jbyte *>(parameter.GetTensorRawData()));
+        return out;
+    } catch (const std::exception &e) {
+        __android_log_print(ANDROID_LOG_WARN, LOG_TAG,
+                            "nativeExportCheckpointTensor('%s'): %s", parameter_name.c_str(), e.what());
+        return nullptr;
+    }
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+/**
+ * Writes raw little-endian bytes back into ONE checkpoint parameter.
+ *
+ * The import half of the federated round: the aggregated factors arrive as a record, the Kotlin codec
+ * decodes it, and each tensor is written back **by name**. Matching by name rather than by iteration
+ * order is not a preference — the Python simulation had exactly that defect, pairing tensors by
+ * checkpoint iteration order, which would write one layer's `lora_A` over another's and was caught
+ * only "mostly", by differing shapes.
+ *
+ * Fails (returns false) rather than truncating or padding when the incoming byte count does not match
+ * the parameter's own element count and dtype: a size mismatch means the sender and this checkpoint
+ * disagree about the adapter geometry, and writing anyway would corrupt training silently.
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_nativeImportCheckpointTensor(
+        JNIEnv *env, jobject /* this */,
+        jlong session, jstring name, jbyteArray data) {
+    if (session == 0 || data == nullptr) {
+        return JNI_FALSE;
+    }
+    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+    const std::string parameter_name = utils::JString2String(env, name);
+
+    try {
+        // Read the EXISTING parameter to learn the shape and dtype the checkpoint expects. The record
+        // carries a declared shape too, but the checkpoint is the authority on its own storage, and
+        // trusting the sender's description would let a malformed record reshape local state.
+        Ort::Value existing = session_cache->checkpoint_state.GetParameter(parameter_name);
+        auto tensor_info = existing.GetTypeInfo().GetTensorTypeAndShapeInfo();
+        const std::vector<int64_t> shape = tensor_info.GetShape();
+        const size_t element_count = tensor_info.GetElementCount();
+        const ONNXTensorElementDataType dtype = tensor_info.GetElementType();
+
+        if (dtype != ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT) {
+            // Adapter factors are float32 by construction: the trainable-tensor gate guarantees a
+            // declared-trainable tensor is never quantized, so anything else here is a real mismatch.
+            __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
+                                "nativeImportCheckpointTensor: '%s' is dtype %u, expected float32",
+                                parameter_name.c_str(), dtype);
+            return JNI_FALSE;
+        }
+
+        const jsize incoming = env->GetArrayLength(data);
+        const size_t expected = element_count * sizeof(float);
+        if (static_cast<size_t>(incoming) != expected) {
+            __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
+                                "nativeImportCheckpointTensor: '%s' got %d bytes, checkpoint needs %zu",
+                                parameter_name.c_str(), incoming, expected);
+            return JNI_FALSE;
+        }
+
+        std::vector<float> values(element_count);
+        env->GetByteArrayRegion(data, 0, incoming, reinterpret_cast<jbyte *>(values.data()));
+
+        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+        Ort::Value updated = Ort::Value::CreateTensor<float>(
+                memory_info, values.data(), element_count, shape.data(), shape.size());
+        session_cache->checkpoint_state.UpdateParameter(parameter_name, updated);
+        return JNI_TRUE;
+    } catch (const std::exception &e) {
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
+                            "nativeImportCheckpointTensor('%s'): %s", parameter_name.c_str(), e.what());
+        return JNI_FALSE;
+    }
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+/**
+ * Export model for inference from the training session.
+ *
+ * @param env
+ * @param thiz
+ * @param session - Current training session native model handle
+ * @return
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_exportModelForInference(JNIEnv *env, jobject thiz,
+                                                                   jlong session) {
+    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+    session_cache->training_session.ExportModelForInferencing(session_cache->artifact_paths.inference_model_path, {"logits"});
+    return env->NewStringUTF(session_cache->artifact_paths.inference_model_path.c_str());
+}
+
+
+extern "C"
+JNIEXPORT jint JNICALL
+/**
+ * Performs the inference step using the exported model for inference.
+ *
+ * @param env
+ * @param thiz
+ * @param session
+ * @param input_ids
+ * @param attention_mask
+ * @param position_ids
+ * @param sequence_length
+ * @param past_sequence_length
+ * @param vocab_size
+ *
+ * @return Next token id
+ */
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_performInferenceStep(JNIEnv *env, jobject thiz,
+                                                                  jlong session,
+                                                                  jlongArray input_ids,
+                                                                  jlongArray attention_mask,
+                                                                  jlongArray position_ids,
+                                                                  jint batch_size,
+                                                                  jint sequence_length,
+                                                                  jint past_sequence_length,
+                                                                  jint vocab_size
+                                                                  ) {
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+
+    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
+    jlong* attention_mask_elements = env->GetLongArrayElements(attention_mask, nullptr);
+    jlong* position_ids_elements = env->GetLongArrayElements(position_ids, nullptr);
+
+    // A C++ exception must never cross the JNI boundary: an Ort::Exception escaping here calls
+    // std::terminate and aborts the whole process, so a recoverable shape/IO error took the app (and,
+    // in CI, the entire instrumentation run) down instead of surfacing as a catchable failure. Kotlin's
+    // `catch (e: Throwable)` around generate() cannot see a C++ throw — it has to be converted here.
+    try {
+        // Forward pass
+        auto logits = inference::generateWithKVCache(session_cache,
+                                       input_ids_elements,
+                                       attention_mask_elements,
+                                       position_ids_elements,
+                                       batch_size,
+                                       sequence_length,
+                                       past_sequence_length);
+
+        // The graph decides how wide the vocabulary is, not the package's JSON declaration. An
+        // over-declared vocab_size both mis-strides the row offset and lets the argmax return an id
+        // with no embedding row, which the NEXT step reports as an out-of-bounds Gather far from the
+        // cause. See sampling::effectiveVocabSize.
+        const long long graph_width = session_cache->lastLogitsWidth();
+        const int sampled_vocab_size = sampling::effectiveVocabSize(vocab_size, graph_width);
+        if (sampled_vocab_size != vocab_size) {
+            __android_log_print(ANDROID_LOG_WARN, LOG_TAG,
+                                "declared vocab_size %d exceeds the graph's logits width %lld; "
+                                "sampling over %d. Re-export the package: its "
+                                "mobiletransformers_tokenizer_config.json is wrong.",
+                                vocab_size, graph_width, sampled_vocab_size);
+        }
+
+        int best_index = sampling::sampleNextToken(logits, past_sequence_length, sampled_vocab_size, session_cache->sampling_config, session_cache->random_generator);
+
+        env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(attention_mask, attention_mask_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(position_ids, position_ids_elements, JNI_ABORT);
+        return best_index;
+    } catch (const std::exception& e) {
+        env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(attention_mask, attention_mask_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(position_ids, position_ids_elements, JNI_ABORT);
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "performInferenceStep failed: %s", e.what());
+        jclass runtime_exception = env->FindClass("java/lang/RuntimeException");
+        if (runtime_exception != nullptr) {
+            env->ThrowNew(runtime_exception, (std::string("inference step failed: ") + e.what()).c_str());
+        }
+        return -1;
+    }
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTokenizerNative_createTokenizerSession(JNIEnv *env,
+                                                                          jobject thiz,
+                                                                          jstring jTokenizerFile) {
+    // Convert Java string to C++ string
+    const char *tokenizer_file = env->GetStringUTFChars(jTokenizerFile, nullptr);
+    std::unique_ptr<TokenizerSessionCache> tokenizer = std::make_unique<TokenizerSessionCache>(tokenizer_file);
+
+    // Release the Java string memory
+    env->ReleaseStringUTFChars(jTokenizerFile, tokenizer_file);
+
+    // Return the handle (cast the unique pointer to `jlong`)
+    return reinterpret_cast<jlong>(tokenizer.release());
+}
+
+
+extern "C"
+JNIEXPORT jintArray JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTokenizerNative_tokenizeString(JNIEnv *env, jobject thiz,
+                                                                  jlong tokenizer_model,
+                                                                  jstring sequence) {
+    // Convert Java string to C++ string
+    const char *text = env->GetStringUTFChars(sequence, nullptr);
+
+    std::vector<int32_t> tokens = tokenization::tokenize(tokenizer_model, text);
+
+    // Release the Java string memory
+    env->ReleaseStringUTFChars(sequence, text);
+    jintArray token_array = env->NewIntArray(tokens.size());
+    env->SetIntArrayRegion(token_array, 0, tokens.size(), reinterpret_cast<const jint *>(tokens.data()));
+    return token_array;
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTokenizerNative_decodeString(JNIEnv *env, jobject thiz,
+                                                                  jlong tokenizer_model,
+                                                                  jintArray sequence) {
+
+    // Convert Java int array to C++ vector
+    jsize length = env->GetArrayLength(sequence);
+    std::vector<int32_t> token_ids(length);
+    env->GetIntArrayRegion(sequence, 0, length, reinterpret_cast<jint *>(token_ids.data()));
+
+    // Decode the token IDs
+    std::string decoded_text = tokenization::decode(tokenizer_model, token_ids);
+
+    // Convert C++ string to Java string
+    return env->NewStringUTF(decoded_text.c_str());
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTokenizerNative_releaseTokenizerSession(JNIEnv *env, jobject thiz, jlong tokenizer_model) {
+    ReleaseTokenizerSession(tokenizer_model);
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTokenizerNative_decodeToken(JNIEnv *env, jobject thiz,
+                                                               jlong tokenizer_model,
+                                                               jint token_id) {
+
+    // Decode the token IDs
+    std::string decoded_text = tokenization::decodeToken(tokenizer_model, token_id);
+
+    // Convert C++ string to Java string
+    return env->NewStringUTF(decoded_text.c_str());
+}
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_optimizerStep(JNIEnv *env, jobject thiz,
+                                                                jlong session) {
+    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    return training::optimizer_step(session_cache);
+}
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_setLearningRate(JNIEnv *env, jobject thiz,
+                                                                  jlong session,
+                                                                  jfloat learning_rate) {
+    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    session_cache->SetLearningRate(learning_rate);
+}
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_saveModel(JNIEnv *env, jobject thiz,
+                                                            jlong session, jboolean saveOptimizer) {
+    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
+
+    Ort::CheckpointState::SaveCheckpoint(session_cache->checkpoint_state, session_cache->artifact_paths.checkpoint_path, saveOptimizer);
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+/**
+ * Merges and exports the weights which are then ready for inference session.
+ *
+ * @param env
+ * @param thiz
+ * @param session
+ */
+Java_com_martinkorelic_mobiletransformers_ORTTrainerNative_mergeExportWeights(JNIEnv *env, jobject thiz,
+                                                                     jlong session,
+                                                                     jstring peft_mapping_path,
+                                                                     jstring merger_models_directory,
+                                                                     jstring output_directory) {
+    try {
+        auto* session_cache = reinterpret_cast<TrainingSessionCache*>(session);
+
+        // Convert Java strings to C++ strings
+        const char* peft_path_cstr = env->GetStringUTFChars(peft_mapping_path, nullptr);
+        const char* merger_models_dir_cstr = env->GetStringUTFChars(merger_models_directory, nullptr);
+        const char* output_dir_cstr = env->GetStringUTFChars(output_directory, nullptr);
+
+        std::string peft_path(peft_path_cstr);
+        std::string merger_models_dir(merger_models_dir_cstr);
+        std::string output_dir(output_dir_cstr);
+
+        // Release Java strings
+        env->ReleaseStringUTFChars(peft_mapping_path, peft_path_cstr);
+        env->ReleaseStringUTFChars(merger_models_directory, merger_models_dir_cstr);
+        env->ReleaseStringUTFChars(output_directory, output_dir_cstr);
+
+        // Perform weight merging
+        bool success = session_cache->weight_merger->merge_and_export_weights(
+                session_cache->checkpoint_state,
+                peft_path,
+                merger_models_dir,
+                output_dir
+        );
+
+        // Destroy the old WeightMerger instance and create a new one for next time
+        session_cache->weight_merger.reset();
+        session_cache->weight_merger = nullptr;
+        session_cache->weight_merger = std::make_unique<WeightMerger>();
+
+        return success ? JNI_TRUE : JNI_FALSE;
+
+    } catch (const std::exception& e) {
+        LOGE("Error in mergeExportWeights: %s", e.what());
+        return JNI_FALSE;
+    }
+}
+
+// Additional JNI function to configure sampling parameters
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTGeneratorNative_setSamplingConfig(JNIEnv *env, jobject thiz,
+                                                                      jlong session,
+                                                                      jint sampling_method,
+                                                                      jfloat temperature,
+                                                                      jint top_k,
+                                                                      jfloat top_p,
+                                                                      jint random_seed) {
+    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
+
+    auto method = static_cast<sampling::SamplingMethod>(sampling_method);
+
+    session_cache->setSamplingConfig(method, temperature, top_k, top_p, random_seed);
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTRetriever_createEmbeddingSession(JNIEnv *env, jobject thiz,
+                                                                     jstring embedding_model_path,
+                                                                     jstring embedding_model_name,
+                                                                     jstring cache_dir_path,
+                                                                     jstring memory_config_id,
+                                                                     jstring core_config_id,
+                                                                     jstring execution_provider,
+                                                                     jboolean enable_profiling) {
+    try {
+        // Convert Java strings to C++ strings
+        const char *model_path_chars = env->GetStringUTFChars(embedding_model_path, nullptr);
+        const char *model_name_chars = env->GetStringUTFChars(embedding_model_name, nullptr);
+        const char *cache_path_chars = env->GetStringUTFChars(cache_dir_path, nullptr);
+        const char *memory_config_chars = env->GetStringUTFChars(memory_config_id, nullptr);
+        const char *core_config_chars = env->GetStringUTFChars(core_config_id, nullptr);
+        const char *execution_provider_chars = env->GetStringUTFChars(execution_provider, nullptr);
+
+        std::string model_path_str(model_path_chars);
+        std::string model_name_str(model_name_chars);
+        std::string cache_path_str(cache_path_chars);
+        std::string memory_config_str(memory_config_chars);
+        std::string core_config_str(core_config_chars);
+        std::string execution_provider_str(execution_provider_chars);
+
+        // Release Java string references
+        env->ReleaseStringUTFChars(embedding_model_path, model_path_chars);
+        env->ReleaseStringUTFChars(embedding_model_name, model_name_chars);
+        env->ReleaseStringUTFChars(cache_dir_path, cache_path_chars);
+        env->ReleaseStringUTFChars(memory_config_id, memory_config_chars);
+        env->ReleaseStringUTFChars(core_config_id, core_config_chars);
+        env->ReleaseStringUTFChars(execution_provider, execution_provider_chars);
+
+        LOGI("Creating embedding session with model: %s", model_name_str.c_str());
+
+        // Create the embedding session cache
+        auto *embedding_session = new EmbeddingSessionCache(
+                model_path_str,
+                model_name_str,
+                cache_path_str,
+                memory_config_str,
+                core_config_str,
+                execution_provider_str,
+                static_cast<bool>(enable_profiling)
+        );
+
+        LOGI("Embedding session created successfully");
+
+        // Return the pointer as jlong
+        return reinterpret_cast<jlong>(embedding_session);
+
+    } catch (const std::exception &e) {
+        LOGE("Failed to create embedding session: %s", e.what());
+
+        // Throw Java exception
+        jclass exception_class = env->FindClass("java/lang/RuntimeException");
+        if (exception_class != nullptr) {
+            env->ThrowNew(exception_class, e.what());
+        }
+
+        return 0;
+    }
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_martinkorelic_mobiletransformers_ORTRetriever_releaseEmbeddingSession(JNIEnv *env, jobject thiz, jlong session) {
+    try {
+
+        auto *session_cache = reinterpret_cast<EmbeddingSessionCache *>(session);
+
+        delete session_cache->embedding_session;
+        delete session_cache;
+        session_cache = nullptr;
+
+    } catch (const std::exception& e) {
+        LOGE("Failed to destroy embedding session: %s", e.what());
+    }
+}
+
+extern "C"
+JNIEXPORT jfloatArray JNICALL
+/**
+ * Performs the inference step using the exported model for inference.
+ *
+ * @param env
+ * @param thiz
+ * @param session
+ * @param input_ids
+ * @param attention_mask
+ * @param token_type_ids
+ * @param sequence_length
+ *
+ * @return Next token id
+ */
+Java_com_martinkorelic_mobiletransformers_ORTRetriever_performEmbeddingStep(JNIEnv *env, jobject thiz,
+        jlong session,
+        jlongArray input_ids,
+        jlongArray attention_mask,
+        jlongArray token_type_ids,
+        jint batch_size,
+        jint sequence_length,
+        jint embedding_dim) {
+    auto *session_cache = reinterpret_cast<EmbeddingSessionCache *>(session);
+
+    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
+    jlong* attention_mask_elements = env->GetLongArrayElements(attention_mask, nullptr);
+    jlong* token_type_ids_elements = env->GetLongArrayElements(token_type_ids, nullptr);
+
+    // Forward pass
+    auto embedding_vector = inference::generateEmbedding(session_cache,
+                                        input_ids_elements,
+                                     attention_mask_elements,
+                                     token_type_ids_elements,
+                                                 batch_size,
+                                                 sequence_length);
+
+    jint total_size = batch_size * embedding_dim;
+    jfloatArray result = env->NewFloatArray(total_size);
+
+    // JNI_ABORT: nothing was written back into these, so there is no copy worth committing. Without
+    // the release the three arrays pinned above leak on EVERY embedding call — once per chunk during
+    // a RAG ingest, which is the workload that makes it matter.
+    auto release_inputs = [&] {
+    env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(attention_mask, attention_mask_elements, JNI_ABORT);
+        env->ReleaseLongArrayElements(token_type_ids, token_type_ids_elements, JNI_ABORT);
+    };
+
+    if (!result) {
+        LOGE("Failed to create result float array");
+        // NB: `embedding_vector` is NOT ours to free. It points into
+        // `EmbeddingSessionCache::last_output`, owned by the cache and valid until the next forward
+        // pass. This path used to `delete` it — a pointer that was never `new`-allocated, and
+        // since the fix above, one that belongs to a live object.
+        release_inputs;
+        return nullptr;
+    }
+
+    // Copy data to Java array
+    env->SetFloatArrayRegion(result, 0, total_size, embedding_vector);
+
+    release_inputs;
+    return result;
+}
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai.h
new file mode 100644
index 0000000..3424287
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai.h
@@ -0,0 +1,909 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+#if __cplusplus >= 202002L
+#include <span>
+#define OGA_USE_SPAN 1
+#endif
+
+#include "ort_genai_c.h"
+
+// GenAI C++ API
+//
+// This is a zero cost wrapper around the C API, and provides for a set of C++ classes with automatic resource management
+
+/* A simple end to end example of how to generate an answer from a prompt:
+ *
+ * auto model = OgaModel::Create("phi-2");
+ * auto tokenizer = OgaTokenizer::Create(*model);
+ *
+ * auto sequences = OgaSequences::Create();
+ * tokenizer->Encode("A great recipe for Kung Pao chicken is ", *sequences);
+ *
+ * auto params = OgaGeneratorParams::Create(*model);
+ * params->SetSearchOption("max_length", 200);
+ * params->SetSearchOption("batch_size", 1);
+ *
+ * auto generator = OgaGenerator::Create(*model, *params);
+ * generator->AppendTokenSequences(*sequences);
+ * while (!generator->IsDone()) {
+ *  generator->GenerateNextToken();
+ * }
+ * auto output_sequence = generator->GetSequenceData(0);
+ * auto output_string = tokenizer->Decode(output_sequence, generator->GetSequenceCount(0));
+ *
+ * std::cout << "Output: " << std::endl << output_string << std::endl;
+ */
+
+// The types defined in this file are to give us zero overhead C++ style interfaces around an opaque C pointer.
+// For example, there is no actual 'OgaModel' type defined anywhere, so we create a fake definition here
+// that lets users have a C++ style OgaModel type that can be held in a std::unique_ptr.
+//
+// This OgaAbstract struct is to prevent accidentally trying to use them by value.
+struct OgaAbstract {
+  OgaAbstract() = delete;
+  OgaAbstract(const OgaAbstract&) = delete;
+  void operator=(const OgaAbstract&) = delete;
+};
+
+struct OgaResult : OgaAbstract {
+  const char* GetError() const { return OgaResultGetError(this); }
+  static void operator delete(void* p) { OgaDestroyResult(reinterpret_cast<OgaResult*>(p)); }
+};
+
+// This is used to turn OgaResult return values from the C API into std::runtime_error exceptions
+inline void OgaCheckResult(OgaResult* result) {
+  if (result) {
+    std::unique_ptr<OgaResult> p_result{result};  // Take ownership so it's destroyed properly
+    throw std::runtime_error(p_result->GetError());
+  }
+}
+
+struct OgaFloat16_t;
+struct OgaBFloat16_t;
+
+// Variable templates to convert a C++ type into it's OgaElementType
+template <typename T>
+inline constexpr OgaElementType OgaTypeToElementType = T::Unsupported_Type;  // Force a compile error if hit, please add specialized version if type is valid
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<bool> = OgaElementType_bool;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<int8_t> = OgaElementType_int8;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<uint8_t> = OgaElementType_uint8;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<int16_t> = OgaElementType_int16;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<uint16_t> = OgaElementType_uint16;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<int32_t> = OgaElementType_int32;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<uint32_t> = OgaElementType_uint32;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<int64_t> = OgaElementType_int64;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<uint64_t> = OgaElementType_uint64;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<float> = OgaElementType_float32;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<double> = OgaElementType_float64;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<OgaFloat16_t> = OgaElementType_float16;
+template <>
+inline constexpr OgaElementType OgaTypeToElementType<OgaBFloat16_t> = OgaElementType_bfloat16;
+
+struct OgaString {
+  OgaString(const char* p) : p_{p} {}
+  ~OgaString() { OgaDestroyString(p_); }
+
+  operator const char*() const { return p_; }
+
+  const char* p_;
+};
+
+struct OgaStringArray {
+  static std::unique_ptr<OgaStringArray> Create() {
+    OgaStringArray* p;
+    OgaCheckResult(OgaCreateStringArray(&p));
+    return std::unique_ptr<OgaStringArray>(p);
+  }
+
+  static std::unique_ptr<OgaStringArray> Create(const char* const* strings, size_t count) {
+    OgaStringArray* p;
+    OgaCheckResult(OgaCreateStringArrayFromStrings(strings, count, &p));
+    return std::unique_ptr<OgaStringArray>(p);
+  }
+
+  void Add(const char* str) {
+    OgaCheckResult(OgaStringArrayAddString(this, str));
+  }
+
+  const char* Get(size_t index) const {
+    const char* p;
+    OgaCheckResult(OgaStringArrayGetString(this, index, &p));
+    return p;
+  }
+
+  size_t Count() const {
+    size_t count;
+    OgaCheckResult(OgaStringArrayGetCount(this, &count));
+    return count;
+  }
+
+  static void operator delete(void* p) { OgaDestroyStringArray(reinterpret_cast<OgaStringArray*>(p)); }
+};
+
+struct OgaRuntimeSettings : OgaAbstract {
+  static std::unique_ptr<OgaRuntimeSettings> Create() {
+    OgaRuntimeSettings* p;
+    OgaCheckResult(OgaCreateRuntimeSettings(&p));
+    return std::unique_ptr<OgaRuntimeSettings>(p);
+  }
+
+  void SetHandle(const char* name, void* handle) {
+    OgaCheckResult(OgaRuntimeSettingsSetHandle(this, name, handle));
+  }
+  void SetHandle(const std::string& name, void* handle) {
+    SetHandle(name.c_str(), handle);
+  }
+
+  static void operator delete(void* p) { OgaDestroyRuntimeSettings(reinterpret_cast<OgaRuntimeSettings*>(p)); }
+};
+
+struct OgaConfig : OgaAbstract {
+  static std::unique_ptr<OgaConfig> Create(const char* config_path) {
+    OgaConfig* p;
+    OgaCheckResult(OgaCreateConfig(config_path, &p));
+    return std::unique_ptr<OgaConfig>(p);
+  }
+
+  void ClearProviders() {
+    OgaCheckResult(OgaConfigClearProviders(this));
+  }
+
+  void AppendProvider(const char* provider) {
+    OgaCheckResult(OgaConfigAppendProvider(this, provider));
+  }
+
+  void SetProviderOption(const char* provider, const char* name, const char* value) {
+    OgaCheckResult(OgaConfigSetProviderOption(this, provider, name, value));
+  }
+
+  void Overlay(const char* json) {
+    OgaCheckResult(OgaConfigOverlay(this, json));
+  }
+
+  void AddModelData(const std::string& model_filename, const void* model_data, size_t model_data_length) {
+    OgaCheckResult(OgaConfigAddModelData(this, model_filename.c_str(), model_data, model_data_length));
+  }
+
+  void AddModelData(const std::string& model_filename, const std::vector<std::byte>& model_data) {
+    OgaCheckResult(OgaConfigAddModelData(this, model_filename.c_str(), model_data.data(), model_data.size()));
+  }
+
+#if OGA_USE_SPAN
+  void AddModelData(const std::string& model_filename, std::span<const std::byte> model_data) {
+    OgaCheckResult(OgaConfigAddModelData(this, model_filename.c_str(), model_data.data(), model_data.size()));
+  }
+#endif
+
+  void RemoveModelData(const std::string& model_filename) {
+    OgaCheckResult(OgaConfigRemoveModelData(this, model_filename.c_str()));
+  }
+
+  void SetDecoderProviderOptionsHardwareDeviceType(const char* provider, const char* hardware_device_type) {
+    OgaCheckResult(OgaConfigSetDecoderProviderOptionsHardwareDeviceType(this, provider, hardware_device_type));
+  }
+
+  void SetDecoderProviderOptionsHardwareDeviceId(const char* provider, uint32_t hardware_device_id) {
+    OgaCheckResult(OgaConfigSetDecoderProviderOptionsHardwareDeviceId(this, provider, hardware_device_id));
+  }
+
+  void SetDecoderProviderOptionsHardwareVendorId(const char* provider, uint32_t hardware_vendor_id) {
+    OgaCheckResult(OgaConfigSetDecoderProviderOptionsHardwareVendorId(this, provider, hardware_vendor_id));
+  }
+
+  void ClearDecoderProviderOptionsHardwareDeviceType(const char* provider) {
+    OgaCheckResult(OgaConfigClearDecoderProviderOptionsHardwareDeviceType(this, provider));
+  }
+
+  void ClearDecoderProviderOptionsHardwareDeviceId(const char* provider) {
+    OgaCheckResult(OgaConfigClearDecoderProviderOptionsHardwareDeviceId(this, provider));
+  }
+
+  void ClearDecoderProviderOptionsHardwareVendorId(const char* provider) {
+    OgaCheckResult(OgaConfigClearDecoderProviderOptionsHardwareVendorId(this, provider));
+  }
+
+  static void operator delete(void* p) { OgaDestroyConfig(reinterpret_cast<OgaConfig*>(p)); }
+};
+
+struct OgaModel : OgaAbstract {
+  static std::unique_ptr<OgaModel> Create(const char* config_path) {
+    OgaModel* p;
+    OgaCheckResult(OgaCreateModel(config_path, &p));
+    return std::unique_ptr<OgaModel>(p);
+  }
+  static std::unique_ptr<OgaModel> Create(const char* config_path, const OgaRuntimeSettings& settings) {
+    OgaModel* p;
+    OgaCheckResult(OgaCreateModelWithRuntimeSettings(config_path, &settings, &p));
+    return std::unique_ptr<OgaModel>(p);
+  }
+  static std::unique_ptr<OgaModel> Create(const OgaConfig& config) {
+    OgaModel* p;
+    OgaCheckResult(OgaCreateModelFromConfig(&config, &p));
+    return std::unique_ptr<OgaModel>(p);
+  }
+
+  OgaString GetType() const {
+    const char* p;
+    OgaCheckResult(OgaModelGetType(this, &p));
+    return p;
+  }
+
+  OgaString GetDeviceType() const {
+    const char* p;
+    OgaCheckResult(OgaModelGetDeviceType(this, &p));
+    return p;
+  }
+
+  static void operator delete(void* p) { OgaDestroyModel(reinterpret_cast<OgaModel*>(p)); }
+};
+
+struct OgaSequences : OgaAbstract {
+  static std::unique_ptr<OgaSequences> Create() {
+    OgaSequences* p;
+    OgaCheckResult(OgaCreateSequences(&p));
+    return std::unique_ptr<OgaSequences>(p);
+  }
+
+  size_t Count() const {
+    return OgaSequencesCount(this);
+  }
+
+  size_t SequenceCount(size_t index) const {
+    return OgaSequencesGetSequenceCount(this, index);
+  }
+
+  const int32_t* SequenceData(size_t index) const {
+    return OgaSequencesGetSequenceData(this, index);
+  }
+
+  void Append(const int32_t* tokens, size_t token_cnt) {
+    OgaCheckResult(OgaAppendTokenSequence(tokens, token_cnt, this));
+  }
+
+  void Append(int32_t token, size_t sequence_index) {
+    OgaCheckResult(OgaAppendTokenToSequence(token, this, sequence_index));
+  }
+
+#if OGA_USE_SPAN
+  std::span<const int32_t> Get(size_t index) const {
+    return {SequenceData(index), SequenceCount(index)};
+  }
+  void Append(std::span<const int32_t> sequence) {
+    OgaCheckResult(OgaAppendTokenSequence(sequence.data(), sequence.size(), this));
+  }
+  void Append(const std::vector<int32_t>& sequence) {
+    OgaCheckResult(OgaAppendTokenSequence(sequence.data(), sequence.size(), this));
+  }
+#endif
+
+  static void operator delete(void* p) { OgaDestroySequences(reinterpret_cast<OgaSequences*>(p)); }
+};
+
+struct OgaTokenizer : OgaAbstract {
+  static std::unique_ptr<OgaTokenizer> Create(const OgaModel& model) {
+    OgaTokenizer* p;
+    OgaCheckResult(OgaCreateTokenizer(&model, &p));
+    return std::unique_ptr<OgaTokenizer>(p);
+  }
+
+  void UpdateOptions(const char* const* keys, const char* const* values, size_t num_options) {
+    OgaCheckResult(OgaUpdateTokenizerOptions(this, keys, values, num_options));
+  }
+
+  int32_t GetBosTokenId() const {
+    int32_t token_id;
+    OgaCheckResult(OgaTokenizerGetBosTokenId(this, &token_id));
+    return token_id;
+  }
+
+#if OGA_USE_SPAN
+  std::span<const int32_t> GetEosTokenIds() const {
+    const int32_t* eos_ids;
+    size_t count;
+    OgaCheckResult(OgaTokenizerGetEosTokenIds(this, &eos_ids, &count));
+    return {eos_ids, count};
+  }
+#else
+  std::vector<int32_t> GetEosTokenIds() const {
+    const int32_t* eos_ids_ptr;
+    size_t count;
+    OgaCheckResult(OgaTokenizerGetEosTokenIds(this, &eos_ids_ptr, &count));
+    return std::vector<int32_t>(eos_ids_ptr, eos_ids_ptr + count);
+  }
+#endif
+
+  int32_t GetPadTokenId() const {
+    int32_t token_id;
+    OgaCheckResult(OgaTokenizerGetPadTokenId(this, &token_id));
+    return token_id;
+  }
+
+  void Encode(const char* str, OgaSequences& sequences) const {
+    OgaCheckResult(OgaTokenizerEncode(this, str, &sequences));
+  }
+
+  std::unique_ptr<OgaTensor> EncodeBatch(const char** strings, size_t count) const {
+    OgaTensor* out;
+    OgaCheckResult(OgaTokenizerEncodeBatch(this, strings, count, &out));
+    return std::unique_ptr<OgaTensor>(out);
+  }
+
+  int32_t ToTokenId(const char* str) const {
+    int32_t token_id;
+    OgaCheckResult(OgaTokenizerToTokenId(this, str, &token_id));
+    return token_id;
+  }
+
+  OgaString Decode(const int32_t* tokens_data, size_t tokens_length) const {
+    const char* p;
+    OgaCheckResult(OgaTokenizerDecode(this, tokens_data, tokens_length, &p));
+    return p;
+  }
+
+  OgaString ApplyChatTemplate(const char* template_str, const char* messages, const char* tools, bool add_generation_prompt) const {
+    const char* p{};
+    OgaCheckResult(OgaTokenizerApplyChatTemplate(this, template_str, messages, tools, add_generation_prompt, &p));
+    return p;
+  }
+
+#if OGA_USE_SPAN
+  OgaString Decode(std::span<const int32_t> tokens) const {
+    const char* p;
+    OgaCheckResult(OgaTokenizerDecode(this, tokens.data(), tokens.size(), &p));
+    return p;
+  }
+#endif
+
+  std::unique_ptr<OgaStringArray> DecodeBatch(const OgaTensor& tensor) const {
+    OgaStringArray* p;
+    OgaCheckResult(OgaTokenizerDecodeBatch(this, &tensor, &p));
+    return std::unique_ptr<OgaStringArray>(p);
+  }
+
+  static void operator delete(void* p) { OgaDestroyTokenizer(reinterpret_cast<OgaTokenizer*>(p)); }
+};
+
+struct OgaTokenizerStream : OgaAbstract {
+  static std::unique_ptr<OgaTokenizerStream> Create(const OgaTokenizer& tokenizer) {
+    OgaTokenizerStream* p;
+    OgaCheckResult(OgaCreateTokenizerStream(&tokenizer, &p));
+    return std::unique_ptr<OgaTokenizerStream>(p);
+  }
+
+  static std::unique_ptr<OgaTokenizerStream> Create(const OgaMultiModalProcessor& processor) {
+    OgaTokenizerStream* p;
+    OgaCheckResult(OgaCreateTokenizerStreamFromProcessor(&processor, &p));
+    return std::unique_ptr<OgaTokenizerStream>(p);
+  }
+
+  /*
+   * Decode a single token in the stream. If this results in a word being generated, it will be returned in 'out'.
+   * The caller is responsible for concatenating each chunk together to generate the complete result.
+   * 'out' is valid until the next call to OgaTokenizerStreamDecode or when the OgaTokenizerStream is destroyed
+   */
+  const char* Decode(int32_t token) {
+    const char* out;
+    OgaCheckResult(OgaTokenizerStreamDecode(this, token, &out));
+    return out;
+  }
+
+  static void operator delete(void* p) { OgaDestroyTokenizerStream(reinterpret_cast<OgaTokenizerStream*>(p)); }
+};
+
+struct OgaGeneratorParams : OgaAbstract {
+  static std::unique_ptr<OgaGeneratorParams> Create(const OgaModel& model) {
+    OgaGeneratorParams* p;
+    OgaCheckResult(OgaCreateGeneratorParams(&model, &p));
+    return std::unique_ptr<OgaGeneratorParams>(p);
+  }
+
+  void SetSearchOption(const char* name, double value) {
+    OgaCheckResult(OgaGeneratorParamsSetSearchNumber(this, name, value));
+  }
+
+  void SetSearchOptionBool(const char* name, bool value) {
+    OgaCheckResult(OgaGeneratorParamsSetSearchBool(this, name, value));
+  }
+
+  void SetGuidance(const char* type, const char* data, bool enable_ff_tokens = false) {
+    OgaCheckResult(OgaGeneratorParamsSetGuidance(this, type, data, enable_ff_tokens));
+  }
+
+  double GetSearchNumber(const char* name) const {
+    double value;
+    OgaCheckResult(OgaGeneratorParamsGetSearchNumber(this, name, &value));
+    return value;
+  }
+
+  bool GetSearchBool(const char* name) const {
+    bool value;
+    OgaCheckResult(OgaGeneratorParamsGetSearchBool(this, name, &value));
+    return value;
+  }
+
+  static void operator delete(void* p) { OgaDestroyGeneratorParams(reinterpret_cast<OgaGeneratorParams*>(p)); }
+};
+
+struct OgaGenerator : OgaAbstract {
+  static std::unique_ptr<OgaGenerator> Create(const OgaModel& model, OgaGeneratorParams& params) {
+    OgaGenerator* p;
+    OgaCheckResult(OgaCreateGenerator(&model, &params, &p));
+    return std::unique_ptr<OgaGenerator>(p);
+  }
+
+  bool IsDone() {
+    return OgaGenerator_IsDone(this);
+  }
+
+  bool IsSessionTerminated() const {
+    return OgaGenerator_IsSessionTerminated(this);
+  }
+
+  void SetModelInput(const char* name, OgaTensor& tensor) {
+    OgaCheckResult(OgaGenerator_SetModelInput(this, name, &tensor));
+  }
+
+  void SetInputs(OgaNamedTensors& named_tensors) {
+    OgaCheckResult(OgaGenerator_SetInputs(this, &named_tensors));
+  }
+
+  void AppendTokenSequences(const OgaSequences& sequences) {
+    OgaCheckResult(OgaGenerator_AppendTokenSequences(this, &sequences));
+  }
+
+  void AppendTokens(const int32_t* input_ids, size_t input_ids_count) {
+    OgaCheckResult(OgaGenerator_AppendTokens(this, input_ids, input_ids_count));
+  }
+
+#if OGA_USE_SPAN
+  void AppendTokens(std::span<const int32_t> input_ids) {
+    OgaCheckResult(OgaGenerator_AppendTokens(this, input_ids.data(), input_ids.size()));
+  }
+#endif
+
+  size_t TokenCount() const {
+    return OgaGenerator_TokenCount(this);
+  }
+
+  void GenerateNextToken() {
+    OgaCheckResult(OgaGenerator_GenerateNextToken(this));
+  }
+
+#if OGA_USE_SPAN
+  std::span<const int32_t> GetNextTokens() {
+    const int32_t* out;
+    size_t out_count;
+    OgaCheckResult(OgaGenerator_GetNextTokens(this, &out, &out_count));
+    return {out, out_count};
+  }
+#else
+  std::vector<int32_t> GetNextTokens() {
+    const int32_t* out;
+    size_t out_count;
+    OgaCheckResult(OgaGenerator_GetNextTokens(this, &out, &out_count));
+    return std::vector<int32_t>(out, out + out_count);
+  }
+#endif
+
+  void RewindTo(size_t new_length) {
+    OgaCheckResult(OgaGenerator_RewindTo(this, new_length));
+  }
+
+  void SetRuntimeOption(const char* key, const char* value) {
+    OgaCheckResult(OgaGenerator_SetRuntimeOption(this, key, value));
+  }
+
+  size_t GetSequenceCount(size_t index) const {
+    return OgaGenerator_GetSequenceCount(this, index);
+  }
+
+  const int32_t* GetSequenceData(size_t index) const {
+    return OgaGenerator_GetSequenceData(this, index);
+  }
+
+  std::unique_ptr<OgaTensor> GetInput(const char* name) {
+    OgaTensor* out;
+    OgaCheckResult(OgaGenerator_GetInput(this, name, &out));
+    return std::unique_ptr<OgaTensor>(out);
+  }
+
+  std::unique_ptr<OgaTensor> GetOutput(const char* name) {
+    OgaTensor* out;
+    OgaCheckResult(OgaGenerator_GetOutput(this, name, &out));
+    return std::unique_ptr<OgaTensor>(out);
+  }
+
+  std::unique_ptr<OgaTensor> GetLogits() {
+    OgaTensor* out;
+    OgaCheckResult(OgaGenerator_GetLogits(this, &out));
+    return std::unique_ptr<OgaTensor>(out);
+  }
+
+  void SetLogits(OgaTensor& tensor) {
+    OgaCheckResult(OgaGenerator_SetLogits(this, &tensor));
+  }
+
+#if OGA_USE_SPAN
+  std::span<const int32_t> GetSequence(size_t index) const {
+    return {GetSequenceData(index), GetSequenceCount(index)};
+  }
+#endif
+
+  void SetActiveAdapter(OgaAdapters& adapters, const char* adapter_name) {
+    OgaCheckResult(OgaSetActiveAdapter(this, &adapters, adapter_name));
+  }
+
+  static void operator delete(void* p) { OgaDestroyGenerator(reinterpret_cast<OgaGenerator*>(p)); }
+};
+
+struct OgaTensor : OgaAbstract {
+#if OGA_USE_SPAN
+  template <typename T>
+  static std::unique_ptr<OgaTensor> Create(T* data, std::span<const int64_t> shape) {
+    OgaTensor* p;
+    OgaCheckResult(OgaCreateTensorFromBuffer(data, shape.data(), shape.size(), OgaTypeToElementType<T>, &p));
+    return std::unique_ptr<OgaTensor>(p);
+  }
+
+  static std::unique_ptr<OgaTensor> Create(void* data, std::span<const int64_t> shape, OgaElementType type) {
+    OgaTensor* p;
+    OgaCheckResult(OgaCreateTensorFromBuffer(data, shape.data(), shape.size(), type, &p));
+    return std::unique_ptr<OgaTensor>(p);
+  }
+#endif
+
+  static std::unique_ptr<OgaTensor> Create(void* data, const int64_t* shape_dims, size_t shape_dims_count, OgaElementType element_type) {
+    OgaTensor* p;
+    OgaCheckResult(OgaCreateTensorFromBuffer(data, shape_dims, shape_dims_count, element_type, &p));
+    return std::unique_ptr<OgaTensor>(p);
+  }
+
+  OgaElementType Type() {
+    OgaElementType type;
+    OgaCheckResult(OgaTensorGetType(this, &type));
+    return type;
+  }
+
+  std::vector<int64_t> Shape() {
+    size_t size;
+    OgaCheckResult(OgaTensorGetShapeRank(this, &size));
+    std::vector<int64_t> shape(size);
+    OgaCheckResult(OgaTensorGetShape(this, shape.data(), shape.size()));
+    return shape;
+  }
+
+  void* Data() {
+    void* data;
+    OgaCheckResult(OgaTensorGetData(this, &data));
+    return data;
+  }
+
+  static void operator delete(void* p) { OgaDestroyTensor(reinterpret_cast<OgaTensor*>(p)); }
+};
+
+struct OgaImages : OgaAbstract {
+  static std::unique_ptr<OgaImages> Load(const std::vector<const char*>& image_paths) {
+    OgaImages* p;
+    auto strs = OgaStringArray::Create(image_paths.data(), image_paths.size());
+    OgaCheckResult(OgaLoadImages(strs.get(), &p));
+    return std::unique_ptr<OgaImages>(p);
+  }
+
+#if OGA_USE_SPAN
+  static std::unique_ptr<OgaImages> Load(std::span<const char* const> image_paths) {
+    OgaImages* p;
+    auto strs = OgaStringArray::Create(image_paths.data(), image_paths.size());
+    OgaCheckResult(OgaLoadImages(strs.get(), &p));
+    return std::unique_ptr<OgaImages>(p);
+  }
+#endif
+
+  static std::unique_ptr<OgaImages> Load(const void** image_data, const size_t* image_data_sizes, size_t count) {
+    OgaImages* p;
+    OgaCheckResult(OgaLoadImagesFromBuffers(image_data, image_data_sizes, count, &p));
+    return std::unique_ptr<OgaImages>(p);
+  }
+
+  static void operator delete(void* p) { OgaDestroyImages(reinterpret_cast<OgaImages*>(p)); }
+};
+
+struct OgaAudios : OgaAbstract {
+  static std::unique_ptr<OgaAudios> Load(const std::vector<const char*>& audio_paths) {
+    OgaAudios* p;
+    auto strs = OgaStringArray::Create(audio_paths.data(), audio_paths.size());
+    OgaCheckResult(OgaLoadAudios(strs.get(), &p));
+    return std::unique_ptr<OgaAudios>(p);
+  }
+
+#if OGA_USE_SPAN
+  static std::unique_ptr<OgaAudios> Load(std::span<const char* const> audio_paths) {
+    OgaAudios* p;
+    auto strs = OgaStringArray::Create(audio_paths.data(), audio_paths.size());
+    OgaCheckResult(OgaLoadAudios(strs.get(), &p));
+    return std::unique_ptr<OgaAudios>(p);
+  }
+#endif
+
+  static std::unique_ptr<OgaAudios> Load(const void** audio_data, const size_t* audio_data_sizes, size_t count) {
+    OgaAudios* p;
+    OgaCheckResult(OgaLoadAudiosFromBuffers(audio_data, audio_data_sizes, count, &p));
+    return std::unique_ptr<OgaAudios>(p);
+  }
+
+  static void operator delete(void* p) { OgaDestroyAudios(reinterpret_cast<OgaAudios*>(p)); }
+};
+
+struct OgaNamedTensors : OgaAbstract {
+  static std::unique_ptr<OgaNamedTensors> Create() {
+    OgaNamedTensors* p;
+    OgaCheckResult(OgaCreateNamedTensors(&p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaTensor> Get(const char* name) {
+    OgaTensor* p;
+    OgaCheckResult(OgaNamedTensorsGet(this, name, &p));
+    return std::unique_ptr<OgaTensor>(p);
+  }
+
+  void Set(const char* name, OgaTensor& tensor) {
+    OgaCheckResult(OgaNamedTensorsSet(this, name, &tensor));
+  }
+
+  void Delete(const char* name) {
+    OgaCheckResult(OgaNamedTensorsDelete(this, name));
+  }
+
+  size_t Count() const {
+    size_t count;
+    OgaCheckResult(OgaNamedTensorsCount(this, &count));
+    return count;
+  }
+
+  std::unique_ptr<OgaStringArray> GetNames() const {
+    OgaStringArray* p;
+    OgaCheckResult(OgaNamedTensorsGetNames(this, &p));
+    return std::unique_ptr<OgaStringArray>(p);
+  }
+
+  static void operator delete(void* p) { OgaDestroyNamedTensors(reinterpret_cast<OgaNamedTensors*>(p)); }
+};
+
+struct OgaMultiModalProcessor : OgaAbstract {
+  static std::unique_ptr<OgaMultiModalProcessor> Create(const OgaModel& model) {
+    OgaMultiModalProcessor* p;
+    OgaCheckResult(OgaCreateMultiModalProcessor(&model, &p));
+    return std::unique_ptr<OgaMultiModalProcessor>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessImages(const char* prompt, const OgaImages* images = nullptr) const {
+    OgaNamedTensors* p;
+    OgaCheckResult(OgaProcessorProcessImages(this, prompt, images, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessImages(const std::vector<const char*>& prompts, const OgaImages* images = nullptr) const {
+    OgaNamedTensors* p;
+    auto strs = OgaStringArray::Create(prompts.data(), prompts.size());
+    OgaCheckResult(OgaProcessorProcessImagesAndPrompts(this, strs.get(), images, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessAudios(const char* prompt, const OgaAudios* audios = nullptr) const {
+    OgaNamedTensors* p;
+    OgaCheckResult(OgaProcessorProcessAudios(this, prompt, audios, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessAudios(const std::vector<const char*>& prompts, const OgaAudios* audios = nullptr) const {
+    OgaNamedTensors* p;
+    auto strs = OgaStringArray::Create(prompts.data(), prompts.size());
+    OgaCheckResult(OgaProcessorProcessAudiosAndPrompts(this, strs.get(), audios, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessImagesAndAudios(const char* prompt, const OgaImages* images = nullptr, const OgaAudios* audios = nullptr) const {
+    OgaNamedTensors* p;
+    OgaCheckResult(OgaProcessorProcessImagesAndAudios(this, prompt, images, audios, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> ProcessImagesAndAudios(const std::vector<const char*>& prompts, const OgaImages* images = nullptr, const OgaAudios* audios = nullptr) const {
+    OgaNamedTensors* p;
+    auto strs = OgaStringArray::Create(prompts.data(), prompts.size());
+    OgaCheckResult(OgaProcessorProcessImagesAndAudiosAndPrompts(this, strs.get(), images, audios, &p));
+    return std::unique_ptr<OgaNamedTensors>(p);
+  }
+
+  OgaString Decode(const int32_t* tokens_data, size_t tokens_length) const {
+    const char* p;
+    OgaCheckResult(OgaProcessorDecode(this, tokens_data, tokens_length, &p));
+    return p;
+  }
+
+#if OGA_USE_SPAN
+  OgaString Decode(std::span<const int32_t> tokens) const {
+    const char* p;
+    OgaCheckResult(OgaProcessorDecode(this, tokens.data(), tokens.size(), &p));
+    return p;
+  }
+#endif
+
+  static void operator delete(void* p) { OgaDestroyMultiModalProcessor(reinterpret_cast<OgaMultiModalProcessor*>(p)); }
+};
+
+struct OgaAdapters : OgaAbstract {
+  static std::unique_ptr<OgaAdapters> Create(const OgaModel& model) {
+    OgaAdapters* p;
+    OgaCheckResult(OgaCreateAdapters(&model, &p));
+    return std::unique_ptr<OgaAdapters>(p);
+  }
+
+  void LoadAdapter(const char* adapter_file_path,
+                   const char* adapter_name) {
+    OgaCheckResult(OgaLoadAdapter(this, adapter_file_path, adapter_name));
+  }
+
+  void UnloadAdapter(const char* adapter_name) {
+    OgaCheckResult(OgaUnloadAdapter(this, adapter_name));
+  }
+
+  static void operator delete(void* p) { OgaDestroyAdapters(reinterpret_cast<OgaAdapters*>(p)); }
+};
+
+struct OgaRequest : OgaAbstract {
+  static std::unique_ptr<OgaRequest> Create(OgaGeneratorParams& params) {
+    OgaRequest* p;
+    OgaCheckResult(OgaCreateRequest(&params, &p));
+    return std::unique_ptr<OgaRequest>(p);
+  }
+
+  void AddTokens(const OgaSequences& tokens) {
+    OgaCheckResult(OgaRequestAddTokens(this, &tokens));
+  }
+
+  bool IsDone() const {
+    bool is_done{};
+    OgaCheckResult(OgaRequestIsDone(this, &is_done));
+    return is_done;
+  }
+
+  bool HasUnseenTokens() const {
+    bool has_unseen_tokens{};
+    OgaCheckResult(OgaRequestHasUnseenTokens(this, &has_unseen_tokens));
+    return has_unseen_tokens;
+  }
+
+  int32_t GetUnseenToken() {
+    int32_t token;
+    OgaCheckResult(OgaRequestGetUnseenToken(this, &token));
+    return token;
+  }
+
+  void SetOpaqueData(void* data) {
+    OgaCheckResult(OgaRequestSetOpaqueData(this, data));
+  }
+
+  void* GetOpaqueData() {
+    void* data;
+    OgaCheckResult(OgaRequestGetOpaqueData(this, &data));
+    return data;
+  }
+
+  static void operator delete(void* p) { OgaDestroyRequest(reinterpret_cast<OgaRequest*>(p)); }
+};
+
+struct OgaEngine : OgaAbstract {
+  static std::unique_ptr<OgaEngine> Create(OgaModel& model) {
+    OgaEngine* p;
+    OgaCheckResult(OgaCreateEngine(&model, &p));
+    return std::unique_ptr<OgaEngine>(p);
+  }
+
+  bool HasPendingRequests() {
+    bool f;
+    OgaCheckResult(OgaEngineHasPendingRequests(this, &f));
+    return f;
+  }
+
+  void Add(OgaRequest& request) {
+    OgaCheckResult(OgaEngineAddRequest(this, &request));
+  }
+
+  void Remove(OgaRequest& request) {
+    OgaCheckResult(OgaEngineRemoveRequest(this, &request));
+  }
+
+  std::unique_ptr<OgaRequest> Step() {
+    OgaRequest* request;
+    OgaCheckResult(OgaEngineStep(this, &request));
+    return request ? std::unique_ptr<OgaRequest>(request) : nullptr;
+  }
+
+  static void operator delete(void* p) { OgaDestroyEngine(reinterpret_cast<OgaEngine*>(p)); }
+};
+
+struct OgaHandle {
+  OgaHandle() = default;
+  ~OgaHandle() noexcept {
+    OgaShutdown();
+  }
+};
+
+// Global Oga functions
+namespace Oga {
+
+inline void SetLogBool(const char* name, bool value) {
+  OgaCheckResult(OgaSetLogBool(name, value));
+}
+
+inline void SetLogString(const char* name, const char* value) {
+  OgaCheckResult(OgaSetLogString(name, value));
+}
+
+inline void SetLogCallback(void (*callback)(const char* string, size_t length)) {
+  OgaCheckResult(OgaSetLogCallback(callback));
+}
+
+inline void SetCurrentGpuDeviceId(int device_id) {
+  OgaCheckResult(OgaSetCurrentGpuDeviceId(device_id));
+}
+
+inline int GetCurrentGpuDeviceId() {
+  int device_id;
+  OgaCheckResult(OgaGetCurrentGpuDeviceId(&device_id));
+  return device_id;
+}
+
+}  // namespace Oga
+
+struct OgaStreamingProcessor : OgaAbstract {
+  static std::unique_ptr<OgaStreamingProcessor> Create(OgaModel& model) {
+    OgaStreamingProcessor* p;
+    OgaCheckResult(OgaCreateStreamingProcessor(&model, &p));
+    return std::unique_ptr<OgaStreamingProcessor>(p);
+  }
+
+  std::unique_ptr<OgaNamedTensors> Process(const float* audio_data, size_t num_samples) {
+    OgaNamedTensors* out;
+    OgaCheckResult(OgaStreamingProcessorProcess(this, audio_data, num_samples, &out));
+    return std::unique_ptr<OgaNamedTensors>(out);  // May be nullptr if not enough audio
+  }
+
+  std::unique_ptr<OgaNamedTensors> Flush() {
+    OgaNamedTensors* out;
+    OgaCheckResult(OgaStreamingProcessorFlush(this, &out));
+    return std::unique_ptr<OgaNamedTensors>(out);
+  }
+
+  void SetOption(const char* key, const char* value) {
+    OgaCheckResult(OgaStreamingProcessorSetOption(this, key, value));
+  }
+
+  OgaString GetOption(const char* key) const {
+    const char* value;
+    OgaCheckResult(OgaStreamingProcessorGetOption(this, key, &value));
+    return value;
+  }
+
+  static void operator delete(void* p) { OgaDestroyStreamingProcessor(reinterpret_cast<OgaStreamingProcessor*>(p)); }
+};
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai_c.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai_c.h
new file mode 100644
index 0000000..b507ca5
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime-genai/ort_genai_c.h
@@ -0,0 +1,1205 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#include <stdbool.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#ifdef BUILDING_ORT_GENAI_C
+#define OGA_EXPORT __declspec(dllexport)
+#else
+#define OGA_EXPORT __declspec(dllimport)
+#endif
+#define OGA_API_CALL _stdcall
+#else
+// To make symbols visible on macOS/iOS
+#ifdef __APPLE__
+#define OGA_EXPORT __attribute__((visibility("default")))
+#else
+#define OGA_EXPORT
+#endif
+#define OGA_API_CALL
+#endif
+
+/** \addtogroup Global
+ * ONNX Runtime Generative AI C API
+ * This API is not thread safe.
+ * @{
+ */
+
+typedef enum OgaElementType {
+  OgaElementType_undefined,
+  OgaElementType_float32,     // maps to c type float
+  OgaElementType_uint8,       // maps to c type uint8_t
+  OgaElementType_int8,        // maps to c type int8_t
+  OgaElementType_uint16,      // maps to c type uint16_t
+  OgaElementType_int16,       // maps to c type int16_t
+  OgaElementType_int32,       // maps to c type int32_t
+  OgaElementType_int64,       // maps to c type int64_t
+  OgaElementType_string,      // string type (not currently supported by Oga)
+  OgaElementType_bool,        // maps to c type bool
+  OgaElementType_float16,     // IEEE 752-2008 binary16 format, 1 sign bit, 5 bit exponent, 10 bit fraction
+  OgaElementType_float64,     // maps to c type double
+  OgaElementType_uint32,      // maps to c type uint32_t
+  OgaElementType_uint64,      // maps to c type uint64_t
+  OgaElementType_complex64,   // complex with float32 real and imaginary components
+  OgaElementType_complex128,  // complex with float64 real and imaginary components
+  OgaElementType_bfloat16,    // Non-IEEE floating-point format based on IEEE754 single-precision
+} OgaElementType;
+
+typedef struct OgaResult OgaResult;
+typedef struct OgaGeneratorParams OgaGeneratorParams;
+typedef struct OgaGenerator OgaGenerator;
+typedef struct OgaRuntimeSettings OgaRuntimeSettings;
+typedef struct OgaConfig OgaConfig;
+typedef struct OgaModel OgaModel;
+// OgaSequences is an array of token arrays where the number of token arrays can be obtained using
+// OgaSequencesCount and the number of tokens in each token array can be obtained using OgaSequencesGetSequenceCount.
+typedef struct OgaSequences OgaSequences;
+typedef struct OgaTokenizer OgaTokenizer;
+typedef struct OgaTokenizerStream OgaTokenizerStream;
+typedef struct OgaTensor OgaTensor;
+typedef struct OgaImages OgaImages;
+typedef struct OgaNamedTensors OgaNamedTensors;
+typedef struct OgaMultiModalProcessor OgaMultiModalProcessor;
+typedef struct OgaAudios OgaAudios;
+typedef struct OgaStringArray OgaStringArray;
+typedef struct OgaAdapters OgaAdapters;
+typedef struct OgaEngine OgaEngine;
+typedef struct OgaRequest OgaRequest;
+typedef struct OgaStreamingProcessor OgaStreamingProcessor;
+
+//! @}
+
+/** \addtogroup Global
+ * @{
+ */
+
+/**
+ * \brief Call this on process exit to cleanly shutdown the genai library & its onnxruntime usage
+ */
+OGA_EXPORT void OGA_API_CALL OgaShutdown();
+
+/**
+ * \param[in] result OgaResult that contains the error message.
+ * \return Error message contained in the OgaResult. The const char* is owned by the OgaResult
+ *         and can will be freed when the OgaResult is destroyed.
+ */
+OGA_EXPORT const char* OGA_API_CALL OgaResultGetError(const OgaResult* result);
+
+/**
+ * \brief Control the logging behavior of the library.
+ *        If OgaSetLogString is called with name "filename", and value is a valid file path,
+ *        the library will log to that file. This will override any previously set logging destination.
+ *        If OgaSetLogString is called with name "filename" and the value provided is an empty string,
+ *        the library will log to the default destination (i.e. std::cerr) thereafter.
+ * \param[in] name logging option name, see logging.h 'struct LogItems' for the list of available options
+ * \param[in] value logging option value.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaSetLogBool(const char* name, bool value);
+OGA_EXPORT OgaResult* OGA_API_CALL OgaSetLogString(const char* name, const char* value);
+
+/**
+ * \brief Register a callback function to receive log messages from the library. If invoked, the callback will override
+ *        the previously set logging destination (e.g. a file or std::cerr).
+ * \param[in] callback function pointer to the logging callback function (use nullptr to disable callback and revert to
+ *                     the default logging destination - std::cerr).
+ * \return OgaResult containing the error message when the callback could not be set, else nullptr.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaSetLogCallback(void (*callback)(const char* string, size_t length));
+
+/**
+ * \param[in] result OgaResult to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyResult(OgaResult* result);
+OGA_EXPORT void OGA_API_CALL OgaDestroyString(const char*);
+OGA_EXPORT void OGA_API_CALL OgaDestroyNamedTensors(OgaNamedTensors*);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateSequences(OgaSequences** out);
+
+/**
+ * \param[in] sequences OgaSequences to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroySequences(OgaSequences* sequences);
+
+/**
+ * \brief Returns the number of sequences in the OgaSequences
+ * \param[in] sequences
+ * \return The number of sequences in the OgaSequences
+ */
+OGA_EXPORT size_t OGA_API_CALL OgaSequencesCount(const OgaSequences* sequences);
+
+/**
+ * \brief Appends token_cnt number of tokens from token_ptr to sequence
+ * \param[in] token_ptr constant pointer to int32 tokens
+ * \param[in] token_cnt number of tokens to read from token_ptr
+ * \param[in] sequences OgaSequences object to append the tokens to
+ * \return OgaResult containing the error message when tokens could not been added, else nullptr.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaAppendTokenSequence(const int32_t* token_ptr, size_t token_cnt, OgaSequences* sequences);
+
+/**
+ * \brief Appends the given token to the sequence at the given index.
+          If the sequence at the given index does not exist, a new sequence is
+          created at the given index if sequence_idx is equal to the current sequences count.
+ * \param[in] token token to append to the sequence
+ * \param[in] sequences OgaSequences object to append the token to
+ * \param[in] sequence_index index of the sequence to append the token to
+ * \return OgaResult containing the error message when tokens could not been added, else nullptr.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaAppendTokenToSequence(int32_t token, OgaSequences* sequences, size_t sequence_index);
+
+/**
+ * \brief Returns the number of tokens in the sequence at the given index.
+ * \param[in] sequences OgaSequences to use.
+ * \param[in] sequence_index index of the sequence to use.
+ * \return The number of tokens in the sequence at the given index
+ */
+OGA_EXPORT size_t OGA_API_CALL OgaSequencesGetSequenceCount(const OgaSequences* sequences, size_t sequence_index);
+
+/**
+ * \brief Returns a pointer to the sequence data at the given index. The number of tokens in the sequence
+ *        is given by OgaSequencesGetSequenceCount
+ * \param[in] sequences OgaSequences to use.
+ * \param[in] sequence_index index of the sequence to use.
+ * \return The pointer to the sequence data at the given index. The pointer is valid until the OgaSequences is destroyed.
+ */
+OGA_EXPORT const int32_t* OGA_API_CALL OgaSequencesGetSequenceData(const OgaSequences* sequences, size_t sequence_index);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadImage(const char* image_path, OgaImages** images);
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadImages(const OgaStringArray* image_paths, OgaImages** images);
+
+/**
+ * \brief Load multiple images from an array of byte buffers
+ * \param[in] image_data Array of byte buffers containing the image data.
+ * \param[in] image_data_sizes Array of sizes of the byte buffers.
+ * \param[in] count Number of images to load.
+ * \param[out] images The loaded images.
+ * \return OgaResult containing the error message if the loading of the images failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadImagesFromBuffers(const void** image_data, const size_t* image_data_sizes, size_t count, OgaImages** images);
+
+OGA_EXPORT void OGA_API_CALL OgaDestroyImages(OgaImages* images);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadAudio(const char* audio_path, OgaAudios** audios);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadAudios(const OgaStringArray* audio_paths, OgaAudios** audios);
+
+/**
+ * \brief Load multiple audios from an array of byte buffers
+ * \param[in] audio_data Array of byte buffers containing the audio data.
+ * \param[in] audio_data_sizes Array of sizes of the byte buffers.
+ * \param[in] count Number of audios to load.
+ * \param[out] audios The loaded audios.
+ * \return OgaResult containing the error message if the loading of the audios failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadAudiosFromBuffers(const void** audio_data, const size_t* audio_data_sizes, size_t count, OgaAudios** audios);
+
+OGA_EXPORT void OGA_API_CALL OgaDestroyAudios(OgaAudios* audios);
+
+/**
+ * \brief Creates a runtime settings instance to be used to create a model.
+ * \param[out] out The created runtime settings.
+ * \return OgaResult containing the error message if the creation of the runtime settings failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateRuntimeSettings(OgaRuntimeSettings** out);
+/**
+ * \brief Destroys the given runtime settings.
+ * \param[in] settings The runtime settings to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyRuntimeSettings(OgaRuntimeSettings* settings);
+
+/**
+ * \brief Sets a specific runtime handle for the runtime settings.
+ * \param[in] settings The runtime settings to set the device type.
+ * \param[in] handle_name The name of the handle to set for the runtime settings.
+ * \param[in] handle The value of handle to set for the runtime settings.
+ * \return OgaResult containing the error message if the setting of the device type failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRuntimeSettingsSetHandle(OgaRuntimeSettings* settings, const char* handle_name, void* handle);
+
+/**
+ * \brief Creates an OgaConfig from the given configuration directory.
+ * \param[in] config_path The path to the configuration directory. The path is expected to be encoded in UTF-8.
+ * \param[out] out The created config.
+ * \return OgaResult containing the error message if the creation of the config failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateConfig(const char* config_path, OgaConfig** out);
+
+/**
+ * \brief Clear the list of providers in the given config
+ * \param[in] config The config to clear the providers from.
+ * \return OgaResult containing the error message if the clearing of the providers failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigClearProviders(OgaConfig* config);
+
+/**
+ * \brief Add the provider at the end of the list of providers in the given config if it doesn't already exist.
+ * If it already exists, do nothing.
+ * \param[in] config The config to set the provider on.
+ * \param[in] provider The provider to set on the config.
+ * \return OgaResult containing the error message if the setting of the provider failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigAppendProvider(OgaConfig* config, const char* provider);
+
+/**
+ * \brief Set a provider option
+ * \param[in] config The config to set the provider option on.
+ * \param[in] provider The provider to set the option on.
+ * \param[in] key The key of the option to set.
+ * \param[in] value The value of the option to set.
+ * \return OgaResult containing the error message if the setting of the provider option failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigSetProviderOption(OgaConfig* config, const char* provider, const char* key, const char* value);
+
+/**
+ * \brief Add the model data to load the model from memory. Applications may call OgaConfigRemoveModelData to remove the model data
+ *        when it is no longer needed.
+ *
+ * Note that the model data is expected to be valid at least until the model is created.
+ * If using session options such as `session.use_ort_model_bytes_directly`, the model data must remain valid
+ * until the OgaModel is destroyed, as the model data will be used directly by the Ort::Session.
+ * Please see the relevant ONNX Runtime documentation for more details on this option.
+ *
+ * \param[in] config The config to add the model data to.
+ * \param[in] model_filename The name of the model file as defined in the config.
+ * \param[in] model_data The model data to add. The data is expected to be valid at least until the model is created.
+ * \param[in] model_data_length The length of the model data.
+ * \return OgaResult containing the error message if the addition of the model data failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigAddModelData(OgaConfig* config, const char* model_filename, const void* model_data, size_t model_data_length);
+
+/**
+ * \brief Remove model data previously added to the config.
+ * \param[in] config The config to remove the model data from.
+ * \param[in] model_filename The name of the model file as defined in the config.
+ * \return OgaResult containing the error message if the removal of the model data failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigRemoveModelData(OgaConfig* config, const char* model_filename);
+
+/**
+ * \brief Filter EP devices by hardware device type property with ONNXRuntime API.
+ * \param[in] config The config to overlay the JSON on.
+ * \param[in] hardware_device_type hardware device type, e.g., CPU, GPU, NPU.
+ * \return OgaResult containing the error message if the overlaying of the JSON failed.
+ *
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigSetDecoderProviderOptionsHardwareDeviceType(OgaConfig* config, const char* provider, const char* hardware_device_type);
+
+/**
+ * \brief Filter EP devices by hardware device id property with ONNXRuntime API.
+ * \param[in] config The config to overlay the JSON on.
+ * \param[in] hardware_device_type hardware device id.
+ * \return OgaResult containing the error message if the overlaying of the JSON failed.
+ *
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigSetDecoderProviderOptionsHardwareDeviceId(OgaConfig* config, const char* provider, uint32_t hardware_device_id);
+
+/**
+ * \brief Filter EP devices by hardware vendor id property with ONNXRuntime API.
+ * \param[in] config The config to overlay the JSON on.
+ * \param[in] hardware_device_type hardware vendor id.
+ * \return OgaResult containing the error message if the overlaying of the JSON failed.
+ *
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigSetDecoderProviderOptionsHardwareVendorId(OgaConfig* config, const char* provider, uint32_t hardware_vendor_id);
+
+/**
+ * \brief Clear the hardware device type property
+ * \param[in] config The config to clear hardware device type property.
+ * \return OgaResult containing the error message if the clearing failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigClearDecoderProviderOptionsHardwareDeviceType(OgaConfig* config, const char* provider);
+
+/**
+ * \brief Clear the hardware device id property
+ * \param[in] config The config to clear hardware device id property.
+ * \return OgaResult containing the error message if the clearing failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigClearDecoderProviderOptionsHardwareDeviceId(OgaConfig* config, const char* provider);
+
+/**
+ * \brief Clear the hardware vendor id property
+ * \param[in] config The config to clear hardware vendor id property.
+ * \return OgaResult containing the error message if the clearing failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigClearDecoderProviderOptionsHardwareVendorId(OgaConfig* config, const char* provider);
+
+/**
+ * \brief Overlay JSON on top of config file
+ * \param[in] config The config to overlay the JSON on.
+ * \param[in] json The JSON to overlay on the config.
+ * \return OgaResult containing the error message if the overlaying of the JSON failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaConfigOverlay(OgaConfig* config, const char* json);
+
+/**
+ * \brief Creates a model from the given configuration directory.
+ * \param[in] config_path The path to the model configuration directory. The path is expected to be encoded in UTF-8.
+ * \param[out] out The created model.
+ * \return OgaResult containing the error message if the model creation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateModel(const char* config_path, OgaModel** out);
+
+/**
+ * \brief Creates a model from the given configuration.
+ * \param[in] config The configuration to use for the model.
+ * \param[out] out The created model.
+ * \return OgaResult containing the error message if the model creation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateModelFromConfig(const OgaConfig* config, OgaModel** out);
+
+/**
+ * \brief Creates a model from the given configuration directory, runtime settings and device type.
+ * \param[in] config_path The path to the model configuration directory. The path is expected to be encoded in UTF-8.
+ * \param[in] settings The runtime settings to use for the model.
+ * \param[out] out The created model.
+ * \return OgaResult containing the error message if the model creation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateModelWithRuntimeSettings(const char* config_path, const OgaRuntimeSettings* settings, OgaModel** out);
+
+/**
+ * \brief Returns the type of the model.
+ * \param[in] model The model to get the type from.
+ * \param[out] out The type of the model. Must be destroyed with OgaDestroyString
+ * \return OgaResult containing the error message if the getting of the model type failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaModelGetType(const OgaModel* model, const char** out);
+
+/**
+ * \brief Returns the device type of the model.
+ * \param[in] model The model to get the device type from.
+ * \param[out] out The device type of the model. Must be destroyed with OgaDestroyString
+ * \return OgaResult containing the error message if the getting of the device type failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaModelGetDeviceType(const OgaModel* model, const char** out);
+
+/**
+ * \brief Destroys the given config
+ * \param[in] config The config to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyConfig(OgaConfig* config);
+
+/**
+ * \brief Destroys the given model.
+ * \param[in] model The model to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyModel(OgaModel* model);
+
+/**
+ * \brief Creates a OgaGeneratorParams from the given model.
+ * \param[in] model The model to use for generation.
+ * \param[out] out The created generator params.
+ * \return OgaResult containing the error message if the generator params creation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateGeneratorParams(const OgaModel* model, OgaGeneratorParams** out);
+
+/**
+ * \brief Destroys the given generator params.
+ * \param[in] params The generator params to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyGeneratorParams(OgaGeneratorParams* params);
+
+/**
+ * \brief Set a numerical value for a search parameter
+ * \param[in] params The generator params to set.
+ * \param[in] name The name of the search parameter.
+ * \param[in] value The value of the search parameter.
+ * \return OgaResult containing the error message if setting the generator params failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetSearchNumber(OgaGeneratorParams* params, const char* name, double value);
+
+/**
+ * \brief Set a boolean value for a search parameter
+ * \param[in] params The generator params to set.
+ * \param[in] name The name of the search parameter.
+ * \param[in] value The value of the search parameter.
+ * \return OgaResult containing the error message if setting the generator params failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetSearchBool(OgaGeneratorParams* params, const char* name, bool value);
+
+/**
+ * \brief Sets the guidance type and data for the Generator params
+ * \param[in] params The generator params to set the guidance on
+ * \param[in] type The type of the guidance. Currently, we support json_schema, regex and lark_grammar
+ * \param[in] data The input string, which is the guidance data. Examples are present in test/test_models/grammars folder
+ * \param[in] enable_ff_tokens Whether to enable ff_tokens generation. This feature allows guidance to force-forward tokens that satisfy input grammar without calling model, hence speeding up generation process. Only valid when guidance type is set and batch_size is 1 and beam_size is 1.
+ * \return OgaResult containing the error message if the setting of the guidance failed
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetGuidance(OgaGeneratorParams* params, const char* type, const char* data, bool enable_ff_tokens);
+
+/**
+ * \brief Get a numerical value for a search parameter
+ * \param[in] params The generator params to set.
+ * \param[in] name The name of the search parameter.
+ * \param[out] value The value of the search parameter.
+ * \return OgaResult containing the error message if setting the generator params failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsGetSearchNumber(const OgaGeneratorParams* params, const char* name, double* value);
+
+/**
+ * \brief Get a boolean value for a search parameter
+ * \param[in] params The generator params to set.
+ * \param[in] name The name of the search parameter.
+ * \param[out] value The value of the search parameter.
+ * \return OgaResult containing the error message if setting the generator params failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsGetSearchBool(const OgaGeneratorParams* params, const char* name, bool* value);
+
+/**
+ * \brief Creates a generator from the given model and generator params.
+ * \param[in] model The model to use for generation.
+ * \param[in] params The parameters to use for generation.
+ * \param[out] out The created generator.
+ * \return OgaResult containing the error message if the generator creation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateGenerator(const OgaModel* model, const OgaGeneratorParams* params, OgaGenerator** out);
+
+/**
+ * \brief Destroys the given generator.
+ * \param[in] generator The generator to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyGenerator(OgaGenerator* generator);
+
+/**
+ * \brief Returns true if the generator has finished generating all the sequences.
+ * \param[in] generator The generator to check if it is done with generating all sequences.
+ * \return True if the generator has finished generating all the sequences, false otherwise.
+ */
+OGA_EXPORT bool OGA_API_CALL OgaGenerator_IsDone(OgaGenerator* generator);
+
+/**
+ * \brief Returns true if the session has been terminated.
+ * \param[in] generator The generator to add the inputs to.
+ * \return True if the session has been terminated, false otherwise.
+ */
+OGA_EXPORT bool OGA_API_CALL OgaGenerator_IsSessionTerminated(const OgaGenerator* generator);
+
+/**
+ * \brief For additional model inputs that genai does not handle, this lets the user set their values. For example LoRA models handle
+ * fine tuning through model inputs. This lets the user supply the fine tuning inputs, while genai handles the standard inputs.
+ * \param[in] generator The generator to add the inputs to.
+ * \param[in] name Name of the model input (this must match the model's input name)
+ * \param[in] tensor The OgaTensor of the input data
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_SetModelInput(OgaGenerator* generator, const char* name, OgaTensor* tensor);
+
+/**
+ * \brief For additional model inputs that genai does not handle, this lets the user set their values.
+ * \param[in] generator The generator to add the inputs to.
+ * \param[in] named_tensors The named tensors to set the inputs as.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_SetInputs(OgaGenerator* generator, const OgaNamedTensors* named_tensors);
+
+/**
+ * \brief Adds the input ids to the generator. The input ids are used to seed the generation.
+ * \param[in] generator The generator to add the input ids to.
+ * \param[in] p_sequences The input id sequences.
+ * \return OgaResult containing the error message if the setting of the input ids failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_AppendTokenSequences(OgaGenerator* generator, const OgaSequences* p_sequences);
+
+/**
+ * \brief Adds the input ids to the generator. The input ids are used to seed the generation.
+ * \param[in] generator The generator to add the input ids to.
+ * \param[in] input_ids The input ids to add.
+ * \param[in] input_ids_count The number of input ids to add (batch_size * sequence_length).
+ * \return OgaResult containing the error message if the setting of the input ids failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_AppendTokens(OgaGenerator* generator, const int32_t* input_ids, size_t input_ids_count);
+
+/**
+ * \brief Returns the number of tokens in the generator
+ * \param[in] generator The generator containing the appended tokens.
+ * \return The number of tokens that have been added.
+ */
+OGA_EXPORT size_t OGA_API_CALL OgaGenerator_TokenCount(const OgaGenerator* generator);
+
+/**
+ * \brief Computes the logits from the model based on the input ids and the past state. The computed logits are stored in the generator.
+ * \param[in] generator The generator to compute the logits for.
+ * \return OgaResult containing the error message if the computation of the logits failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GenerateNextToken(OgaGenerator* generator);
+
+/**
+ * \brief Returns a pointer to the next tokens generated by the model. The out_count will match the batch size
+ * \param[in] generator The generator to get the next tokens from.
+ * \param[out] out The pointer to the next tokens generated by the model. The pointer is valid until the next OgaGenerator call
+ * \param[out] out_count The number of tokens in the out array.
+ * \return OgaResult containing the error message if the getting of the next tokens failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GetNextTokens(const OgaGenerator* generator, const int32_t** out, size_t* out_count);
+
+/**
+ * \brief Set a runtime option's name and value.
+ * \param[in] generator The generator to rewind to the given length.
+ * \param[in] key The runtime option's name
+ * \param[in] value The runtime option's value
+ * \return OgaResult containing the error message if setting the runtime option failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_SetRuntimeOption(OgaGenerator* generator, const char* key, const char* value);
+
+/**
+ * \brief Rewinds the generator to the given length. This is useful when the user wants to rewind the generator to a specific length
+ *        and continue generating from that point.
+ * \param[in] generator The generator to rewind to the given length.
+ * \param[in] new_length The desired length in tokens after rewinding.
+ * \return OgaResult containing the error message if the rewinding failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_RewindTo(OgaGenerator* generator, size_t new_length);
+
+/**
+ * \brief Returns a copy of the model input identified by the given name as an OgaTensor on CPU. The buffer is owned by returned OgaTensor
+ *       and will be released when the OgaTensor is destroyed
+ * \param[in] generator The generator to run the GetInput on the name provided and the out pointer to store the input.
+ * \param[in] name The name of the input tensor.
+ * \param[out] out The returned OgaTensor.
+ * \return OgaResult containing the error message if the computation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GetInput(const OgaGenerator* generator, const char* name, OgaTensor** out);
+
+/**
+ * \brief Returns a copy of the model output identified by the given name as an OgaTensor on CPU. The buffer is owned by returned OgaTensor
+ *       and will be released when the OgaTensor is destroyed
+ * \param[in] generator The generator to run the GetOutput on the name provided and the out pointer to store the output.
+ * \param[in] name The name of the output tensor.
+ * \param[out] out The returned OgaTensor.
+ * \return OgaResult containing the error message if the computation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GetOutput(const OgaGenerator* generator, const char* name, OgaTensor** out);
+
+/**
+ * \brief Returns a copy of the logits from the model as an OgaTensor on CPU. The buffer is owned by returned OgaTensor
+ *        and will be released when the OgaTensor is destroyed
+ * \param[in] generator The generator get the logits from
+ * \param[out] out The OgaTensor containing the logits, it only contains the last token logits even in prompt processing
+ * \return OgaResult containing the error message if the computation failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GetLogits(OgaGenerator* generator, OgaTensor** out);
+
+/**
+ * \brief Sets the logits to the generator. This is useful when the user wants to set the logits to a specific value
+ *        for example when doing guided generation.
+ * \param[in] generator The generator to set the logits on
+ * \param[in] tensor The OgaTensor containing the logits, it must have the same shape as the logits returned by GetLogits
+ * which is the last token logits.
+ * \return OgaResult containing the error message if the setting of the logits failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_SetLogits(OgaGenerator* generator, OgaTensor* tensor);
+
+/*
+ * \brief Returns the number of tokens in the sequence at the given index.
+ * \param[in] generator The generator to get the count of the tokens for the sequence at the given index.
+ * \param[in] index The given index.
+ * \return The number tokens in the sequence at the given index.
+ */
+OGA_EXPORT size_t OGA_API_CALL OgaGenerator_GetSequenceCount(const OgaGenerator* generator, size_t index);
+
+/**
+ * \brief Returns a pointer to the sequence data at the given index. The number of tokens in the sequence
+ *        is given by OgaGenerator_GetSequenceCount
+ * \param[in] generator The generator to get the sequence data for the sequence at the given index.
+ * \param[in] index The given index.
+ * \return The pointer to the sequence data at the given index. The sequence data is owned by the OgaGenerator
+ *         and will be freed when the OgaGenerator is destroyed. The caller must copy the data if it needs to
+ *         be used after the OgaGenerator is destroyed.
+ */
+OGA_EXPORT const int32_t* OGA_API_CALL OgaGenerator_GetSequenceData(const OgaGenerator* generator, size_t index);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizer(const OgaModel* model, OgaTokenizer** out);
+OGA_EXPORT void OGA_API_CALL OgaDestroyTokenizer(OgaTokenizer*);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateMultiModalProcessor(const OgaModel* model, OgaMultiModalProcessor** out);
+
+OGA_EXPORT void OGA_API_CALL OgaDestroyMultiModalProcessor(OgaMultiModalProcessor* processor);
+
+/**
+ * Updates tokenizer options for the given OgaTokenizer instance.
+ * The provided keys and values must be null-terminated UTF-8 strings.
+ *
+ * This function allows updating tokenizer behavior at runtime by passing
+ * key/value string pairs. Each key corresponds to a configurable tokenizer
+ * option. Both keys and values must remain valid for the duration of this call.
+ *
+ * @param tokenizer Pointer to the OgaTokenizer whose options will be updated.
+ * @param keys Array of option key strings.
+ * @param values Array of corresponding option value strings (same length as keys).
+ * @param num_options Number of key/value pairs provided.
+ *
+ * @return nullptr on success, or an OgaResult* describing the error.
+ *         The returned OgaResult* (if not null) must be freed with OgaDestroyResult.
+ *
+ * Supported options:
+ *
+ * - `add_special_tokens`
+ *   - Purpose: Controls whether to add special tokens (e.g., BOS/EOS) during tokenization.
+ *   - Values: `"true"` / `"false"` or `"1"` / `"0"`.
+ *   - Default: `"false"`. This is the default value set by ORT GenAI prior to any options updating.
+ *
+ * - `skip_special_tokens`
+ *   - Purpose: Controls whether to remove special tokens during detokenization.
+ *   - Values: `"true"` / `"false"` or `"1"` / `"0"`.
+ *   - Default: `"true"`. This is the default value set by ORT GenAI prior to any options updating.
+ *
+ * Future tokenizer options may be added without changing this API signature.
+ * Passing unknown keys will result in an error.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaUpdateTokenizerOptions(
+    OgaTokenizer* tokenizer,
+    const char* const* keys,
+    const char* const* values,
+    size_t num_options);
+
+/**
+ * \brief Return the int representation of the BOS token
+ * \param[in] tokenizer The tokenizer to read from
+ * \param[out] token_id The BOS token id
+ * \return OgaResult containing the error message if returning the BOS token id fails.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerGetBosTokenId(const OgaTokenizer* tokenizer, int32_t* token_id);
+
+/**
+ * \brief Return an array containing the int representations of the EOS token ids. The array is owned by the tokenizer and will be freed when the tokenizer is destroyed.
+ * \param[in] tokenizer The tokenizer to read from
+ * \param[out] eos_token_ids The array of EOS token ids
+ * \param[out] token_count The length of the array
+ * \return OgaResult containing the error message if returning the EOS token ids fails.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerGetEosTokenIds(const OgaTokenizer* tokenizer, const int32_t** eos_token_ids, size_t* token_count);
+
+/**
+ * \brief Return the int representation of the PAD token
+ * \param[in] tokenizer The tokenizer to read from
+ * \param[out] token_id The PAD token id
+ * \return OgaResult containing the error message if returning the PAD token id fails.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerGetPadTokenId(const OgaTokenizer* tokenizer, int32_t* token_id);
+
+/**
+ * Encodes a single string and adds the encoded sequence of tokens to the OgaSequences. The OgaSequences must be freed with OgaDestroySequences
+ * when it is no longer needed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerEncode(const OgaTokenizer*, const char* str, OgaSequences* sequences);
+
+/**
+ * Batch encode an array of strings and return a single tensor output
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerEncodeBatch(const OgaTokenizer*, const char** strings, size_t count, OgaTensor** out);
+
+/**
+ * Batch decode a tensor of token ids and return an array of strings
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerDecodeBatch(const OgaTokenizer*, const OgaTensor* tensor, OgaStringArray** out);
+
+/**
+ * \brief Converts the given string to a single token id.
+ * \param[in] tokenizer The tokenizer to use to convert the string to a token id.
+ * \param[in] str The string to convert to a token id.
+ * \param[in] token_id The converted token id.
+ * \return OgaResult containing the error message if the conversion of the string to a token id failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerToTokenId(const OgaTokenizer* tokenizer, const char* str, int32_t* token_id);
+
+/**
+ * \brief Process images with input prompt
+ * \param[in] processor The processor to use to process the images and prompt.
+ * \param[in] prompt The prompt to use with the images.
+ * \param[in] images The images to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessImages(const OgaMultiModalProcessor*, const char* prompt, const OgaImages* images, OgaNamedTensors** input_tensors);
+
+/**
+ * \brief Process images with input prompts
+ * \param[in] processor The processor to use to process the images and prompts.
+ * \param[in] prompts The prompts to use with the images.
+ * \param[in] images The images to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessImagesAndPrompts(const OgaMultiModalProcessor*, const OgaStringArray* prompts, const OgaImages* images, OgaNamedTensors** input_tensors);
+
+/**
+ * \brief Process audios with input prompt
+ * \param[in] processor The processor to use to process the audios and prompt.
+ * \param[in] prompt The prompt to use with the audios.
+ * \param[in] audios The audios to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessAudios(const OgaMultiModalProcessor*, const char* prompt, const OgaAudios* audios, OgaNamedTensors** input_tensors);
+
+/**
+ * \brief Process audios with input prompts
+ * \param[in] processor The processor to use to process the audios and prompts.
+ * \param[in] prompts The prompts to use with the audios.
+ * \param[in] audios The audios to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessAudiosAndPrompts(const OgaMultiModalProcessor*, const OgaStringArray* prompts, const OgaAudios* audios, OgaNamedTensors** input_tensors);
+
+/**
+ * \brief Process images and/or audios with input prompt
+ * \param[in] processor The processor to use to process the images, audios, and/or prompt.
+ * \param[in] prompt The prompt to use with the images and/or audios.
+ * \param[in] images The images to process.
+ * \param[in] audios The audios to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessImagesAndAudios(const OgaMultiModalProcessor*, const char* prompt, const OgaImages* images, const OgaAudios* audios, OgaNamedTensors** input_tensors);
+
+/**
+ * \brief Process images and/or audios with input prompts
+ * \param[in] processor The processor to use to process the images, audios, and/or prompts.
+ * \param[in] prompts The prompts to use with the images and/or audios.
+ * \param[in] images The images to process.
+ * \param[in] audios The audios to process.
+ * \return OgaResult containing the named tensors for the processed inputs.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessImagesAndAudiosAndPrompts(const OgaMultiModalProcessor*, const OgaStringArray* prompts, const OgaImages* images, const OgaAudios* audios, OgaNamedTensors** input_tensors);
+
+/** Decode a single token sequence and returns a null terminated utf8 string. out_string must be freed with OgaDestroyString
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerDecode(const OgaTokenizer*, const int32_t* tokens, size_t token_count, const char** out_string);
+OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorDecode(const OgaMultiModalProcessor*, const int32_t* tokens, size_t token_count, const char** out_string);
+
+/**
+ * @brief Applies a chat template to input messages
+ *
+ * This function processes the specified template with the provided input using the
+ * tokenizer, and outputs the resulting string. Optionally, it can include a
+ * generation prompt in the output.
+ *
+ * \param[in] tokenizer OgaTokenizer used for template processing.
+ * \param[in] template_str Null-terminated string representing the chat template. Use nullptr to fall back to the default chat template from the tokenizer config.
+ * \param[in] messages Null-terminated string containing the input messages to be processed.
+ * \param[in] tools Null-terminated string containing the chat function calls if any. Use nullptr if none.
+ * \param[in] add_generation_prompt Indicates whether to add a generation prompt to the output.
+ * \param[out] out_string Pointer to where the output will be stored. The returned pointer must be freed with OgaDestroyString
+ * \return OgaResult* containing the error message if the function fails
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerApplyChatTemplate(const OgaTokenizer*, const char* template_str, const char* messages, const char* tools, bool add_generation_prompt, const char** out_string);
+
+/** OgaTokenizerStream is to decoded token strings incrementally, one token at a time.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizerStream(const OgaTokenizer*, OgaTokenizerStream** out);
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizerStreamFromProcessor(const OgaMultiModalProcessor*, OgaTokenizerStream** out);
+OGA_EXPORT void OGA_API_CALL OgaDestroyTokenizerStream(OgaTokenizerStream*);
+
+/**
+ * Decode a single token in the stream. If this results in a word being generated, it will be returned in 'out'.
+ * The caller is responsible for concatenating each chunk together to generate the complete result.
+ * 'out' is valid until the next call to OgaTokenizerStreamDecode or when the OgaTokenizerStream is destroyed
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerStreamDecode(OgaTokenizerStream*, int32_t token, const char** out);
+
+/** Create an OgaTensor from an optional user owned buffer. If a user owned buffer is supplied, the OgaTensor does
+ * not own the memory (as it has no way to free it) so the 'data' parameter must be valid for the lifetime of the OgaTensor.
+ *  If the 'data' parameter is nullptr, the OgaTensor will allocate its own memory.
+ *
+ * \param[in] data User supplied memory pointer, if non nullptr it must remain valid for lifetime of the OgaTensor
+ * \param[in] shape_dims Pointer to array of int64_t values that define the tensor shape, example [1 20 30] would be equivalent to a C array of [1][20][30]
+ * \param[in] shape_dims_count Count of elements in the shape_dims array
+ * \param[in] element_type The data type that 'data' points to.
+ * \param[out] out Writes the newly created OgaTensor into this, must be destroyed with OgaDestroyTensor
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTensorFromBuffer(void* data, const int64_t* shape_dims, size_t shape_dims_count, OgaElementType element_type, OgaTensor** out);
+
+OGA_EXPORT void OGA_API_CALL OgaDestroyTensor(OgaTensor* tensor);
+
+/** Get the OgaElementType of the data stored in the OgaTensor
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetType(OgaTensor*, OgaElementType* out);
+
+/** Get the number of dimensions of the OgaTensor's shape, typically used to allocate a buffer of this size then calling OgaTensorGetShape with it
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetShapeRank(OgaTensor*, size_t* out);
+
+/** Copies the shape dimensions into the shape_dims parameters. shape_dims_count must match the value returned by OgaTensorGetShapeRank
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetShape(OgaTensor*, int64_t* shape_dims, size_t shape_dims_count);
+
+/** A pointer to the tensor data, it is typically cast into the actual data type of the tensor
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetData(OgaTensor*, void** out);
+
+/** \brief Create an OgaNamedTensors
+ * \param[out] out The created OgaNamedTensors
+ * \return OgaResult containing the error message if the creation of the OgaNamedTensors failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateNamedTensors(OgaNamedTensors** out);
+
+/** \brief Lookup a tensor in a NamedTensor set by name
+ * \param[in] named_tensors The named tensors to search
+ * \param[in] name The name of the tensor to find
+ * \param[out] out The tensor with the given name
+ * \return OgaResult containing the error message if the tensor with the given name could not be found.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaNamedTensorsGet(OgaNamedTensors* named_tensors, const char* name, OgaTensor** out);
+
+/** \brief Set a tensor in a NamedTensor set by name
+ * \param[in] named_tensors The named tensors to set the tensor
+ * \param[in] name The name of the tensor to set
+ * \param[in] tensor The tensor to set
+ * \return OgaResult containing the error message if the tensor with the given name could not be set.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaNamedTensorsSet(OgaNamedTensors* named_tensors, const char* name, OgaTensor* tensor);
+
+/** \brief Delete a tensor in a NamedTensor set by name
+ * \param[in] named_tensors The named tensors to remove the tensor
+ * \param[in] name The name of the tensor to remove
+ * \return OgaResult containing the error message if the tensor with the given name could not be removed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaNamedTensorsDelete(OgaNamedTensors* named_tensors, const char* name);
+
+/** \brief Get the number of tensors in the NamedTensors
+ * \param[in] named_tensors The named tensors to get the count of the tensors
+ * \param[out] out The number of tensors in the NamedTensors
+ * \return OgaResult containing the error message if the getting of the count of the tensors failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaNamedTensorsCount(const OgaNamedTensors* named_tensors, size_t* out);
+
+/** \brief Return an OgaStringArray of the names of the tensors in an OgaNamedTensors object
+ * \param[in] named_tensors The named tensors to get the names of the tensors
+ * \param[out] out The OgaStringArray containing the names of the tensors
+ * \return OgaResult containing the error message if the getting of the names of the tensors failed.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaNamedTensorsGetNames(const OgaNamedTensors* named_tensors, OgaStringArray** out);
+
+OGA_EXPORT OgaResult* OGA_API_CALL OgaSetCurrentGpuDeviceId(int device_id);
+OGA_EXPORT OgaResult* OGA_API_CALL OgaGetCurrentGpuDeviceId(int* device_id);
+
+/**
+ * \brief Creates an object of type OgaStringArray.
+ * \return The result of the operation. If the operation is successful, a nullptr is returned.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateStringArray(OgaStringArray** out);
+
+/**
+ * \brief Creates an object of type OgaStringArray from the given strings.
+ * \return The result of the operation. If the operation is successful, a nullptr is returned.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateStringArrayFromStrings(const char* const* strs, size_t count, OgaStringArray** out);
+
+/**
+ * \brief Destroys OgaStringArray.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyStringArray(OgaStringArray* string_array);
+
+/**
+ * \brief Adds the given string to the string_array.
+ * \param[inout] string_array The string array to which the string is to be added
+ * \param[in] str The string to be added to the string_array.
+ * \return The result of the operation. If the operation is successful, a nullptr is returned.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStringArrayAddString(OgaStringArray* string_array, const char* str);
+
+/**
+ * \brief Gets the number of strings in the string_array.
+ * \param[in] string_array The OgaStringArray object to get the count of the strings.
+ * \param[out] out The number of strings in the string_array.
+ * \return The result of the operation. If the operation is successful, a nullptr is returned.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStringArrayGetCount(const OgaStringArray* string_array, size_t* out);
+
+/**
+ * \brief Get a string from a string_array
+ * \param[in] string_array The OgaStringArray object to get the string from.
+ * \param[in] index The index of the string to get.
+ * \return The string at the given index.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStringArrayGetString(const OgaStringArray* string_array, size_t index, const char** out);
+
+/**
+ * \brief Creates the OgaAdapters object that manages the adapters.
+          - The OgaAdapters object is used to load all the model adapters.
+          - It is responsible for reference counting the loaded adapters.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateAdapters(const OgaModel* model, OgaAdapters** out);
+
+/**
+ * \brief Destroys the OgaAdapters object.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyAdapters(OgaAdapters* adapters);
+
+/**
+ * \brief Loads the model adapter from the given adapter file path and adapter name.
+ * \param[in] adapters The OgaAdapters object to load the adapter.
+ * \param[in] adapter_file_path The file path of the adapter to load.
+ * \param[in] adapter_name A unique identifier for the adapter chosed by the function invoker.
+ *                         This name is used for querying the adapter.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadAdapter(OgaAdapters* adapters, const char* adapter_file_path,
+                                                  const char* adapter_name);
+
+/**
+ * \brief Unloads the adapter with the given identifier from the previosly loaded adapters.
+          If the adapter is not found, or if it cannot be unloaded (when it is in use), an error is returned.
+ * \param[in] adapters The OgaAdapters object to unload the adapter.
+ * \param[in] adapter_name The name of the adapter to unload.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaUnloadAdapter(OgaAdapters* adapters, const char* adapter_name);
+
+/**
+ * \brief Sets the adapter with the given adapter name as active for the given OgaGenerator object.
+ * \param[in] generator The OgaGenerator object to set the active adapter.
+ * \param[in] adapters The OgaAdapters object that manages the model adapters.
+ * \param[in] adapter_name The name of the adapter to set as active.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaSetActiveAdapter(OgaGenerator* generator, OgaAdapters* adapters,
+                                                       const char* adapter_name);
+
+/**
+ * \brief Creates an OgaEngine object from the given model.
+ *
+ * The OgaEngine is responsible for managing and scheduling multiple requests, executing model inference,
+ * and coordinating batching, caching, and resource management for efficient processing. This function
+ * initializes a new engine instance using the provided model, allowing requests to be added, removed, and
+ * processed through the engine's API. The engine must be destroyed with OgaDestroyEngine when no longer needed.
+ *
+ * \param[in] model The model to use for the engine. The model must remain valid for the lifetime of the engine.
+ * \param[out] out Pointer to the created engine instance. On success, *out will be set to the new engine object.
+ * \return OgaResult containing the error message if the engine creation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateEngine(OgaModel* model, OgaEngine** out);
+
+/**
+ * \brief Destroys the given engine.
+ * \param[in] engine The engine to be destroyed.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyEngine(OgaEngine* engine);
+
+/**
+ * \brief Returns a ready request of runs one step of the OgaEngine if there are pending requests.
+ *
+ * This function advances the state of the engine by processing a subset of the currently pending requests.
+ * It schedules and executes model inference for requests that are ready, updates their state with the generated results,
+ * and manages batching and resource allocation as needed. This function should be called repeatedly (e.g., in a loop)
+ * to ensure all requests are processed efficiently. It is a core part of the engine's request processing pipeline.
+ * If the engine has ready requests from a previous call, it will return one of them in the request parameter.
+ * If there are no ready requests, a new subset of requests will be scheduled for processing and the request parameter
+ * will be set to the first request from this subset that is ready to be queried for results.
+ *
+ * \param[in] engine The engine instance to run a processing step on.
+ * \param[out] request A request that has been processed by the engine and is ready to be queried for results.
+ *                     If the engine has no ready requests, this will be set to a nullptr.
+ * \return OgaResult containing the error message if the operation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaEngineStep(OgaEngine* engine, OgaRequest** request);
+
+/**
+ * \brief Checks if the engine has any pending requests to process.
+ *
+ * This function queries the OgaEngine to determine whether there are any requests that have not yet been fully processed.
+ *
+ * \param[in] engine The engine instance to check for pending requests.
+ * \param[out] out Pointer to a boolean value that will be set to true if there are pending requests, or false otherwise.
+ * \return OgaResult containing the error message if the operation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaEngineHasPendingRequests(OgaEngine* engine, bool* out);
+
+/**
+ * \brief Adds a request to the OgaEngine for processing.
+ *
+ * This function submits a new request to the engine, which will then be processed in subsequent calls to OgaEngineStep.
+ * The request must be created using OgaCreateRequest and should contain the necessary parameters for model inference.
+ *
+ * \param[in] engine The engine instance to which the request is being added.
+ * \param[in] request The request to add to the engine. The request must remain valid until it is removed or processed.
+ * \return OgaResult containing the error message if the operation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaEngineAddRequest(OgaEngine* engine, OgaRequest* request);
+
+/**
+ * \brief Removes a request from the OgaEngine.
+ *
+ * This function removes a request from the engine, allowing it to be cleaned up. The request must have been previously added
+ * to the engine using OgaEngineAddRequest. After this call, the request will no longer be processed by the engine.
+ *
+ * \param[in] engine The engine instance from which the request is being removed.
+ * \param[in] request The request to remove from the engine. The request must have been previously added to the engine.
+ * \return OgaResult containing the error message if the operation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaEngineRemoveRequest(OgaEngine* engine, OgaRequest* request);
+
+/**
+ * \brief Creates a new request for the OgaEngine.
+ *
+ * This function initializes a new request object that can be used to submit input sequences for model inference.
+ * Once added to the engine, the request will be processed by the engine in subsequent calls to OgaEngineStep.
+ *
+ * \param[in] params The parameters for the generator, such as temperature, top-k, etc.
+ * \param[out] out Pointer to the created request instance. On success, *out will be set to the new request object.
+ * \return OgaResult containing the error message if the request creation failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateRequest(OgaGeneratorParams* params, OgaRequest** out);
+
+/**
+ * \brief Adds input sequences to the request.
+ *
+ * This function sets the input sequences for the request. The input sequences are used to seed the generation process.
+ * The request must have been created using OgaCreateRequest before calling this function.
+ *
+ * \param[in] request The request to set the input sequences on.
+ * \param[in] tokens The input sequences to set on the request.
+ * \return OgaResult containing the error message if the setting of the input sequences failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestAddTokens(OgaRequest* request, const OgaSequences* tokens);
+
+/**
+ * \brief Destroys the given request.
+ *
+ * This function cleans up the resources associated with the request, including any input sequences and parameters.
+ * It should be called when the request is no longer needed, either after it has been processed.
+ *
+ * \param[in] request The request to be destroyed. The request must have been created using OgaCreateRequest.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyRequest(OgaRequest* request);
+
+/**
+ * \brief Sets custom user data on the request.
+ *
+ * This function sets custom user data on the request that is opaque to the request. It can be queried
+ * later using OgaRequestGetOpaqueData. This is useful for associating additional information with the
+ * request that may be actionable by the user or application logic.
+ *
+ * \param[in] request The request to set the input sequences on.
+ * \param[in] tokens The input sequences to set on the request.
+ * \return OgaResult containing the error message if the setting of the input sequences failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestSetOpaqueData(OgaRequest* request, void* opaque_data);
+
+/**
+ * \brief Gets the custom user data from the request.
+ *
+ * This function retrieves the custom user data that was set on the request using OgaRequestSetOpaqueData.
+ * The user data is opaque to the request and can be used to store additional information that may be
+ * useful for the application logic.
+ *
+ * \param[in] request The request to get the opaque data from.
+ * \param[out] opaque_data Pointer to where the opaque data will be stored.
+ * \return OgaResult containing the error message if the getting of the opaque data failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestGetOpaqueData(OgaRequest* request, void** opaque_data);
+
+/**
+ * \brief Checks if the request has any unseen tokens.
+ *
+ * This function checks if the request has any unseen tokens that have not yet been queried by the user
+ * or application yet. Unseen tokens are those that have been generated by the model but not yet
+ * retrieved by the user.
+ *
+ * \param[in] request The request to check for unseen tokens.
+ * \param[out] out Boolean flag that will be set to true if there are unseen tokens, or false otherwise.
+ * \return OgaResult containing the error message if the setting of the input sequences failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestHasUnseenTokens(const OgaRequest* request, bool* out);
+
+/**
+ * \brief Gets an unseen token from the request.
+ *
+ * This function retrieves the next unseen token from the request. If there are no unseen tokens,
+ * it will return an error. The unseen token is a token that has been generated by the model but
+ * has not yet been queried by the user.
+ *
+ * \param[in] request The request to get the unseen token from.
+ * \param[out] out Pointer to where the unseen token will be stored.
+ * \return OgaResult containing the error message if the getting of the unseen token failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestGetUnseenToken(OgaRequest* request, int32_t* out);
+
+/**
+ * \brief Checks if the request is done processing.
+ *
+ * This function checks if the request has finished processing. The request is done when one of the termination
+ * conditions has been reached (e.g. end of sequence token is encountered or the request was cancelled).
+ * If the request is done, it will return true; otherwise, it will return false.
+ *
+ * \param[in] request The request to check if it is done.
+ * \param[out] out Boolean flag that will be set to true if the request is done, or false otherwise.
+ * \return OgaResult containing the error message if the checking of the request status failed, or nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaRequestIsDone(const OgaRequest* request, bool* out);
+
+/**
+ * \brief Registers an execution provider library with ONNXRuntime API.
+ * \param registration_name name for registration.
+ * \param path provider path.
+ *
+ */
+OGA_EXPORT void OGA_API_CALL OgaRegisterExecutionProviderLibrary(const char* registration_name, const char* library_path);
+
+/**
+ * \brief Unregisters an execution provider library with ONNXRuntime API.
+ * \param registration_name name for registration.
+ *
+ */
+OGA_EXPORT void OGA_API_CALL OgaUnregisterExecutionProviderLibrary(const char* registration_name);
+
+/**
+ * \brief Creates a StreamingProcessor for mel spectrogram extraction from raw audio.
+ * \param[in] model The model to create the processor for (must be nemotron_speech type).
+ * \param[out] out Pointer to store the created StreamingProcessor instance.
+ * \return OgaResult on error, nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateStreamingProcessor(OgaModel* model, OgaStreamingProcessor** out);
+
+/**
+ * \brief Process a chunk of raw PCM audio and return a NamedTensors if a full chunk is ready.
+ * \param[in] processor The StreamingProcessor instance.
+ * \param[in] audio_data Pointer to float32 PCM audio samples (mono, model sample rate).
+ * \param[in] num_samples Number of audio samples.
+ * \param[out] out Pointer to store the NamedTensors. Set to nullptr if not enough audio yet.
+ *                  Caller must free with OgaDestroyNamedTensors.
+ * \return OgaResult on error, nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStreamingProcessorProcess(OgaStreamingProcessor* processor, const float* audio_data, size_t num_samples, OgaNamedTensors** out);
+
+/**
+ * \brief Flush remaining buffered audio (pads with silence).
+ * \param[in] processor The StreamingProcessor instance.
+ * \param[out] out Pointer to store the NamedTensors. Set to nullptr if buffer was empty.
+ * \return OgaResult on error, nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStreamingProcessorFlush(OgaStreamingProcessor* processor, OgaNamedTensors** out);
+
+/**
+ * \brief Destroy a StreamingProcessor instance.
+ * \param[in] processor The StreamingProcessor instance to destroy.
+ */
+OGA_EXPORT void OGA_API_CALL OgaDestroyStreamingProcessor(OgaStreamingProcessor* processor);
+
+/**
+ * \brief Set a processor option as a key-value pair.
+ *        Supported keys: "use_vad", "vad_threshold", "silence_duration_ms", "prefix_padding_ms".
+ * \param[in] processor The StreamingProcessor instance.
+ * \param[in] key Option name.
+ * \param[in] value Option value as string.
+ * \return OgaResult on error, nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStreamingProcessorSetOption(OgaStreamingProcessor* processor, const char* key, const char* value);
+
+/**
+ * \brief Get a processor option value by key.
+ * \param[in] processor The StreamingProcessor instance.
+ * \param[in] key Option name.
+ * \param[out] value Pointer to store the value string. Caller must free with OgaDestroyString.
+ * \return OgaResult on error, nullptr on success.
+ */
+OGA_EXPORT OgaResult* OGA_API_CALL OgaStreamingProcessorGetOption(const OgaStreamingProcessor* processor, const char* key, const char** value);
+
+#ifdef __cplusplus
+}
+#endif
+//! @}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/cpu_provider_factory.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/cpu_provider_factory.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/cpu_provider_factory.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/cpu_provider_factory.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/nnapi_provider_factory.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/nnapi_provider_factory.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/nnapi_provider_factory.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/nnapi_provider_factory.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_c_api.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_c_api.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_c_api.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_c_api.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_cxx_api.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_cxx_api.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_cxx_api.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_cxx_api.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_cxx_inline.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_cxx_inline.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_cxx_inline.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_cxx_inline.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_ep_c_api.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_ep_c_api.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_ep_c_api.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_ep_c_api.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_ep_device_ep_metadata_keys.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_ep_device_ep_metadata_keys.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_ep_device_ep_metadata_keys.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_ep_device_ep_metadata_keys.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_float16.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_float16.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_float16.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_float16.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_lite_custom_op.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_lite_custom_op.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_lite_custom_op.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_lite_custom_op.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_run_options_config_keys.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_run_options_config_keys.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_run_options_config_keys.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_run_options_config_keys.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_session_options_config_keys.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_session_options_config_keys.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_session_options_config_keys.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_session_options_config_keys.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_c_api.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_c_api.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_c_api.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_c_api.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_cxx_api.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_cxx_api.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_cxx_api.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_cxx_api.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_cxx_inline.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_cxx_inline.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime/onnxruntime_training_cxx_inline.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/onnxruntime/onnxruntime_training_cxx_inline.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/sampling.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/sampling.cpp
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/sampling.cpp
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/sampling.cpp
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/sampling.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/sampling.h
similarity index 61%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/sampling.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/sampling.h
index bd58ced..27b04ed 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/sampling.h
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/sampling.h
@@ -2,8 +2,8 @@
 // Created by martinkorelic on 20. 07. 25.
 //
 
-#ifndef ORTTRANSFORMER_SAMPLING_H
-#define ORTTRANSFORMER_SAMPLING_H
+#ifndef MOBILETRANSFORMERS_SAMPLING_H
+#define MOBILETRANSFORMERS_SAMPLING_H
 
 #include <vector>
 #include <random>
@@ -120,6 +120,49 @@ namespace sampling {
         int sampleNextToken(float* logits, int sequence_length, int vocab_size,
                             const SamplingConfig& config, RandomGenerator& rng);
 
+        /**
+         * How many logits the sampler may actually look at.
+         *
+         * ### Why the declared vocabulary cannot be trusted
+         *
+         * `vocab_size` reaches this layer from `mobiletransformers_tokenizer_config.json` — a file the
+         * exporter writes and the phone reads. The graph's logits width is the number of embedding
+         * rows that exist. When the two disagree, the graph is right by construction: an id the
+         * embedding table has no row for is not a token, whatever a JSON file says.
+         *
+         * Over-declaring is not a cosmetic error. Every sampler here computes its row offset as
+         * `(sequence_length - 1) * vocab_size`, so a vocab two entries too wide reads
+         * `2 * (sequence_length - 1)` floats past the intended row on prefill, and then scans two
+         * more past the end of the buffer. If that garbage wins the argmax the id is fed back as the
+         * next `input_ids` and ORT fails the embedding lookup:
+         *
+         *     Gather node ... indices element out of data bounds, idx=262145 ... [-262144,262143]
+         *
+         * which is precisely what FunctionGemma did on device — its tokenizer declares two image
+         * tokens above a 262144-row table, and the exporter sized the vocabulary from the tokenizer.
+         * The exporter is fixed (`export/tokenizer_export.py`), but **every package already installed
+         * on a device still carries the wrong number**, so the runtime must not depend on it being
+         * right.
+         *
+         * Under-declaring is left alone: a caller narrowing the sampler to a prefix of the vocabulary
+         * is a deliberate restriction, not a defect, and silently widening it would be the same class
+         * of mistake in the other direction.
+         *
+         * @param declared_vocab_size the vocabulary the package declares. Non-positive means "unknown".
+         * @param graph_logits_width  the last dimension of the logits tensor the graph produced.
+         *   Non-positive means the shape could not be read, in which case the declaration is all
+         *   there is.
+         */
+        inline int effectiveVocabSize(int declared_vocab_size, long long graph_logits_width) {
+            if (graph_logits_width <= 0) {
+                return declared_vocab_size;
+            }
+            if (declared_vocab_size <= 0 || declared_vocab_size > graph_logits_width) {
+                return static_cast<int>(graph_logits_width);
+            }
+            return declared_vocab_size;
+        }
+
     /**
      * Utility functions
      */
@@ -132,4 +175,4 @@ namespace sampling {
 
 } // namespace inference::sampling
 
-#endif //ORTTRANSFORMER_SAMPLING_H
\ No newline at end of file
+#endif //MOBILETRANSFORMERS_SAMPLING_H
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/session_cache.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/session_cache.h
similarity index 68%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/session_cache.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/session_cache.h
index e4b53fe..65b8ca8 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/session_cache.h
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/session_cache.h
@@ -14,6 +14,8 @@
 #include "weight_merger.h"
 #include "sampling.h"
 #include "logging.h"
+#include "mem_probe.h"    // #12: RSS probe (Gate 0.2)
+#include "mmap_tensor.h"  // #12: RAII mmap region (default-off zero-copy load)
 
 namespace fs = std::filesystem;
 
@@ -43,6 +45,9 @@ struct WeightSessionCache {
 
     std::unordered_map<std::string, Ort::Value > weights;
     std::unordered_map<std::string, void*> allocated_buffers; // Track allocated memory
+    // #12: mmap'd regions backing zero-copy external initializers (default-off). Must outlive the
+    // Ort::Values that point into them, so they are freed only in clearWeights()/destruction.
+    std::vector<MmapRegion> mmap_regions_;
 
     Ort::MemoryInfo memory_info_;
     Ort::AllocatorWithDefaultOptions allocator_;
@@ -50,78 +55,173 @@ struct WeightSessionCache {
     // Constructor
     WeightSessionCache() : memory_info_(Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU)) {}
 
-    // Initialize cache by loading tensors from folder
-    bool init(const std::string& weights_folder) {
+    // #23: initialize the cache from FLAT per-tensor <name>.bin files in the inference dir, keyed by
+    // weight_handoff_map.json (the ONE reader in handoff_io.h). No <dirname>.<filestem> reconstruction:
+    // initializer names come straight from inferenceInitializerNames[role]. dtype/shape are validated
+    // by the map itself (per role); a missing file or size/dtype/shape mismatch fails closed (clears the
+    // cache and returns false so the caller adds NO external initializers, never a partial/wrong set).
+    // Checksums are already enforced by the Kotlin precondition (HandoffPrecondition) before this runs.
+    bool init(const std::string& inference_dir) {
         try {
-            // Check if the folder exists
-            if (!std::filesystem::exists(weights_folder)) {
-                LOGE("Weights folder does not exist: %s", weights_folder.c_str());
+            LOG_RSS("weight-load:start");
+            // #12 (Gate 0.2, default-off): load each fp per-tensor .bin zero-copy via mmap instead of the
+            // buffered copy. Opt-in only — the shipping default is the #23 copy path, so this never
+            // perturbs the hardened load unless it is switched on.
+            const bool use_mmap = memprobe::mmap_weights_enabled();
+
+            const std::string map_path = inference_dir + "/weight_handoff_map.json";
+            std::unordered_map<std::string, HandoffEntry> handoff;
+            if (!load_handoff_entries(map_path, /*readerVersion=*/"1.0", handoff)) {
+                LOGE("Handoff map missing/invalid at %s; not loading merged weights", map_path.c_str());
                 return false;
             }
 
-            // Iterate through all subdirectories in the weights folder
-            for (const auto& layer_entry : std::filesystem::directory_iterator(weights_folder)) {
-                if (layer_entry.is_directory()) {
-                    std::string layer_name = layer_entry.path().filename().string();
-
-                    // Iterate through all .tensor files in this directory
-                    for (const auto& tensor_file : std::filesystem::directory_iterator(layer_entry.path())) {
-                        if (tensor_file.is_regular_file() && tensor_file.path().extension() == ".tensor") {
-                            std::string tensor_filename = tensor_file.path().stem().string(); // Gets filename without .tensor extension
-                            std::string full_tensor_name = layer_name + "." + tensor_filename;
-
-                            try {
-                                // Load the tensor
-                                auto [loaded_tensor, buffer_ptr] = load_tensor_with_allocator(tensor_file.path().string());
-                                if (loaded_tensor) {
-
-                                    // Store the tensor and track the buffer
-                                    weights.emplace(full_tensor_name, std::move(loaded_tensor));
-                                    // Release ownership from unique_ptr
-                                    allocated_buffers[full_tensor_name] = buffer_ptr;
-                                    LOGI("Loaded tensor for layer: %s", full_tensor_name.c_str());
-                                } else {
-                                    LOGE("Failed to load tensor from: %s", tensor_file.path().string().c_str());
-                                }
-                            } catch (const std::exception& e) {
-                                LOGE("Error loading tensor from %s: %s", tensor_file.path().string().c_str(), e.what());
-                            }
+            for (const auto& [layer, entry] : handoff) {
+                for (const auto& [role, bin_name] : entry.externalDataLocation) {
+                    const std::string init_name = entry.inferenceInitializerNames.count(role)
+                            ? entry.inferenceInitializerNames.at(role) : bin_name;
+                    const std::string path = inference_dir + "/" + bin_name;
+                    if (!std::filesystem::exists(path)) {
+                        LOGE("Merged weight file missing: %s (layer %s, role %s)", path.c_str(),
+                             layer.c_str(), role.c_str());
+                        clearWeights();
+                        return false;
+                    }
+
+                    // mmap path: only well-shaped, non-quantized tensors (the frozen-base RSS win). Any
+                    // other tensor falls back to the copy path so quantized/scalar cases stay correct.
+                    // dtype/shape are read PER ROLE (see load_tensor_raw).
+                    ONNXTensorElementDataType mmap_type =
+                            use_mmap ? onnx_type_from_string(entry.dtype_for(role))
+                                     : ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED;
+                    if (use_mmap && !entry.shape_for(role).empty() && !entry.has_quantization &&
+                        mmap_type != ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED) {
+                        MmapRegion region(path);
+                        if (!region.valid()) {
+                            LOGE("mmap failed for %s; failing closed", path.c_str());
+                            clearWeights();
+                            return false;
                         }
+                        std::vector<int64_t> shape = entry.shape_for(role);
+                        Ort::Value v = Ort::Value::CreateTensor(
+                                memory_info_, const_cast<void*>(region.data()), region.size(),
+                                shape.data(), shape.size(), mmap_type);
+                        weights.emplace(init_name, std::move(v));
+                        mmap_regions_.push_back(std::move(region));
+                        LOGI("mmap'd initializer: %s <- %s (%zu bytes)", init_name.c_str(), bin_name.c_str(),
+                             mmap_regions_.back().size());
+                        continue;
+                    }
+
+                    // Copy path (the shipping default). load_tensor_raw already fails closed on dtype,
+                    // shape and byte-size mismatch, so there is no separate post-hoc validation step:
+                    // the Ort::Value is constructed FROM the map's declaration, not checked against it.
+                    auto [loaded_tensor, buffer_ptr] = load_tensor_raw(path, entry, role, init_name);
+                    if (!loaded_tensor) {
+                        LOGE("Failed to load merged weight: %s", path.c_str());
+                        clearWeights();
+                        return false;
                     }
+                    weights.emplace(init_name, std::move(loaded_tensor));
+                    allocated_buffers[init_name] = buffer_ptr;
+                    LOGI("Loaded merged initializer: %s <- %s", init_name.c_str(), bin_name.c_str());
                 }
             }
 
-            LOGI("Weight cache initialized with %zu tensors", weights.size());
-            return true;
+            LOGI("Weight cache initialized with %zu external initializers (mmap=%d)", weights.size(),
+                 use_mmap ? 1 : 0);
+            LOG_RSS("weight-load:end");
+            return !weights.empty();
 
         } catch (const std::exception& e) {
             LOGE("Error initializing weight cache: %s", e.what());
+            clearWeights();
             return false;
         }
     }
 
-    // Load tensor using our allocator and return both tensor and buffer pointer
-    std::pair<Ort::Value, void*> load_tensor_with_allocator(const std::string& filepath) {
-        try {
-            // Read from file
-            std::ifstream file(filepath, std::ios::binary);
-            if (!file.is_open()) {
-                throw std::runtime_error("Failed to open file: " + filepath);
-            }
+    // Map the handoff dtype string onto an ORT element type (int4 packs into uint8 storage on device).
+    static ONNXTensorElementDataType onnx_type_from_string(const std::string& s) {
+        if (s == "float32" || s == "float") return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
+        if (s == "float16") return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16;
+        if (s == "int8") return ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8;
+        if (s == "uint8" || s == "int4") return ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8;
+        if (s == "int32") return ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32;
+        return ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED;
+    }
 
-            onnx::TensorProto tensor_proto;
-            if (!tensor_proto.ParseFromIstream(&file)) {
-                file.close();
-                throw std::runtime_error("Failed to parse TensorProto from file: " + filepath);
-            }
-            file.close();
+    // Byte width of an ORT element type (int4 is stored packed in uint8 on device).
+    static size_t element_size(ONNXTensorElementDataType t) {
+        switch (t) {
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT:   return 4;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16: return 2;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8:
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8:   return 1;
+            case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:   return 4;
+            default:                                    return 0;
+        }
+    }
 
-            // Convert TensorProto to OrtValue using our allocator
-            return OrtValueSerializer::tensorproto_to_ortvalue_with_allocator(tensor_proto, memory_info_, allocator_);
+    // Load one flat <name>.bin as RAW external-data bytes into an allocator-owned Ort::Value.
+    //
+    // #23 correctness fix: these files are ONNX external-data blobs (raw tensor bytes, no header) —
+    // that is what every writer emits: the exporter via onnx.write_external_data_tensors, and the
+    // device merger via weight_merger.cpp::write_raw_tensor_atomic. The previous implementation parsed
+    // them as serialized onnx::TensorProto, which cannot succeed on raw bytes, so the shipping (non-
+    // mmap) merged-weight load failed on every device run. Shape/dtype therefore come from the handoff
+    // map -- PER ROLE, since a packed weight_quantized/scale/zero_point is not shaped like its weight.
+    //
+    // Fail-closed: an unknown dtype, an absent/empty shape, or a file whose size is not exactly
+    // numel * element_size throws rather than handing ORT a mis-shaped buffer.
+    std::pair<Ort::Value, void*> load_tensor_raw(const std::string& filepath,
+                                                 const HandoffEntry& entry,
+                                                 const std::string& role,
+                                                 const std::string& init_name) {
+        const std::string& dtype_s = entry.dtype_for(role);
+        const std::vector<int64_t>& shape = entry.shape_for(role);
+
+        const ONNXTensorElementDataType elem_type = onnx_type_from_string(dtype_s);
+        const size_t elem_size = element_size(elem_type);
+        if (elem_type == ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED || elem_size == 0) {
+            throw std::runtime_error("unsupported dtype '" + dtype_s + "' for " + init_name);
+        }
+        if (shape.empty()) {
+            throw std::runtime_error(
+                    "no shape declared for role '" + role + "' of " + init_name +
+                    " (raw external data carries no header; the map must declare tensorShapes)");
+        }
 
-        } catch (const std::exception& e) {
-            throw std::runtime_error("Error loading tensor: " + std::string(e.what()));
+        size_t numel = 1;
+        for (int64_t d : shape) {
+            if (d <= 0) throw std::runtime_error("non-positive dim in shape of " + init_name);
+            numel *= static_cast<size_t>(d);
+        }
+        const size_t expected_bytes = numel * elem_size;
+
+        std::error_code ec;
+        const auto file_size = fs::file_size(filepath, ec);
+        if (ec) throw std::runtime_error("cannot stat " + filepath + ": " + ec.message());
+        if (static_cast<size_t>(file_size) != expected_bytes) {
+            throw std::runtime_error(
+                    "size mismatch for " + init_name + " (" + filepath + "): file has " +
+                    std::to_string(file_size) + " bytes, map declares " + dtype_s + " " +
+                    std::to_string(numel) + " elements = " + std::to_string(expected_bytes) + " bytes");
+        }
+
+        std::ifstream file(filepath, std::ios::binary);
+        if (!file.is_open()) throw std::runtime_error("Failed to open file: " + filepath);
+
+        void* buffer = allocator_.Alloc(expected_bytes);
+        if (buffer == nullptr) throw std::runtime_error("allocation failed for " + init_name);
+        if (!file.read(static_cast<char*>(buffer), static_cast<std::streamsize>(expected_bytes))) {
+            allocator_.Free(buffer);
+            throw std::runtime_error("short read for " + init_name + " from " + filepath);
         }
+
+        Ort::Value value = Ort::Value::CreateTensor(
+                memory_info_, buffer, expected_bytes,
+                const_cast<int64_t*>(shape.data()), shape.size(), elem_type);
+        return {std::move(value), buffer};
     }
 
     // Clear all cached weights with explicit cleanup
@@ -141,6 +241,8 @@ struct WeightSessionCache {
         // Clear the maps
         weights.clear();
         allocated_buffers.clear();
+        // #12: unmap any mmap'd regions (after the Ort::Values that referenced them are cleared).
+        mmap_regions_.clear();
 
         LOGI("Weight cache cleared and memory freed");
     }
@@ -176,6 +278,19 @@ struct EmbeddingSessionCache {
 
     bool has_token_type_ids;
 
+    // Owns the embedding tensor of the most recent forward pass.
+    //
+    // Exactly the bug, and exactly the fix, already applied to `InferenceSessionCache::last_output`:
+    // `generateEmbedding` returned a raw `float*` into a tensor held by a LOCAL `unique_ptr` that was
+    // destroyed at the `return`, so every caller read freed memory. It appeared to work because the
+    // caller copies the vector out immediately, before the allocator reuses the pages — the same way
+    // the generation path appeared to work until something read a larger block.
+    //
+    // Holding it on the cache keeps the data valid until the next forward pass overwrites it, which is
+    // the lifetime every caller already assumed. Affects RAG today and classification next: both go
+    // through this one function.
+    std::unique_ptr<Ort::Value> last_output;
+
     EmbeddingSessionCache(const std::string& embedding_model_path,
                           const std::string& embedding_model_name,
                           const std::string& cache_dir_path,
@@ -399,6 +514,18 @@ struct InferenceSessionCache {
     // KV cache
     std::vector<std::unique_ptr<Ort::Value>> past_key_values;
 
+    // Owns the logits of the most recent forward pass.
+    //
+    // `generateWithKVCache` returns a raw `float*` into the output tensor. That tensor used to be a
+    // LOCAL `unique_ptr`, destroyed at the `return` statement — so every caller received a dangling
+    // pointer into freed memory. The sampling path survived it by reading a single row immediately
+    // after the call, before the allocator reused the pages; reading the whole `[seq, vocab]` block
+    // (8 x 49152 floats for SmolLM2) crashes the process reliably, which is how it was found.
+    //
+    // Holding it here keeps the data valid until the next forward pass replaces it, which is exactly
+    // the lifetime every caller already assumed.
+    std::unique_ptr<Ort::Value> last_output;
+
     // Merged weight cache
     std::unique_ptr<WeightSessionCache> weight_session;
     bool load_external_weights;
@@ -458,48 +585,71 @@ struct InferenceSessionCache {
         sampling_config.top_p = 0.9f;
     }
 
+    /**
+     * The last dimension of the logits the most recent forward pass produced, or 0 before one has run.
+     *
+     * This is the graph's own statement of how many token ids exist, and it is the only trustworthy
+     * one on the device: the declared vocabulary arrives from a JSON file the exporter wrote, and for
+     * at least one shipped package that file is two entries too wide. See
+     * `sampling::effectiveVocabSize` for what goes wrong when the sampler believes it.
+     */
+    long long lastLogitsWidth() const {
+        if (!last_output) {
+            return 0;
+        }
+        try {
+            const auto shape = last_output->GetTensorTypeAndShapeInfo().GetShape();
+            if (shape.empty()) {
+                return 0;
+            }
+            return static_cast<long long>(shape.back());
+        } catch (const std::exception&) {
+            // A shape we cannot read is not a reason to fail a generation step; the declared value
+            // stays in force, which is exactly the behaviour that existed before this check.
+            return 0;
+        }
+    }
+
     // Function to initialize the KV cache with provided batch size and sequence length
     void initializeKVCache(int batch_size) {
-        auto ortApi = OrtGetApiBase()->GetApi(ORT_API_VERSION);
         past_key_values.clear();  // Clear any existing key-values
-        auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+        // The geometry comes from the graph's own metadata (loadModelMetadata). If it is missing, every
+        // layer count is 0, we create no past tensors, and generateWithKVCache then declares the graph's
+        // full input count while binding only 3 values — an out-of-bounds read inside ORT. Fail here,
+        // where the cause is nameable, instead of there.
+        if (num_layers <= 0 || num_kv_heads <= 0 || head_dim <= 0) {
+            throw std::runtime_error(
+                    "model metadata is missing the KV-cache geometry (num_layers=" +
+                    std::to_string(num_layers) + ", num_kv_heads=" + std::to_string(num_kv_heads) +
+                    ", head_dim=" + std::to_string(head_dim) +
+                    "). The exporter must stamp these into the ONNX metadata_props.");
+        }
+
+        Ort::AllocatorWithDefaultOptions allocator;
         // Pre-allocate the vector to avoid reallocations
         past_key_values.reserve(num_layers * 2); // *2 because we store both key and value
 
         // Initialize KV cache based on model configuration
         for (int i = 0; i < num_layers; ++i) {
-            size_t element_count = batch_size * num_kv_heads * 1 * head_dim;
-
-            // Create tensors for key and value, initialized to size 0
-            // Each layer has 2 tensors (key, value) of shape (batch_size, num_heads, 0, head_size)
+            // Each layer has 2 tensors (key, value) of shape (batch_size, num_kv_heads, 0, head_dim) —
+            // zero-length past on the first pass, which is what a `*-with-past` graph expects.
+            //
+            // These are allocator-owned. They used to be created with CreateTensorWithDataAsOrtValue
+            // over a `std::vector<float>` local to this loop iteration: that API borrows the caller's
+            // buffer without copying, so every tensor in past_key_values pointed at freed memory the
+            // moment the iteration ended.
             std::vector<int64_t> kv_shape = {batch_size, num_kv_heads, 0, head_dim};
 
-            // Create zero-initialized data for key tensor
-            std::vector<float> key_data(element_count, 0.0f);
+            auto kv_key = std::make_unique<Ort::Value>(Ort::Value::CreateTensor<float>(
+                    allocator, kv_shape.data(), kv_shape.size()));
+            validateTensor(kv_key.get(), "key");
+            past_key_values.push_back(std::move(kv_key));
 
-            OrtValue* new_k;
-            ortApi->CreateTensorWithDataAsOrtValue(
-                    memory_info,
-                    key_data.data(), key_data.size() * sizeof(float), kv_shape.data(), kv_shape.size(), ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &new_k);
-
-            std::unique_ptr<Ort::Value> kv_key = std::make_unique<Ort::Value>(new_k);
-
-            // Create empty tensor for key
-            past_key_values.push_back(std::move(kv_key)); // Empty for first pass
-
-            // Create zero-initialized data for key tensor
-            std::vector<float> value_data(element_count, 0.0f);
-            OrtValue* new_v;
-            ortApi->CreateTensorWithDataAsOrtValue(
-                    memory_info,
-                    value_data.data(), value_data.size() * sizeof(float), kv_shape.data(), kv_shape.size(), ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &new_v);
-            std::unique_ptr<Ort::Value> kv_value = std::make_unique<Ort::Value>(new_v);
-
-            validateTensor(kv_value.get(), "key");
-
-            // Create empty tensor for value
-            past_key_values.push_back(std::move(kv_value)); // Empty for first pass
-            const auto& present_kv = past_key_values[i];
+            auto kv_value = std::make_unique<Ort::Value>(Ort::Value::CreateTensor<float>(
+                    allocator, kv_shape.data(), kv_shape.size()));
+            validateTensor(kv_value.get(), "value");
+            past_key_values.push_back(std::move(kv_value));
         }
         __android_log_print(ANDROID_LOG_DEBUG, "InferenceSessionCache", "Generated %zu KV caches.", past_key_values.size());
     }
@@ -544,6 +694,33 @@ struct InferenceSessionCache {
         }
     }
 
+    /**
+     * How many tokens the KV cache actually holds, read off the cached tensors themselves.
+     *
+     * This is the ONE authority on the cache length. Kotlin used to track it independently in
+     * `ORTGeneratorNative.pastAttentionMaskLength` and derive the next turn's attention mask from that
+     * counter; the two could drift, and when they did the graph got a mask shorter than `past + new`.
+     * Under transformers 4.57.6 that surfaces as an opaque
+     *
+     *   "Gather node. Name:'/model/Gather_5' indices element out of data bounds, idx=5 ... [-5,4]"
+     *
+     * because the newer exported graph gathers the flattened attention mask at absolute positions
+     * derived from the cache length. The 4.46.2 graph had no such node and tolerated the short mask.
+     *
+     * Layout is `[batch, num_kv_heads, sequence, head_dim]`, so the sequence extent is dimension 2.
+     * Returns 0 when the cache is empty (a fresh conversation), which is the correct past length.
+     */
+    int64_t pastSequenceLength() const {
+        if (past_key_values.empty() || !past_key_values[0]) {
+            return 0;
+        }
+        const auto shape = past_key_values[0]->GetTensorTypeAndShapeInfo().GetShape();
+        if (shape.size() < 3) {
+            return 0;
+        }
+        return shape[2];
+    }
+
 private:
     Ort::SessionOptions setSessionOptions(const std::string& memory_config_id, const std::string& core_config_id, const bool enable_profiling, const std::string& artifact_path, const std::string& execution_provider = "cpu") {
         Ort::SessionOptions options;
@@ -659,13 +836,23 @@ struct InferenceSessionCache {
             }
         }
 
-        // Load merged weights (external initializers)
+        // #23: load merged weights as flat per-tensor external initializers from the inference dir,
+        // keyed by weight_handoff_map.json (retired the inference/merged subdir). The Kotlin
+        // precondition already checksum-verified these before we got here.
         if (load_external_weights) {
-            const std::string weights_path = inference_model_path + "/merged";
+            const std::string weights_path = inference_model_path;
             weight_session = std::make_unique<WeightSessionCache>();
 
             if (!weight_session->init(weights_path)) {
-                LOGE("Failed to initialize WeightSessionCache from path: %s", weights_path.c_str());
+                // #23 fail-closed: merged weights were explicitly REQUESTED and could not be loaded.
+                // Logging and falling through would build the session with the frozen base initializers
+                // — an untrained model that looks healthy, which is exactly what #23's DoD forbids.
+                // The Kotlin precondition catches missing files and bad checksums, but dtype/shape and
+                // byte-size validation are C++-only, so this is the only place those can be caught.
+                weight_session.reset();
+                throw std::runtime_error(
+                        "merged weights requested but WeightSessionCache::init failed for " + weights_path +
+                        " (see prior log lines for the offending tensor); refusing to fall back to base weights");
             } else {
                 LOGI("Successfully initialized WeightSessionCache from path: %s", weights_path.c_str());
 
@@ -703,7 +890,14 @@ struct InferenceSessionCache {
                         LOGI("Successfully added %zu external initializers to session options", initializer_names.size());
                     }
                 } catch (const std::exception& e) {
+                    // ORT rejects a replacement whose name/dims/dtype disagree with the graph's external
+                    // initializer. Swallowing that threw away the one signal that the merged tensors do
+                    // not match the model — same fail-closed rule as init() above.
                     LOGE("Error adding external initializers: %s", e.what());
+                    weight_session.reset();
+                    throw std::runtime_error(
+                            std::string("merged weights requested but AddExternalInitializers failed: ") +
+                            e.what() + "; refusing to fall back to base weights");
                 }
             }
         }
@@ -810,7 +1004,6 @@ struct InferenceSessionCache {
         past_key_values.clear();
     }
 
-
 };
 
 /**
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/CMakeLists.txt b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/CMakeLists.txt
new file mode 100644
index 0000000..c4a73fe
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/CMakeLists.txt
@@ -0,0 +1,68 @@
+# Host (desktop) unit tests for the ORT-free C++ headers.
+#
+# The shipping library is built by ../CMakeLists.txt via the Android NDK and links ONNX Runtime, so it
+# cannot run on a host. But three headers carry real, fail-closed logic with no ORT dependency, and
+# until now the entire C++ tree was compile/link-verified only — no C++ test target existed anywhere,
+# which is why #8's save->load smoke and the C++ check_compat mirror had nowhere to live:
+#
+#   * handoff_io.h              — weight_handoff_map.json reader + the check_compat semver mirror
+#   * constants/merger_variant.h — the typed MergerVariant that replaced string dispatch (#6)
+#   * mem_probe.h               — parse_vmrss_kb, explicitly labelled "unit-testable without /proc"
+#   * training_inputs.h         — which training-graph inputs get bound, in what order, at what rank
+#   * logits_metrics.h          — the cross-entropy/fingerprint the device reads off a forward pass,
+#                                 mirroring artifacts/train_inference_parity.py's shift convention
+#
+# Build + run (host toolchain, NOT the NDK):
+#   cmake -S src/main/cpp/tests -B build/cpp-tests && cmake --build build/cpp-tests && ctest --test-dir build/cpp-tests --output-on-failure
+#
+# `logging.h` includes <android/log.h>; shims/ provides a host stand-in that prints to stderr.
+
+cmake_minimum_required(VERSION 3.22.1)
+project(mobiletransformers_host_tests CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+
+FetchContent_Declare(
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG v1.14.0
+)
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+FetchContent_Declare(
+        json
+        GIT_REPOSITORY https://github.com/nlohmann/json.git
+        GIT_TAG v3.11.3
+)
+FetchContent_MakeAvailable(json)
+
+enable_testing()
+
+add_executable(host_tests
+        test_handoff_io.cpp
+        test_merger_variant.cpp
+        test_mem_probe.cpp
+        test_layer_name.cpp
+        test_training_inputs.cpp
+        test_logits_metrics.cpp
+        test_sampling.cpp
+        # sampling.cpp is ORT-free (it includes only <vector>/<random>/<algorithm>), so the real
+        # samplers link on a host and the clamp can be tested against the code that ships.
+        ../sampling.cpp)
+
+target_include_directories(host_tests PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/shims   # <android/log.h> stand-in
+        ${CMAKE_CURRENT_SOURCE_DIR}/..)     # the headers under test
+
+target_link_libraries(host_tests PRIVATE GTest::gtest_main nlohmann_json::nlohmann_json)
+
+# The shared cross-language fixture (tests/fixtures/check_compat_cases.json) is read at runtime.
+target_compile_definitions(host_tests PRIVATE
+        MTF_REPO_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../..")
+
+include(GoogleTest)
+gtest_discover_tests(host_tests)
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/shims/android/log.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/shims/android/log.h
new file mode 100644
index 0000000..ba268fe
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/shims/android/log.h
@@ -0,0 +1,31 @@
+//
+// Host shim for <android/log.h> so the ORT-free headers (handoff_io.h, mem_probe.h,
+// constants/merger_variant.h) can be compiled and unit-tested on a desktop.
+// Only the logging macros' backing function is needed; output goes to stderr.
+//
+#ifndef MOBILETRANSFORMERS_HOST_ANDROID_LOG_H
+#define MOBILETRANSFORMERS_HOST_ANDROID_LOG_H
+
+#include <cstdarg>
+#include <cstdio>
+
+enum android_LogPriority {
+    ANDROID_LOG_VERBOSE = 2,
+    ANDROID_LOG_DEBUG,
+    ANDROID_LOG_INFO,
+    ANDROID_LOG_WARN,
+    ANDROID_LOG_ERROR,
+};
+
+inline int __android_log_print(int prio, const char* tag, const char* fmt, ...) {
+    (void)prio;
+    (void)tag;
+    va_list args;
+    va_start(args, fmt);
+    const int n = std::vfprintf(stderr, fmt, args);
+    va_end(args);
+    std::fputc('\n', stderr);
+    return n;
+}
+
+#endif  // MOBILETRANSFORMERS_HOST_ANDROID_LOG_H
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_handoff_io.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_handoff_io.cpp
new file mode 100644
index 0000000..776c80c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_handoff_io.cpp
@@ -0,0 +1,137 @@
+// #8/#23: the weight_handoff_map.json reader + the C++ check_compat mirror.
+//
+// The C++ check_compat mirror has existed since #8 with NO test — the shared cross-language fixture
+// (tests/fixtures/check_compat_cases.json) was consumed by Python and Kotlin only. This closes that.
+
+#include <gtest/gtest.h>
+#include <nlohmann/json.hpp>
+
+#include <cstdio>
+#include <fstream>
+#include <string>
+
+#include "handoff_io.h"
+
+namespace {
+
+std::string write_temp(const std::string& contents) {
+    std::string path = std::string(std::tmpnam(nullptr)) + ".json";
+    std::ofstream out(path);
+    out << contents;
+    out.close();
+    return path;
+}
+
+}  // namespace
+
+// --- check_compat: byte-identical semantics with Python/Kotlin -------------------------------------
+
+TEST(CheckCompat, MatchesTheSharedCrossLanguageFixture) {
+    const std::string fixture =
+            std::string(MTF_REPO_ROOT) + "/tests/fixtures/check_compat_cases.json";
+    std::ifstream in(fixture);
+    ASSERT_TRUE(in.is_open()) << "shared fixture not found: " << fixture;
+
+    nlohmann::json j;
+    in >> j;
+    ASSERT_FALSE(j["cases"].empty());
+
+    for (const auto& c : j["cases"]) {
+        const std::string doc = c["doc"].get<std::string>();
+        const std::string min_reader = c["minReader"].get<std::string>();
+        const std::string reader = c["reader"].get<std::string>();
+        const bool expect_accept = c["expect"].get<std::string>() == "accept";
+        EXPECT_EQ(check_compat(doc, min_reader, reader), expect_accept)
+                << "case: " << c["why"].get<std::string>();
+    }
+}
+
+// --- load_handoff_entries -------------------------------------------------------------------------
+
+TEST(LoadHandoffEntries, ReadsPerRoleDtypeAndShape) {
+    // #23: each <name>.bin is RAW external data with no header, so per-role dtype/shape in the map is
+    // the loader's only description of a packed weight_quantized/scale/zero_point.
+    const std::string path = write_temp(R"({
+      "schemaVersion": "1.0", "minReaderVersion": "1.0",
+      "entries": [{
+        "trainingBaseLayerName": "layer0.base_layer",
+        "dtype": "float16", "shape": [8, 4],
+        "tensorDtypes": {"weight_quantized": "uint8", "scale": "float16"},
+        "tensorShapes": {"weight_quantized": [8, 2], "scale": [8, 1]},
+        "inferenceInitializerNames": {"weight_quantized": "l0.qweight", "scale": "l0.scales"},
+        "externalDataLocation": {"weight_quantized": "l0.qweight.bin", "scale": "l0.scales.bin"},
+        "quantization": {"weightQuantizedName": "l0.qweight"}
+      }]
+    })");
+
+    std::unordered_map<std::string, HandoffEntry> out;
+    ASSERT_TRUE(load_handoff_entries(path, "1.0", out));
+    ASSERT_EQ(out.size(), 1u);
+
+    const HandoffEntry& e = out.at("layer0.base_layer");
+    EXPECT_TRUE(e.has_quantization);
+    EXPECT_EQ(e.dtype_for("weight_quantized"), "uint8");
+    EXPECT_EQ(e.shape_for("weight_quantized"), (std::vector<int64_t>{8, 2}));
+    EXPECT_EQ(e.dtype_for("scale"), "float16");
+    EXPECT_EQ(e.shape_for("scale"), (std::vector<int64_t>{8, 1}));
+    std::remove(path.c_str());
+}
+
+TEST(LoadHandoffEntries, FallsBackToEntryLevelDtypeAndShape) {
+    // Maps written before tensorDtypes/tensorShapes existed must still resolve their single role.
+    const std::string path = write_temp(R"({
+      "schemaVersion": "1.0", "minReaderVersion": "1.0",
+      "entries": [{
+        "trainingBaseLayerName": "layer0.base_layer",
+        "dtype": "float16", "shape": [8, 4],
+        "inferenceInitializerNames": {"weight": "l0.weight"},
+        "externalDataLocation": {"weight": "l0.weight.bin"}
+      }]
+    })");
+
+    std::unordered_map<std::string, HandoffEntry> out;
+    ASSERT_TRUE(load_handoff_entries(path, "1.0", out));
+    const HandoffEntry& e = out.at("layer0.base_layer");
+    EXPECT_EQ(e.dtype_for("weight"), "float16");
+    EXPECT_EQ(e.shape_for("weight"), (std::vector<int64_t>{8, 4}));
+    std::remove(path.c_str());
+}
+
+TEST(LoadHandoffEntries, FailsClosedOnIncompatibleSchema) {
+    const std::string path = write_temp(R"({
+      "schemaVersion": "2.0", "minReaderVersion": "2.0",
+      "entries": [{"trainingBaseLayerName": "l", "dtype": "float16", "shape": [1]}]
+    })");
+    std::unordered_map<std::string, HandoffEntry> out;
+    EXPECT_FALSE(load_handoff_entries(path, "1.0", out));
+    EXPECT_TRUE(out.empty()) << "a rejected map must leave NO entries behind";
+    std::remove(path.c_str());
+}
+
+TEST(LoadHandoffEntries, FailsClosedOnMissingFileAndOnGarbage) {
+    std::unordered_map<std::string, HandoffEntry> out;
+    EXPECT_FALSE(load_handoff_entries("/nonexistent/weight_handoff_map.json", "1.0", out));
+
+    const std::string path = write_temp("{ this is not json ");
+    EXPECT_FALSE(load_handoff_entries(path, "1.0", out));
+    EXPECT_TRUE(out.empty());
+    std::remove(path.c_str());
+}
+
+TEST(LoadHandoffEntries, CollectsMergerModelsByVariantTag) {
+    const std::string path = write_temp(R"({
+      "schemaVersion": "1.0", "minReaderVersion": "1.0",
+      "mergerModels": {"lora": "merger_lora_fpin_fpout.onnx", "mars_q": "merger_mars_q_qin_qout.onnx"},
+      "entries": [{
+        "trainingBaseLayerName": "l", "dtype": "float16", "shape": [2],
+        "inferenceInitializerNames": {"weight": "w"},
+        "externalDataLocation": {"weight": "w.bin"}
+      }]
+    })");
+    std::unordered_map<std::string, HandoffEntry> out;
+    std::unordered_map<std::string, std::string> mergers;
+    ASSERT_TRUE(load_handoff_entries(path, "1.0", out, &mergers));
+    EXPECT_EQ(mergers.at("lora"), "merger_lora_fpin_fpout.onnx");
+    EXPECT_EQ(mergers.at("mars_q"), "merger_mars_q_qin_qout.onnx");
+    std::remove(path.c_str());
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_layer_name.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_layer_name.cpp
new file mode 100644
index 0000000..8e7e71b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_layer_name.cpp
@@ -0,0 +1,108 @@
+// Host tests for layer_name.h — the single definition of how an adapted layer is spelled in C++.
+//
+// Every case here is a bug that actually shipped and could only be caught on a device. The conversions
+// were previously open-coded at nine call sites with the prefixes as string literals; when two of those
+// literals disagreed the merge still reported success and wrote nothing.
+
+#include <gtest/gtest.h>
+
+#include "layer_name.h"
+
+namespace {
+
+// The five spellings of ONE layer, taken verbatim from a real SmolLM2-135M package.
+constexpr const char* kRaw = "base_model.model.model.layers.9.self_attn.q_proj";
+constexpr const char* kCheckpoint = "backbone.model.layers.9.self_attn.q_proj";
+constexpr const char* kHandoffKey = "base_model.model.model.layers.9.self_attn.q_proj.base_layer";
+
+TEST(LayerName, RawToCheckpointAndBack) {
+    EXPECT_EQ(layer_name::to_checkpoint(kRaw), kCheckpoint);
+    EXPECT_EQ(layer_name::to_raw(kCheckpoint), kRaw);
+}
+
+TEST(LayerName, ConversionsRoundTrip) {
+    EXPECT_EQ(layer_name::to_raw(layer_name::to_checkpoint(kRaw)), kRaw);
+    EXPECT_EQ(layer_name::to_checkpoint(layer_name::to_raw(kCheckpoint)), kCheckpoint);
+}
+
+TEST(LayerName, ConversionsLeaveForeignNamesAlone) {
+    // Not a no-op guard for its own sake: a silently-rewritten unrelated name would produce a lookup
+    // miss that looks exactly like a genuinely absent parameter.
+    const std::string other = "model.layers.9.self_attn.q_proj.MatMul.weight";
+    EXPECT_EQ(layer_name::to_checkpoint(other), other);
+    EXPECT_EQ(layer_name::to_raw(other), other);
+}
+
+// The "Missing base weight for LoRA merger" defect: peft wraps the original Linear as `base_layer`,
+// so `<layer>.weight` matches nothing in the checkpoint — for any layer, ever.
+TEST(LayerName, CheckpointWeightParamIncludesBaseLayer) {
+    EXPECT_EQ(layer_name::checkpoint_weight_param(kCheckpoint),
+              "backbone.model.layers.9.self_attn.q_proj.base_layer.weight");
+}
+
+TEST(LayerName, CheckpointWeightParamCarriesQuantRoles) {
+    EXPECT_EQ(layer_name::checkpoint_weight_param(kCheckpoint, "weight_scale"),
+              "backbone.model.layers.9.self_attn.q_proj.base_layer.weight_scale");
+}
+
+// Idempotence matters because the name reaching these helpers may already carry the suffix (the handoff
+// map records `trainingBaseLayerName` WITH it). Doubling it up would miss just as surely as omitting it.
+TEST(LayerName, BaseLayerSuffixIsIdempotent) {
+    const std::string once = layer_name::with_base_layer(kCheckpoint);
+    EXPECT_EQ(layer_name::with_base_layer(once), once);
+    EXPECT_EQ(layer_name::without_base_layer(once), kCheckpoint);
+    EXPECT_EQ(layer_name::without_base_layer(kCheckpoint), kCheckpoint);
+}
+
+// The defect that made all 60 merges write nothing: find_handoff_entry varied the SUFFIX but not the
+// PREFIX, so a merge loop working in checkpoint space never matched a raw-keyed map.
+TEST(LayerName, CandidateKeysCoverBothPrefixAndSuffix) {
+    const auto keys = layer_name::candidate_handoff_keys(kCheckpoint);
+    EXPECT_NE(std::find(keys.begin(), keys.end(), kHandoffKey), keys.end())
+        << "the real handoff-map key must be reachable from the merge loop's spelling";
+    EXPECT_NE(std::find(keys.begin(), keys.end(), kRaw), keys.end());
+    EXPECT_NE(std::find(keys.begin(), keys.end(), kCheckpoint), keys.end());
+}
+
+TEST(LayerName, CandidateKeysWorkFromEitherDirection) {
+    // A caller may hold the raw name instead; it must still reach the checkpoint spellings.
+    const auto keys = layer_name::candidate_handoff_keys(kRaw);
+    EXPECT_NE(std::find(keys.begin(), keys.end(), kHandoffKey), keys.end());
+}
+
+TEST(LayerName, CandidateKeysAreDeduplicated) {
+    // `layer` may already be raw and already suffixed, collapsing all four forms into one. Duplicates
+    // are harmless for correctness but mask which form actually matched when debugging a miss.
+    const auto keys = layer_name::candidate_handoff_keys(kHandoffKey);
+    for (size_t i = 0; i < keys.size(); ++i) {
+        for (size_t j = i + 1; j < keys.size(); ++j) {
+            EXPECT_NE(keys[i], keys[j]) << "duplicate candidate at " << i << " and " << j;
+        }
+    }
+}
+
+// Guards the cross-language contract: these literals must equal Python's in
+// artifacts/checkpoint_names.py (and packages/WeightHandoffMap.kt). They describe one wire format
+// (weight_handoff_map.json).
+TEST(LayerName, WrapperVocabularyMatchesThePythonTwin) {
+    EXPECT_STREQ(layer_name::kRawPrefix, "base_model.model.");
+    EXPECT_STREQ(layer_name::kCheckpointPrefix, "backbone.");
+    EXPECT_STREQ(layer_name::kBaseLayerSuffix, ".base_layer");
+}
+
+// #33: the pair is the two WRAPPERS, not a decoder's own first module. Spelled
+// `base_model.model.model.` -> `backbone.model.` it is identical for every decoder (asserted above via
+// kRaw/kCheckpoint) and converts NOTHING for an encoder, whose path is `bert.encoder.layer…`.
+TEST(LayerName, ConvertsAnEncoderPathAsWellAsADecoderPath) {
+    const std::string encoder_raw = "base_model.model.bert.encoder.layer.0.attention.self.query";
+    const std::string encoder_ckpt = "backbone.bert.encoder.layer.0.attention.self.query";
+
+    EXPECT_EQ(layer_name::to_checkpoint(encoder_raw), encoder_ckpt);
+    EXPECT_EQ(layer_name::to_raw(encoder_ckpt), encoder_raw);
+    EXPECT_EQ(layer_name::to_checkpoint(kRaw), kCheckpoint);  // decoder mapping unchanged
+    // checkpoint_weight_param takes a name already in checkpoint space — it only adds the suffix.
+    EXPECT_EQ(layer_name::checkpoint_weight_param(layer_name::to_checkpoint(encoder_raw)),
+              "backbone.bert.encoder.layer.0.attention.self.query.base_layer.weight");
+}
+
+}  // namespace
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_logits_metrics.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_logits_metrics.cpp
new file mode 100644
index 0000000..16d4747
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_logits_metrics.cpp
@@ -0,0 +1,115 @@
+// Host tests for logits_metrics.h — the numbers the device reads off a forward pass.
+//
+// These exist so the on-device post-merge assertion rests on arithmetic that was checked somewhere
+// cheap. The cross-entropy here must match `artifacts/train_inference_parity.py::causal_cross_entropy`
+// including its shift convention, or the device number is not comparable to the host gate it mirrors —
+// which would make the whole measurement decorative.
+
+#include <cmath>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "logits_metrics.h"
+
+namespace {
+
+    // Two positions, three-token vocabulary. Small enough to compute the expected value by hand.
+    std::vector<float> tiny_logits() {
+        return {
+                // t=0
+                1.0f, 2.0f, 3.0f,
+                // t=1
+                0.5f, 0.5f, 0.5f,
+        };
+    }
+
+    TEST(LogitsFingerprint, ReducesTheLastPositionNotTheFirst) {
+        const auto logits = tiny_logits();
+
+        const auto fp = logits_metrics::fingerprint_last_position(logits.data(), 2, 3);
+
+        // The last row is uniform 0.5 — argmax falls on index 0, and sum is 1.5. If it had reduced the
+        // FIRST row instead, argmax would be 2 and sum 6.0.
+        EXPECT_EQ(fp.argmax, 0);
+        EXPECT_DOUBLE_EQ(fp.sum, 1.5);
+        EXPECT_DOUBLE_EQ(fp.max_logit, 0.5);
+        EXPECT_DOUBLE_EQ(fp.sum_of_squares, 0.75);
+    }
+
+    TEST(LogitsFingerprint, DistinguishesARedistributionThatKeepsTheSum) {
+        // sum alone is blind to this pair; sum_of_squares is not. That is why the fingerprint carries
+        // four statistics rather than one — a merge that corrupts values without changing their total
+        // must not read as "unchanged".
+        const std::vector<float> a = {1.0f, 1.0f, 1.0f};
+        const std::vector<float> b = {0.0f, 0.0f, 3.0f};
+
+        const auto fa = logits_metrics::fingerprint_last_position(a.data(), 1, 3);
+        const auto fb = logits_metrics::fingerprint_last_position(b.data(), 1, 3);
+
+        EXPECT_DOUBLE_EQ(fa.sum, fb.sum);
+        EXPECT_NE(fa.sum_of_squares, fb.sum_of_squares);
+    }
+
+    TEST(LogitsFingerprint, FailsClosedOnBadShapeOrNullPointer) {
+        const auto logits = tiny_logits();
+
+        EXPECT_THROW(logits_metrics::fingerprint_last_position(nullptr, 2, 3), std::invalid_argument);
+        EXPECT_THROW(logits_metrics::fingerprint_last_position(logits.data(), 0, 3), std::invalid_argument);
+        EXPECT_THROW(logits_metrics::fingerprint_last_position(logits.data(), 2, 0), std::invalid_argument);
+    }
+
+    TEST(CausalCrossEntropy, AppliesTheSameShiftAsTheHostGate) {
+        // Position 0 predicts token 1. Only that one pair is scored: position 1 has no target, exactly
+        // as `logits[:, :-1]` vs `input_ids[:, 1:]` on the host.
+        const auto logits = tiny_logits();
+        const std::vector<int64_t> input_ids = {0, 2};
+
+        const double loss = logits_metrics::causal_cross_entropy(logits.data(), input_ids.data(), 2, 3);
+
+        // -log softmax([1,2,3])[2] = log(e^-2 + e^-1 + 1) = 0.40760596...
+        const double expected = std::log(std::exp(-2.0) + std::exp(-1.0) + 1.0);
+        EXPECT_NEAR(loss, expected, 1e-12);
+    }
+
+    TEST(CausalCrossEntropy, AUniformRowScoresLogVocabSize) {
+        // The self-calibrating reference the host gate leans on: a model predicting nothing sits at
+        // ln(vocab_size). A device number at or above this floor means the weights are gone.
+        const std::vector<float> logits = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+        const std::vector<int64_t> input_ids = {0, 1};
+
+        const double loss = logits_metrics::causal_cross_entropy(logits.data(), input_ids.data(), 2, 3);
+
+        EXPECT_NEAR(loss, std::log(3.0), 1e-12);
+    }
+
+    TEST(CausalCrossEntropy, IsStableAtMagnitudesThatOverflowFloat32Exp) {
+        // Broken graphs have been observed emitting logits in the 1e8 range. Without the max
+        // subtraction this is inf/nan; the host casts to float64 for the same reason.
+        const std::vector<float> logits = {1e8f, 2e8f, 3e8f, 0.0f, 0.0f, 0.0f};
+        const std::vector<int64_t> input_ids = {0, 2};
+
+        const double loss = logits_metrics::causal_cross_entropy(logits.data(), input_ids.data(), 2, 3);
+
+        EXPECT_TRUE(std::isfinite(loss));
+        EXPECT_NEAR(loss, 0.0, 1e-9);  // token 2 is the argmax by 1e8 — probability ~1, loss ~0
+    }
+
+    TEST(CausalCrossEntropy, FailsClosedOnATargetOutsideTheVocabulary) {
+        // Tokenizer and graph disagreeing about the vocabulary is a real package defect. Scoring it
+        // anyway would report a plausible-looking number for a broken pairing.
+        const auto logits = tiny_logits();
+        const std::vector<int64_t> bad = {0, 7};
+
+        EXPECT_THROW(logits_metrics::causal_cross_entropy(logits.data(), bad.data(), 2, 3),
+                     std::invalid_argument);
+    }
+
+    TEST(CausalCrossEntropy, FailsClosedWhenThereIsNoPairToScore) {
+        const auto logits = tiny_logits();
+        const std::vector<int64_t> input_ids = {0};
+
+        EXPECT_THROW(logits_metrics::causal_cross_entropy(logits.data(), input_ids.data(), 1, 3),
+                     std::invalid_argument);
+    }
+
+} // namespace
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_mem_probe.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_mem_probe.cpp
new file mode 100644
index 0000000..c47e6a1
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_mem_probe.cpp
@@ -0,0 +1,21 @@
+// #12: parse_vmrss_kb — labelled "unit-testable without /proc" and never tested until now.
+
+#include <gtest/gtest.h>
+
+#include "mem_probe.h"
+
+TEST(ParseVmRss, ReadsTheValueFromProcStatusShapedText) {
+    const std::string status =
+            "Name:\tapp\nVmPeak:\t 123456 kB\nVmSize:\t 123400 kB\nVmRSS:\t   45678 kB\nThreads:\t8\n";
+    EXPECT_EQ(memprobe::parse_vmrss_kb(status), 45678);
+}
+
+TEST(ParseVmRss, HandlesNoWhitespaceAfterTheKey) {
+    EXPECT_EQ(memprobe::parse_vmrss_kb("VmRSS:42 kB\n"), 42);
+}
+
+TEST(ParseVmRss, ReturnsNegativeOneWhenAbsentOrMalformed) {
+    EXPECT_EQ(memprobe::parse_vmrss_kb(""), -1);
+    EXPECT_EQ(memprobe::parse_vmrss_kb("VmSize:\t 100 kB\n"), -1);
+    EXPECT_EQ(memprobe::parse_vmrss_kb("VmRSS:\t kB\n"), -1);
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_merger_variant.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_merger_variant.cpp
new file mode 100644
index 0000000..c50644f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_merger_variant.cpp
@@ -0,0 +1,31 @@
+// #6: the typed MergerVariant that replaced `merger_type == "lora"` string dispatch.
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include "constants/merger_variant.h"
+
+TEST(MergerVariant, WireValuesMatchThePythonEnum) {
+    // Mirrors ENUM_REGISTRY["MergerVariant"] in config/constants.py (checked by `make parity`).
+    EXPECT_STREQ(to_wire(MergerVariant::LORA), "lora");
+    EXPECT_STREQ(to_wire(MergerVariant::LORA_Q), "lora_q");
+    EXPECT_STREQ(to_wire(MergerVariant::MARS_Q), "mars_q");
+}
+
+TEST(MergerVariant, RoundTripsThroughTheWireValue) {
+    for (const auto& [value, wire] : kMergerVariantWire) {
+        const auto parsed = merger_variant_from_wire(wire);
+        ASSERT_TRUE(parsed.has_value()) << wire;
+        EXPECT_EQ(*parsed, value);
+    }
+}
+
+TEST(MergerVariant, FailsClosedOnUnknownTag) {
+    // The handoff map's mergerModels keys are parsed at LOAD time, so a bad tag surfaces immediately
+    // rather than silently never matching at dispatch time.
+    EXPECT_FALSE(merger_variant_from_wire("").has_value());
+    EXPECT_FALSE(merger_variant_from_wire("LORA").has_value());  // case-sensitive
+    EXPECT_FALSE(merger_variant_from_wire("lora_xs").has_value());
+    EXPECT_FALSE(merger_variant_from_wire("mars").has_value());  // fp MARS has no merger variant
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_sampling.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_sampling.cpp
new file mode 100644
index 0000000..5445ee3
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_sampling.cpp
@@ -0,0 +1,102 @@
+// The sampler's vocabulary bound.
+//
+// `sampling::effectiveVocabSize` exists because a package's declared vocab_size is a JSON field and
+// the graph's logits width is a fact. When they disagreed on device, generation died two steps later
+// inside ORT:
+//
+//   Gather node ... indices element out of data bounds, idx=262145 ... range [-262144,262143]
+//
+// FunctionGemma's tokenizer declares <image_soft_token> (262144) and <end_of_image> (262145) above a
+// 262144-row embedding table, and the exporter sized the vocabulary from the tokenizer. These tests
+// pin both halves: the arithmetic of the clamp, and the property it exists to guarantee — that no id
+// the sampler returns can be outside the embedding table.
+
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "sampling.h"
+
+namespace {
+
+// The real numbers, so the test names the case it came from.
+constexpr int kGraphRows = 262144;
+constexpr int kDeclaredWithImageTokens = 262146;
+
+TEST(EffectiveVocabSize, ClampsADeclarationWiderThanTheGraph) {
+    EXPECT_EQ(sampling::effectiveVocabSize(kDeclaredWithImageTokens, kGraphRows), kGraphRows);
+}
+
+TEST(EffectiveVocabSize, LeavesAnAgreeingDeclarationAlone) {
+    EXPECT_EQ(sampling::effectiveVocabSize(kGraphRows, kGraphRows), kGraphRows);
+}
+
+TEST(EffectiveVocabSize, DoesNotWidenANarrowerDeclaration) {
+    // A caller restricting the sampler to a prefix of the vocabulary is deliberate. Widening it
+    // would be the same mistake as trusting an over-declaration, in the other direction.
+    EXPECT_EQ(sampling::effectiveVocabSize(1000, kGraphRows), 1000);
+}
+
+TEST(EffectiveVocabSize, FallsBackToTheDeclarationWhenTheShapeIsUnreadable) {
+    // lastLogitsWidth() returns 0 before the first forward pass and when the shape query throws.
+    // That must not turn into "sample over zero tokens".
+    EXPECT_EQ(sampling::effectiveVocabSize(kGraphRows, 0), kGraphRows);
+    EXPECT_EQ(sampling::effectiveVocabSize(kGraphRows, -1), kGraphRows);
+}
+
+TEST(EffectiveVocabSize, UsesTheGraphWhenNothingWasDeclared) {
+    // vocabSize is 0 on a package whose tokenizer config could not be read at all.
+    EXPECT_EQ(sampling::effectiveVocabSize(0, kGraphRows), kGraphRows);
+}
+
+// The two failure modes, on a small board. `rows` is what the graph produces; `declared` is what the
+// package claims. The arena is oversized so the over-declared reads stay inside test memory — in
+// production they run off the end of the tensor, which is the same bug with less predictable values.
+constexpr int kRows = 8;
+constexpr int kDeclared = 10;
+
+// One decode step: the exact shape of the FunctionGemma failure. The sampler scans two entries past
+// the end of the row and returns an id (declared - 1) that the embedding table has no row for — on
+// device, 262145 against a 262144-row table.
+TEST(GreedySampling, AnOverDeclaredVocabularySelectsAnIdWithNoEmbeddingRow) {
+    std::vector<float> arena(kDeclared + 4, 0.0f);
+    for (int v = 0; v < kRows; ++v) {
+        arena[v] = static_cast<float>(v) * 0.01f;  // a real row, argmax at 7
+    }
+    for (size_t i = kRows; i < arena.size(); ++i) {
+        arena[i] = 999.0f;  // whatever follows the tensor
+    }
+
+    const int unclamped = sampling::greedySampling(arena.data(), 1, kDeclared);
+    EXPECT_GE(unclamped, kRows) << "the unclamped sampler is expected to reach outside the table; if "
+                                   "it no longer does, this test has stopped exercising the hazard";
+
+    const int clamped =
+            sampling::greedySampling(arena.data(), 1, sampling::effectiveVocabSize(kDeclared, kRows));
+    EXPECT_EQ(clamped, 7) << "a clamped sampler must return the real row's argmax — an id outside "
+                             "the table becomes the next input and fails in Gather";
+}
+
+// Prefill: `(sequence_length - 1) * vocab_size` is the row offset, so an over-declared vocabulary
+// reads the wrong row entirely. This one produces a plausible-looking token rather than a crash,
+// which is worse.
+TEST(GreedySampling, AnOverDeclaredVocabularyStridesToTheWrongRowOnPrefill) {
+    constexpr int sequence_length = 3;
+    std::vector<float> arena(sequence_length * kDeclared + 4, 0.0f);
+    for (int t = 0; t < sequence_length; ++t) {
+        for (int v = 0; v < kRows; ++v) {
+            // Each row's argmax is a different id, so reading the wrong row is visible in the answer.
+            arena[t * kRows + v] = (v == (t + 2)) ? 5.0f : 0.0f;
+        }
+    }
+
+    const int correct = sampling::greedySampling(
+            arena.data(), sequence_length, sampling::effectiveVocabSize(kDeclared, kRows));
+    EXPECT_EQ(correct, 4) << "the last row's argmax";
+
+    const int unclamped = sampling::greedySampling(arena.data(), sequence_length, kDeclared);
+    EXPECT_NE(unclamped, correct) << "the over-declared stride is expected to land on other memory; "
+                                     "if it agrees, this test has stopped exercising the hazard";
+}
+
+}  // namespace
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_training_inputs.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_training_inputs.cpp
new file mode 100644
index 0000000..20e0b77
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tests/test_training_inputs.cpp
@@ -0,0 +1,128 @@
+// Host tests for training_inputs.h — the ORT-free half of the training-input binding (#33 B2).
+//
+// `train_step` used to build its input vector positionally, with `labels` always shaped
+// [batch, sequence]. That is one architecture's answer hardcoded: an encoder classification graph
+// declares a different input SET (token_type_ids instead of position_ids), a different ORDER, and a
+// per-sequence label rank. The decision is extracted here so both shapes can be proven on a host,
+// with the decoder pinned as a regression — a phone is not required to know the plan is right.
+
+#include <gtest/gtest.h>
+
+#include "training_inputs.h"
+
+using training::BoundInput;
+using training::InputSource;
+using training::labels_shape;
+using training::plan_training_inputs;
+
+namespace {
+
+// Exactly what a SmolLM2-style causal-LM training graph declares.
+const std::vector<std::string> kDecoderInputs{"input_ids", "attention_mask", "position_ids", "labels"};
+
+// Exactly what the BERT sequence-classification training graph declares (verified against the real
+// export in tests/integration/test_encoder_training_gate.py: labels is [batch_size], and the input
+// set carries token_type_ids, not position_ids).
+const std::vector<std::string> kEncoderInputs{"input_ids", "attention_mask", "token_type_ids", "labels"};
+
+} // namespace
+
+// --- the decoder regression: the shipped shape must not move ---------------------------------
+
+TEST(TrainingInputs, DecoderPlanIsUnchangedFromThePositionalBinder) {
+    const auto plan = plan_training_inputs(kDecoderInputs, /*batch=*/2, /*seq=*/8, /*labels=*/16);
+
+    ASSERT_EQ(plan.size(), 4u);
+    EXPECT_EQ(plan[0].name, "input_ids");
+    EXPECT_EQ(plan[0].source, InputSource::CallerInputIds);
+    EXPECT_EQ(plan[1].name, "attention_mask");
+    EXPECT_EQ(plan[1].source, InputSource::CallerAttentionMask);
+    EXPECT_EQ(plan[2].name, "position_ids");
+    EXPECT_EQ(plan[2].source, InputSource::SyntheticPositions);
+    EXPECT_EQ(plan[3].name, "labels");
+    EXPECT_EQ(plan[3].source, InputSource::CallerLabels);
+
+    // Every tensor is [batch, seq] — including labels, the per-token objective.
+    for (const BoundInput& bound : plan) {
+        EXPECT_EQ(bound.shape, (std::vector<int64_t>{2, 8})) << bound.name;
+    }
+}
+
+// --- the encoder: a different set, a different order, a different label rank -------------------
+
+TEST(TrainingInputs, EncoderClassificationBindsTokenTypesAndPerSequenceLabels) {
+    const auto plan = plan_training_inputs(kEncoderInputs, /*batch=*/8, /*seq=*/12, /*labels=*/8);
+
+    ASSERT_EQ(plan.size(), 4u);
+    EXPECT_EQ(plan[2].name, "token_type_ids");
+    EXPECT_EQ(plan[2].source, InputSource::SyntheticTokenTypes);
+    EXPECT_EQ(plan[2].shape, (std::vector<int64_t>{8, 12}));
+
+    // The contract that defines this objective: ONE label per sequence, rank 1.
+    EXPECT_EQ(plan[3].name, "labels");
+    EXPECT_EQ(plan[3].shape, (std::vector<int64_t>{8}));
+
+    // No position_ids anywhere — the graph never asked for one, so none is synthesized.
+    for (const BoundInput& bound : plan) {
+        EXPECT_NE(bound.source, InputSource::SyntheticPositions);
+    }
+}
+
+TEST(TrainingInputs, PlanFollowsTheGraphsDeclaredOrderNotAFixedOne) {
+    // ORT hands back whatever order the graph declares; TrainStep is positional against THAT order,
+    // so the plan must follow it rather than a canonical one.
+    const std::vector<std::string> shuffled{"labels", "token_type_ids", "input_ids", "attention_mask"};
+    const auto plan = plan_training_inputs(shuffled, /*batch=*/4, /*seq=*/6, /*labels=*/4);
+
+    ASSERT_EQ(plan.size(), 4u);
+    EXPECT_EQ(plan[0].name, "labels");
+    EXPECT_EQ(plan[0].shape, (std::vector<int64_t>{4}));
+    EXPECT_EQ(plan[1].name, "token_type_ids");
+    EXPECT_EQ(plan[2].name, "input_ids");
+    EXPECT_EQ(plan[3].name, "attention_mask");
+}
+
+// --- label rank comes from the data, not from a declared constant -----------------------------
+
+TEST(TrainingInputs, LabelRankIsDerivedFromWhatTheCallerSupplied) {
+    EXPECT_EQ(labels_shape(2, 8, 16), (std::vector<int64_t>{2, 8}));  // per-token
+    EXPECT_EQ(labels_shape(8, 12, 8), (std::vector<int64_t>{8}));     // per-sequence
+}
+
+TEST(TrainingInputs, SingleTokenSequencesKeepTheDecoderRank) {
+    // batch*seq == batch when seq == 1, so the two are indistinguishable by count. [batch, seq] wins
+    // so the decoder path keeps its exact shipped behaviour rather than silently changing rank.
+    EXPECT_EQ(labels_shape(4, 1, 4), (std::vector<int64_t>{4, 1}));
+}
+
+// --- fail closed, naming the entity -----------------------------------------------------------
+
+TEST(TrainingInputs, MismatchedLabelCountFailsClosedNamingBothCounts) {
+    try {
+        labels_shape(2, 8, 5);
+        FAIL() << "expected a throw";
+    } catch (const std::runtime_error& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("5"), std::string::npos) << what;   // what was supplied
+        EXPECT_NE(what.find("16"), std::string::npos) << what;  // what per-token would need
+    }
+}
+
+TEST(TrainingInputs, UnknownInputFailsClosedNamingItAndTheGraph) {
+    const std::vector<std::string> inputs{"input_ids", "pixel_values", "labels"};
+    try {
+        plan_training_inputs(inputs, 2, 8, 16);
+        FAIL() << "expected a throw";
+    } catch (const std::runtime_error& e) {
+        const std::string what = e.what();
+        // Naming the offending input is the difference between a five-minute fix and an
+        // export->push->run cycle spent guessing.
+        EXPECT_NE(what.find("pixel_values"), std::string::npos) << what;
+        EXPECT_NE(what.find("input_ids"), std::string::npos) << what;
+    }
+}
+
+TEST(TrainingInputs, NonPositiveGeometryFailsClosed) {
+    EXPECT_THROW(labels_shape(0, 8, 0), std::runtime_error);
+    EXPECT_THROW(labels_shape(2, 0, 0), std::runtime_error);
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenization.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/tokenization.cpp
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenization.cpp
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/tokenization.cpp
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenization.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/tokenization.h
similarity index 70%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenization.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/tokenization.h
index 8e80ab2..f72165f 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenization.h
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/tokenization.h
@@ -2,8 +2,8 @@
 // Created by martinkorelic on 18/11/2024.
 //
 
-#ifndef ORTTRANSFORMER_TOKENIZATION_H
-#define ORTTRANSFORMER_TOKENIZATION_H
+#ifndef MOBILETRANSFORMERS_TOKENIZATION_H
+#define MOBILETRANSFORMERS_TOKENIZATION_H
 
 namespace tokenization {
     std::vector<int32_t> tokenize(jlong tokenizerCache, const std::string &text);
@@ -11,4 +11,4 @@ namespace tokenization {
     std::string decodeToken(jlong tokenizerCache, const int &id);
 }
 
-#endif //ORTTRANSFORMER_TOKENIZATION_H
+#endif //MOBILETRANSFORMERS_TOKENIZATION_H
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenizers/tokenizers_c.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/tokenizers/tokenizers_c.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenizers/tokenizers_c.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/tokenizers/tokenizers_c.h
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenizers/tokenizers_cpp.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/tokenizers/tokenizers_cpp.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/tokenizers/tokenizers_cpp.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/tokenizers/tokenizers_cpp.h
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/train.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/train.cpp
new file mode 100644
index 0000000..5262883
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/train.cpp
@@ -0,0 +1,112 @@
+//
+// Created by martinkorelic on 31/08/2024
+//
+
+#include "train.h"
+#include "training_inputs.h"
+#include <android/log.h>
+#include <string>
+#include <vector>
+
+#define LOG_TAG "MobileTransformers"
+
+namespace training {
+
+    namespace {
+
+        size_t element_count_of(const std::vector<int64_t>& shape) {
+            size_t count = 1;
+            for (const int64_t dim : shape) {
+                count *= static_cast<size_t>(dim);
+            }
+            return count;
+        }
+
+        Ort::Value make_int64_tensor(const Ort::MemoryInfo& memory_info, int64_t* data,
+                                     const std::vector<int64_t>& shape) {
+            return Ort::Value::CreateTensor(memory_info, data, element_count_of(shape) * sizeof(int64_t),
+                                            shape.data(), shape.size(),
+                                            ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64);
+        }
+
+    } // namespace
+
+    float train_step(TrainingSessionCache* session_cache,
+                     int64_t* input_ids,
+                     int64_t* attention_mask,
+                     int64_t* labels,
+                     int64_t batch_size,
+                     int64_t sequence_length,
+                     int64_t labels_count) {
+
+        // The GRAPH decides which inputs exist and in what order TrainStep wants them. This is what
+        // lets one binder serve a decoder (position_ids, per-token labels) and an encoder classifier
+        // (token_type_ids, per-sequence labels) with no task switch in C++. The decision itself is
+        // ORT-free and host-tested — see training_inputs.h.
+        const std::vector<std::string> input_names =
+                session_cache->training_session.InputNames(/*training=*/true);
+        const std::vector<BoundInput> plan =
+                plan_training_inputs(input_names, batch_size, sequence_length, labels_count);
+
+        // Backing storage for synthesized inputs, declared out here so the buffers outlive the
+        // Ort::Values — which do not own their data.
+        std::vector<int64_t> position_ids;
+        std::vector<int64_t> token_type_ids;
+
+        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+        std::vector<Ort::Value> user_inputs;
+        user_inputs.reserve(plan.size());
+
+        for (const BoundInput& bound : plan) {
+            switch (bound.source) {
+                case InputSource::CallerInputIds:
+                    user_inputs.emplace_back(make_int64_tensor(memory_info, input_ids, bound.shape));
+                    break;
+                case InputSource::CallerAttentionMask:
+                    user_inputs.emplace_back(make_int64_tensor(memory_info, attention_mask, bound.shape));
+                    break;
+                case InputSource::CallerLabels:
+                    user_inputs.emplace_back(make_int64_tensor(memory_info, labels, bound.shape));
+                    break;
+                case InputSource::SyntheticPositions: {
+                    position_ids.resize(element_count_of(bound.shape));
+                    for (int64_t i = 0; i < batch_size; ++i) {
+                        for (int64_t j = 0; j < sequence_length; ++j) {
+                            position_ids[i * sequence_length + j] = j;
+                        }
+                    }
+                    user_inputs.emplace_back(make_int64_tensor(memory_info, position_ids.data(), bound.shape));
+                    break;
+                }
+                case InputSource::SyntheticTokenTypes:
+                    token_type_ids.assign(element_count_of(bound.shape), 0);
+                    user_inputs.emplace_back(make_int64_tensor(memory_info, token_type_ids.data(), bound.shape));
+                    break;
+            }
+        }
+
+        __android_log_print(ANDROID_LOG_INFO, LOG_TAG,
+                            "train_step: bound %zu inputs by name [%s]",
+                            user_inputs.size(), join_names(input_names).c_str());
+
+        // Run the train step and execute the forward + loss + backward.
+        float loss = *(session_cache->training_session.TrainStep(user_inputs)
+                               .front()
+                               .GetTensorMutableData<float>());
+
+        user_inputs.clear();
+
+        return loss;
+    }
+
+    void optimizer_step(TrainingSessionCache* session_cache) {
+        // Update the model parameters by taking a step in the direction of the gradients
+        session_cache->training_session.OptimizerStep();
+
+        // Reset the gradients now that the parameters have been updated.
+        // New set of gradients can then be computed for the next round of inputs.
+        session_cache->training_session.LazyResetGrad();
+    }
+
+} // namespace training
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/train.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/train.h
new file mode 100644
index 0000000..b720491
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/train.h
@@ -0,0 +1,35 @@
+//
+// Created by martinkorelic on 19/09/2024.
+//
+
+#include "onnxruntime/onnxruntime_training_cxx_api.h"
+#include "session_cache.h"
+
+namespace training {
+
+    // returns the output of the training graph (loss) and updates the parameters
+    // based on the gradients computed.
+    //
+    // Inputs are bound BY NAME, in the order the training graph declares them
+    // (`Ort::TrainingSession::InputNames(true)`), not by a fixed positional list. A decoder graph
+    // declares {input_ids, attention_mask, position_ids, labels[batch,seq]}; an encoder
+    // classification graph declares {input_ids, attention_mask, token_type_ids, labels[batch]} —
+    // different names, a different count, and a different label rank. Binding positionally either
+    // threw inside ORT or, worse, bound the wrong tensor to the wrong input.
+    //
+    // `position_ids` and `token_type_ids` are SYNTHESIZED here, and only when the graph asks for
+    // them. `labels_count` is the number of label elements the caller actually supplied; the label
+    // rank is derived from it (== batch*seq -> per-token [batch, seq]; == batch -> per-sequence
+    // [batch]) and any other value fails closed naming the counts. An input name the binder does
+    // not know also fails closed naming it, rather than being silently skipped.
+    float train_step(TrainingSessionCache* session_cache,
+                     int64_t* input_ids,
+                     int64_t* attention_mask,
+                     int64_t* labels,
+                     int64_t batch_size,
+                     int64_t sequence_length,
+                     int64_t labels_count);
+
+    void optimizer_step(TrainingSessionCache* session_cache);
+
+} // namespace training
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/training_inputs.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/training_inputs.h
new file mode 100644
index 0000000..861860c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/training_inputs.h
@@ -0,0 +1,145 @@
+#ifndef MOBILETRANSFORMERS_TRAINING_INPUTS_H
+#define MOBILETRANSFORMERS_TRAINING_INPUTS_H
+
+#include <cstdint>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+/**
+ * @file training_inputs.h
+ * How a training graph's user inputs are bound — decided here, executed in `train.cpp`.
+ *
+ * ## Why this exists
+ *
+ * `train_step` used to build its input vector positionally and with fixed shapes:
+ *
+ * ```
+ * std::vector<Ort::Value> user_inputs; // {input_ids, attention_mask, position_ids, labels}
+ * const std::vector<int64_t> labels_shape({batch_size, sequence_length});
+ * ```
+ *
+ * That is one architecture's answer, hardcoded. A decoder training graph declares
+ * `{input_ids, attention_mask, position_ids, labels[batch, seq]}`; an encoder **classification**
+ * graph declares `{input_ids, attention_mask, token_type_ids, labels[batch]}` — a different set, a
+ * different order, and a different label rank (`TaskSpec.label_shape` on the Python side calls the
+ * latter `["batch_size"]`). Feeding an encoder graph through the positional binder either throws
+ * inside ORT or binds the wrong tensor to the wrong input, which is far worse.
+ *
+ * So the **graph** decides. `Ort::TrainingSession::InputNames(true)` gives the names in the order
+ * `TrainStep` wants them; this header turns that list plus the batch geometry into an ordered plan,
+ * and `train.cpp` just executes it. Keeping the decision ORT-free is what makes it testable on a
+ * host — the same reason `layer_name.h`, `handoff_io.h` and `constants/merger_variant.h` are shaped
+ * this way, and the reason the encoder shape can be proven without a phone.
+ *
+ * ## Fail closed
+ *
+ * An input name the binder cannot supply is an error naming the input and listing the graph's
+ * inputs — never a silent skip, which would surface much later as a wrong number. A label count that
+ * matches neither `batch*sequence` nor `batch` is an error naming both counts.
+ */
+namespace training {
+
+    //: Canonical user-input names of the training graphs this library produces.
+    inline constexpr const char* kInputIds = "input_ids";
+    inline constexpr const char* kAttentionMask = "attention_mask";
+    inline constexpr const char* kPositionIds = "position_ids";
+    inline constexpr const char* kTokenTypeIds = "token_type_ids";
+    inline constexpr const char* kLabels = "labels";
+
+    /** Where a bound tensor's data comes from. */
+    enum class InputSource {
+        CallerInputIds,      //!< supplied by the caller
+        CallerAttentionMask, //!< supplied by the caller
+        CallerLabels,        //!< supplied by the caller
+        SyntheticPositions,  //!< 0..sequence_length-1 per batch row, generated here
+        SyntheticTokenTypes, //!< all zeros: the classification objective supervises single sequences
+    };
+
+    /** One input to bind, in the order the graph declared it. */
+    struct BoundInput {
+        std::string name;
+        InputSource source;
+        std::vector<int64_t> shape;
+    };
+
+    inline std::string join_names(const std::vector<std::string>& values) {
+        std::ostringstream out;
+        for (size_t i = 0; i < values.size(); ++i) {
+            if (i != 0) out << ", ";
+            out << values[i];
+        }
+        return out.str();
+    }
+
+    /**
+     * Per-token `[batch, seq]` or per-sequence `[batch]`, decided by what the caller actually
+     * supplied rather than by a declared constant that can drift away from the data.
+     *
+     * When `sequence_length == 1` the two are indistinguishable by count, and `[batch, seq]` wins so
+     * the decoder path keeps its exact shipped behaviour.
+     */
+    inline std::vector<int64_t> labels_shape(int64_t batch_size, int64_t sequence_length,
+                                             int64_t labels_count) {
+        if (batch_size <= 0 || sequence_length <= 0) {
+            std::ostringstream msg;
+            msg << "batch_size (" << batch_size << ") and sequence_length (" << sequence_length
+                << ") must both be positive";
+            throw std::runtime_error(msg.str());
+        }
+        if (labels_count == batch_size * sequence_length) {
+            return {batch_size, sequence_length};
+        }
+        if (labels_count == batch_size) {
+            return {batch_size};
+        }
+        std::ostringstream msg;
+        msg << "labels has " << labels_count << " elements, which is neither batch*sequence ("
+            << batch_size << "*" << sequence_length << " = " << batch_size * sequence_length
+            << ") for a per-token objective nor batch (" << batch_size
+            << ") for a per-sequence objective";
+        throw std::runtime_error(msg.str());
+    }
+
+    /**
+     * Turn the graph's declared input names into an ordered binding plan.
+     *
+     * @param input_names     `Ort::TrainingSession::InputNames(true)`, in TrainStep order.
+     * @param batch_size      rows in the batch.
+     * @param sequence_length tokens per row.
+     * @param labels_count    label elements the caller supplied (decides the label rank).
+     * @throws std::runtime_error naming any input this build cannot supply.
+     */
+    inline std::vector<BoundInput> plan_training_inputs(const std::vector<std::string>& input_names,
+                                                        int64_t batch_size, int64_t sequence_length,
+                                                        int64_t labels_count) {
+        const std::vector<int64_t> token_shape({batch_size, sequence_length});
+        std::vector<BoundInput> plan;
+        plan.reserve(input_names.size());
+
+        for (const std::string& name : input_names) {
+            if (name == kInputIds) {
+                plan.push_back({name, InputSource::CallerInputIds, token_shape});
+            } else if (name == kAttentionMask) {
+                plan.push_back({name, InputSource::CallerAttentionMask, token_shape});
+            } else if (name == kPositionIds) {
+                plan.push_back({name, InputSource::SyntheticPositions, token_shape});
+            } else if (name == kTokenTypeIds) {
+                plan.push_back({name, InputSource::SyntheticTokenTypes, token_shape});
+            } else if (name == kLabels) {
+                plan.push_back({name, InputSource::CallerLabels,
+                                labels_shape(batch_size, sequence_length, labels_count)});
+            } else {
+                std::ostringstream msg;
+                msg << "training graph declares an input this build cannot supply: '" << name
+                    << "' (graph inputs: " << join_names(input_names) << ")";
+                throw std::runtime_error(msg.str());
+            }
+        }
+        return plan;
+    }
+
+} // namespace training
+
+#endif // MOBILETRANSFORMERS_TRAINING_INPUTS_H
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/utils.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/utils.cpp
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/utils.cpp
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/utils.cpp
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/utils.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/utils.h
similarity index 100%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/utils.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/utils.h
diff --git a/android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.cpp b/android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.cpp
new file mode 100644
index 0000000..fbb0c66
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.cpp
@@ -0,0 +1,1389 @@
+//
+// Created by martinkorelic on 20. 07. 25.
+//
+
+#include "weight_merger.h"
+
+#include "layer_name.h"
+#include <jni.h>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <memory>
+#include <fstream>
+#include <filesystem>
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <cmath>
+#include <limits>
+#include <system_error>
+#include <android/log.h>
+#include <nlohmann/json.hpp>
+#include "logging.h"
+
+
+using json = nlohmann::json;
+
+namespace {
+
+// ---- Compact SHA-256 (public-domain style) so device checksums match Python hashlib.sha256 hex. ----
+struct Sha256 {
+    uint32_t s[8] = {0x6a09e667u, 0xbb67ae85u, 0x3c6ef372u, 0xa54ff53au,
+                     0x510e527fu, 0x9b05688cu, 0x1f83d9abu, 0x5be0cd19u};
+    uint64_t len = 0;
+    uint8_t buf[64];
+    size_t buf_len = 0;
+
+    static uint32_t rotr(uint32_t x, uint32_t n) { return (x >> n) | (x << (32 - n)); }
+
+    void block(const uint8_t* p) {
+        static const uint32_t k[64] = {
+            0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
+            0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
+            0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
+            0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
+            0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
+            0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
+            0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
+            0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2};
+        uint32_t w[64];
+        for (int i = 0; i < 16; i++)
+            w[i] = (p[i*4] << 24) | (p[i*4+1] << 16) | (p[i*4+2] << 8) | p[i*4+3];
+        for (int i = 16; i < 64; i++) {
+            uint32_t s0 = rotr(w[i-15],7) ^ rotr(w[i-15],18) ^ (w[i-15] >> 3);
+            uint32_t s1 = rotr(w[i-2],17) ^ rotr(w[i-2],19) ^ (w[i-2] >> 10);
+            w[i] = w[i-16] + s0 + w[i-7] + s1;
+        }
+        uint32_t a=s[0],b=s[1],c=s[2],d=s[3],e=s[4],f=s[5],g=s[6],h=s[7];
+        for (int i = 0; i < 64; i++) {
+            uint32_t S1 = rotr(e,6) ^ rotr(e,11) ^ rotr(e,25);
+            uint32_t ch = (e & f) ^ (~e & g);
+            uint32_t t1 = h + S1 + ch + k[i] + w[i];
+            uint32_t S0 = rotr(a,2) ^ rotr(a,13) ^ rotr(a,22);
+            uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
+            uint32_t t2 = S0 + maj;
+            h=g; g=f; f=e; e=d+t1; d=c; c=b; b=a; a=t1+t2;
+        }
+        s[0]+=a; s[1]+=b; s[2]+=c; s[3]+=d; s[4]+=e; s[5]+=f; s[6]+=g; s[7]+=h;
+    }
+
+    void update(const uint8_t* data, size_t n) {
+        len += n;
+        while (n) {
+            size_t take = std::min<size_t>(64 - buf_len, n);
+            std::memcpy(buf + buf_len, data, take);
+            buf_len += take; data += take; n -= take;
+            if (buf_len == 64) { block(buf); buf_len = 0; }
+        }
+    }
+
+    std::string hex() {
+        uint64_t bits = len * 8;
+        uint8_t pad = 0x80;
+        update(&pad, 1);
+        uint8_t zero = 0;
+        while (buf_len != 56) update(&zero, 1);
+        uint8_t lenbe[8];
+        for (int i = 0; i < 8; i++) lenbe[i] = (bits >> (56 - 8*i)) & 0xff;
+        // update() bumps len; recompute block directly to append length without altering `len`.
+        std::memcpy(buf + buf_len, lenbe, 8);
+        block(buf);
+        static const char* hexd = "0123456789abcdef";
+        std::string out;
+        out.reserve(64);
+        for (int i = 0; i < 8; i++)
+            for (int j = 3; j >= 0; j--) {
+                uint8_t byte = (s[i] >> (8*j)) & 0xff;
+                out.push_back(hexd[byte >> 4]);
+                out.push_back(hexd[byte & 0xf]);
+            }
+        return out;
+    }
+};
+
+std::string sha256_file(const std::string& path) {
+    std::ifstream f(path, std::ios::binary);
+    if (!f) return "";
+    Sha256 h;
+    char chunk[1 << 16];
+    while (f) {
+        f.read(chunk, sizeof(chunk));
+        std::streamsize got = f.gcount();
+        if (got > 0) h.update(reinterpret_cast<const uint8_t*>(chunk), static_cast<size_t>(got));
+    }
+    return h.hex();
+}
+
+// parse_version / check_compat now live inline in handoff_io.h (shared with the load side, #23).
+
+size_t dtype_byte_size(ONNXTensorElementDataType t) {
+    switch (t) {
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT: return 4;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_DOUBLE: return 8;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64:
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT64: return 8;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT32: return 4;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16:
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_BFLOAT16:
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT16:
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT16: return 2;
+        default: return 1; // int8/uint8/bool
+    }
+}
+
+// Write the tensor's raw bytes (external-data layout) atomically: temp -> fsync -> rename, then a
+// sibling ".sha256". This matches the per-tensor .bin the inference graph references.
+//
+// This comment used to end "...and the offline exporter's checksum, so offline and device merges are
+// byte-identical". That was never verified and was false for as long as the transpose defect existed.
+// It is also not comparable: the offline merger (`merge_validators.py`) keeps merged tensors in memory
+// for validation and writes no `.bin` at all, which is why exported packages were never corrupted.
+//
+// Both trailing parameters are REQUIRED, deliberately. They previously defaulted to `{}` (skip the
+// shape verification) and `true` (transpose), so a new call site got an unverified transpose by
+// omission — the same shape of mistake as the field that caused the defect in the first place.
+bool write_raw_tensor_atomic(const std::string& final_path, const Ort::Value& tensor,
+                             const std::vector<int64_t>& declared_shape,
+                             bool transpose_for_inference) {
+    auto info = tensor.GetTensorTypeAndShapeInfo();
+    size_t count = info.GetElementCount();
+    size_t bytes = count * dtype_byte_size(info.GetElementType());
+    const void* data = tensor.GetTensorData<uint8_t>();
+
+    // #37 ROOT CAUSE: the merged weight must be written in the INFERENCE graph's layout, which is the
+    // TRANSPOSE of the one the merger computes in.
+    //
+    // The merger works in checkpoint convention — `base_layer.weight` is a PyTorch `nn.Linear` weight,
+    // `[out_features, in_features]` — and the merger graph declares its `weight` input and
+    // `merged_weight` output the same way. The inference initializer that consumes the result is an
+    // ONNX `MatMul` right-hand side, `[in_features, out_features]`. Writing the merger's output raw
+    // therefore stored every merged weight TRANSPOSED.
+    //
+    // Proven on device 2026-08-14: after a merge whose delta was exactly zero (`adapter_B l2=0`,
+    // scale 1.0, correct shapes), `max|written - original.T| = 1.9e-09` — the written bytes were the
+    // transpose of the correct ones, to float round-trip precision. The model went from 4.65 nats to
+    // 15.45 on the same text, i.e. worse than uniform.
+    //
+    // Why nothing caught it:
+    //   * `q_proj` is square, so the shape never disagreed and no load-time check fired;
+    //   * `v_proj` is `[576,192]` vs `[192,576]` — the SAME element count, so the raw external-data
+    //     read succeeded too;
+    //   * L2 norm and absmax are transpose-INVARIANT, so every numeric probe in the project matched;
+    //   * `TrainMergeGenerateTest` asserts only that generation is non-empty, and
+    //     `PostMergeNumericsTest` compared two near-uniform cross-entropies over arbitrary token ids.
+    //
+    // `transpose_for_inference` is decided ONCE per package by the caller
+    // (`save_merged_parameters`), by OBSERVING the shapes of the non-square adapted weights — not by
+    // reading the map's `transposePolicy`. That field read `no_transpose` on every package ever
+    // produced, because `ObservedInit.transposed` was declared and never assigned, and those packages
+    // are still on devices; honouring the declaration would keep corrupting them. The exporter now
+    // observes the same thing on its own side
+    // (`artifacts/handoff_map.py::derive_transpose_policy`), and a test pins the two answers together.
+    //
+    // The transpose is still VERIFIED against the declared on-disk shape below, so a wrong orientation
+    // fails closed rather than corrupting weights silently — except for square weights, where both
+    // orders satisfy the check. That is why orientation is settled package-wide by the layers that
+    // CAN be checked, rather than per tensor.
+    std::vector<float> transposed;
+    auto shape = info.GetShape();
+    if (transpose_for_inference && shape.size() == 2 &&
+        info.GetElementType() == ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT) {
+        const int64_t rows = shape[0], cols = shape[1];
+        const float* src = tensor.GetTensorData<float>();
+        transposed.resize(static_cast<size_t>(rows) * static_cast<size_t>(cols));
+        for (int64_t r = 0; r < rows; ++r) {
+            for (int64_t c = 0; c < cols; ++c) {
+                transposed[static_cast<size_t>(c) * rows + r] = src[static_cast<size_t>(r) * cols + c];
+            }
+        }
+        // Fail closed when the transposed shape contradicts what the graph will read. For a square
+        // weight both orders satisfy this, which is exactly why the defect above survived — so the
+        // check is a backstop, not the mechanism.
+        if (declared_shape.size() == 2 &&
+            (declared_shape[0] != cols || declared_shape[1] != rows)) {
+            LOGE("merged tensor %s is [%lldx%lld]; transposed that is [%lldx%lld] but the handoff map "
+                 "declares [%lldx%lld] on disk. Refusing to write a weight the graph cannot read.",
+                 final_path.c_str(), (long long) rows, (long long) cols, (long long) cols,
+                 (long long) rows, (long long) declared_shape[0], (long long) declared_shape[1]);
+            return false;
+        }
+        data = transposed.data();
+    }
+    {
+        // Diagnostic: a merged tensor that does not match the handoff map's declared shape is rejected
+        // at load time by WeightSessionCache, far from here. Name the shape at the point of writing.
+        auto shape = info.GetShape();
+        std::string dims;
+        for (size_t i = 0; i < shape.size(); ++i) {
+            dims += (i ? "x" : "") + std::to_string(shape[i]);
+        }
+        LOGI("writing merged tensor %s: shape=[%s] elemtype=%d count=%zu bytes=%zu",
+             final_path.c_str(), dims.c_str(), static_cast<int>(info.GetElementType()), count, bytes);
+    }
+    std::string tmp = final_path + ".tmp";
+    {
+        std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
+        if (!out) { LOGE("cannot open temp for %s", final_path.c_str()); return false; }
+        out.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(bytes));
+        out.flush();
+        if (!out) { LOGE("write failed for %s", final_path.c_str()); return false; }
+    }
+    std::error_code ec;
+    std::filesystem::rename(tmp, final_path, ec);
+    if (ec) { LOGE("atomic rename failed for %s: %s", final_path.c_str(), ec.message().c_str()); return false; }
+    std::string digest = sha256_file(final_path);
+    if (!digest.empty()) {
+        std::ofstream sc(final_path + ".sha256", std::ios::trunc);
+        sc << digest << "\n";
+    }
+    return true;
+}
+
+}  // namespace
+
+// ParameterTracker constructor implementation
+WeightMerger::ParameterTracker::ParameterTracker(const std::string& layer_name)
+        : base_layer_name(layer_name) {
+}
+
+// WeightMerger constructor implementation
+WeightMerger::WeightMerger()
+        : memory_info_(Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault)) {
+}
+
+
+
+// Helper function to create a copy of OrtValue for user-managed memory
+std::pair<std::unique_ptr<Ort::Value>, void*> WeightMerger::CreateUserManagedCopy(const Ort::Value& original) {
+    auto tensor_info = original.GetTensorTypeAndShapeInfo();
+    std::vector<int64_t> tensor_shape = tensor_info.GetShape();
+    auto tensor_type = tensor_info.GetElementType();
+    size_t total_elements = tensor_info.GetElementCount();
+    size_t element_size = 0;
+
+    // Determine the size of one element based on tensor type
+    switch (tensor_type) {
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT:
+            element_size = sizeof(float);
+            break;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT16:
+            element_size = sizeof(int16_t);
+            break;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:
+            element_size = sizeof(int32_t);
+            break;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64:
+            element_size = sizeof(int64_t);
+            break;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8:
+            element_size = sizeof(int8_t);
+            break;
+        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8:
+            element_size = sizeof(uint8_t);
+            break;
+        default:
+            throw std::runtime_error("Unsupported tensor data type");
+    }
+
+    // Allocate memory for the tensor data
+    size_t data_size = total_elements * element_size;
+    void* user_data = allocator_.Alloc(data_size);
+
+    // Copy data from the original tensor
+    std::memcpy(user_data, original.GetTensorRawData(), data_size);
+
+    // Create new tensor with user-managed data
+    auto& ortApi = Ort::GetApi();
+    OrtValue* c_tensor;
+    auto ortStatus = ortApi.CreateTensorWithDataAsOrtValue(
+            memory_info_, user_data, data_size,
+            tensor_shape.data(), tensor_shape.size(),
+            tensor_type, &c_tensor);
+
+    if (ortStatus != nullptr) {
+        const char* error_message = ortApi.GetErrorMessage(ortStatus);
+        ortApi.ReleaseStatus(ortStatus);
+        allocator_.Free(user_data);
+        throw std::runtime_error("Failed to create tensor with user-managed data: " + std::string(error_message));
+    }
+
+    return std::make_pair(std::make_unique<Ort::Value>(c_tensor), user_data);
+}
+
+std::optional<Ort::Value> WeightMerger::GetParameterIfType(
+        const OrtCheckpointState* checkpoint_state,
+        const char* parameter_name,
+        ONNXTensorElementDataType expected_type) {
+
+    Ort::AllocatorWithDefaultOptions allocator;
+
+    const OrtApi* api = OrtGetApiBase()->GetApi(ORT_API_VERSION);
+    const OrtTrainingApi* training_api = api->GetTrainingApi(ORT_API_VERSION);
+
+    // Check parameter type first
+    OrtTensorTypeAndShapeInfo* type_info = nullptr;
+    OrtStatus* status = training_api->GetParameterTypeAndShape(
+            checkpoint_state, parameter_name, &type_info);
+
+    if (status != nullptr) {
+        api->ReleaseStatus(status);
+        return std::nullopt; // Parameter doesn't exist
+    }
+
+    ONNXTensorElementDataType actual_type;
+    status = api->GetTensorElementType(type_info, &actual_type);
+    api->ReleaseTensorTypeAndShapeInfo(type_info);
+
+    if (status != nullptr) {
+        api->ReleaseStatus(status);
+        return std::nullopt;
+    }
+
+    if (actual_type != expected_type) {
+        LOGI("Parameter %s type mismatch: expected %d, got %d",
+             parameter_name, expected_type, actual_type);
+        return std::nullopt;
+    }
+    // Get the shape information
+    size_t dim_count = 0;
+    status = api->GetDimensionsCount(type_info, &dim_count);
+    if (status != nullptr) {
+        api->ReleaseStatus(status);
+        api->ReleaseTensorTypeAndShapeInfo(type_info);
+        return std::nullopt;
+    }
+
+    std::vector<int64_t> shape(dim_count);
+    status = api->GetDimensions(type_info, shape.data(), dim_count);
+    if (status != nullptr) {
+        api->ReleaseStatus(status);
+        api->ReleaseTensorTypeAndShapeInfo(type_info);
+        return std::nullopt;
+    }
+
+    // Create an OrtValue with the correct type and shape
+    OrtValue* parameter = nullptr;
+    status = api->CreateTensorAsOrtValue(
+            allocator,
+            shape.data(),
+            dim_count,
+            actual_type,
+            &parameter
+    );
+
+    if (status != nullptr) {
+        const char* error_message = api->GetErrorMessage(status);
+        LOGI("CreateTensorAsOrtValue failed: %s", error_message);
+        api->ReleaseStatus(status);
+        return std::nullopt;
+    }
+
+    //LOGI("Created tensor element type: %d (UINT8=%d, FLOAT=%d)", created_type,
+    //     ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+
+    if (status != nullptr) {
+        api->ReleaseStatus(status);
+        return std::nullopt;
+    }
+
+    // Now copy the parameter data into our pre-allocated tensor
+    // NOTE: This kept failing in source code, as it always created float parameter even though we had quantized parameters
+    // This fix needs to be do in source code (orttraining/orttraining/training_api/onnxruntime_training_c_api.cc::640)
+    status = training_api->GetParameter(checkpoint_state, parameter_name, allocator, &parameter);
+
+    if (status != nullptr) {
+        const char* error_message = api->GetErrorMessage(status);
+        LOGI("Error getting parameter type and shape for %s: %s", parameter_name, error_message);
+        api->ReleaseStatus(status);
+        return std::nullopt;
+    }
+
+    return Ort::Value(parameter);
+}
+
+template<typename T>
+std::unique_ptr<Ort::Value> WeightMerger::CreateScalarTensor(T value) {
+    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeDefault);
+
+    // Scalar tensor has empty shape (0 dimensions)
+    std::vector<int64_t> shape = {};
+
+    // Allocate memory for single value
+    std::vector<T> data = {value};
+
+    auto tensor = Ort::Value::CreateTensor<T>(
+            memory_info,
+            data.data(),
+            1,  // single element
+            shape.data(),
+            shape.size()
+    );
+
+    return std::make_unique<Ort::Value>(std::move(tensor));
+}
+
+// Helper function to get tensor shape
+std::vector<int64_t> WeightMerger::get_tensor_shape(const Ort::Value& tensor) {
+    return tensor.GetTensorTypeAndShapeInfo().GetShape();
+}
+
+
+// Load and parse PEFT mapping from JSON
+bool WeightMerger::load_peft_mapping(const std::string& json_path) {
+    try {
+        std::ifstream file(json_path);
+        if (!file.is_open()) {
+            LOGE("Failed to open PEFT mapping file: %s", json_path.c_str());
+            return false;
+        }
+
+        json j;
+        file >> j;
+
+        if (!j.contains("peft_mapping")) {
+            LOGE("JSON file does not contain 'peft_mapping' key");
+            return false;
+        }
+
+        // #37: the merger graph's `alpha` input is a MULTIPLIER — the EFFECTIVE adapter scale, not the
+        // raw hyper-parameter. MARS supplies it per layer already divided (`MarsLayer.alpha =
+        // alpha / rank`), which is why MARS merges correctly. `create_lora_mapping`, by contrast,
+        // emits ONLY `adapter_A`/`adapter_B` — so for LoRA these two fields were never assigned, and
+        // `PeftMapping mapping;` (default-, not value-initialization) left the scalars INDETERMINATE.
+        // The merger therefore computed `base + <uninitialized float> * (B @ A)`.
+        //
+        // Measured on an S21 FE, 2026-08-14: pristine graph 4.65 nats on English, post-merge 15.55
+        // nats on the same text — above the 10.80 uniform-prediction floor, i.e. the merge left the
+        // model worse than random. It hid for months because every prior gate merged a 1- or 3-step
+        // adapter, where `B @ A` is ~0 and any multiplier leaves the graph ~unchanged; only a long run
+        // makes the delta large enough for the wrong scale to matter. An earlier incarnation of this
+        // same defect read the value through `std::map::operator[]`, which VALUE-initializes to 0.0 —
+        // so the merge was a silent no-op instead of silent corruption (see the note in
+        // `merge_and_export_weights`). The read was moved to a stack struct; the fact that LoRA never
+        // populates alpha at all was never addressed.
+        //
+        // The file's top-level `alpha`/`rank` are the authority for LoRA (`training_export.py` writes
+        // them beside `peft_mapping`). Fail closed rather than guessing: a wrong multiplier is silent
+        // corruption, which is precisely the failure mode this path keeps producing.
+        const float file_alpha =
+                j.contains("alpha") ? j["alpha"].get<float>() : std::numeric_limits<float>::quiet_NaN();
+        const int file_rank = j.contains("rank") ? j["rank"].get<int>() : 0;
+
+        for (const auto& [base_layer_name, mapping_data] : j["peft_mapping"].items()) {
+            // Value-initialized: `rank`/`alpha`/`adapter_index` are scalars with no default member
+            // initializer, so plain `PeftMapping mapping;` leaves them indeterminate.
+            PeftMapping mapping{};
+
+            if (mapping_data.contains("adapter_B")) {
+                mapping.adapter_B = mapping_data["adapter_B"];
+            }
+            if (mapping_data.contains("rank")) {
+                mapping.rank = mapping_data["rank"];
+            } else if (file_rank > 0) {
+                mapping.rank = file_rank;
+            }
+            if (mapping_data.contains("alpha")) {
+                // MARS: already the effective scale. Left exactly as it was.
+                mapping.alpha = mapping_data["alpha"];
+            } else {
+                if (!std::isfinite(file_alpha) || file_rank <= 0) {
+                    LOGE("peft_mapping entry '%s' declares no 'alpha', and the file carries no usable "
+                         "top-level alpha/rank (alpha=%f rank=%d). Refusing to merge at a guessed "
+                         "scale — a wrong multiplier corrupts the weights silently.",
+                         base_layer_name.c_str(), file_alpha, file_rank);
+                    return false;
+                }
+                mapping.alpha = file_alpha / static_cast<float>(file_rank);
+            }
+            if (mapping_data.contains("shared_A")) {
+                mapping.shared_A = mapping_data["shared_A"];
+            }
+            if (mapping_data.contains("intermediate")) {
+                mapping.intermediate = mapping_data["intermediate"];
+            }
+            if (mapping_data.contains("adapter_index")) {
+                mapping.adapter_index = mapping_data["adapter_index"];
+            }
+            if (mapping_data.contains("adapter_A")) {
+                mapping.adapter_A = mapping_data["adapter_A"];
+            }
+
+            peft_mapping_[base_layer_name] = mapping;
+            // The scale is logged because it is the value that decides whether the merge is correct,
+            // and it was previously unobservable — the old line said only that a mapping loaded.
+            LOGI("Loaded PEFT mapping for: %s (merge scale=%f, rank=%d)",
+                 base_layer_name.c_str(), mapping.alpha, mapping.rank);
+        }
+
+        LOGI("Successfully loaded %zu PEFT mappings", peft_mapping_.size());
+        return true;
+    } catch (const std::exception& e) {
+        LOGE("Error loading PEFT mapping: %s", e.what());
+        return false;
+    }
+}
+
+// Extract base layer parameters from checkpoint
+void WeightMerger::extract_base_layer_params(Ort::CheckpointState& checkpoint_state) {
+    LOGI("Extracting base layer parameters...");
+
+    for (const auto& [base_layer_name, _] : peft_mapping_) {
+        std::string adjusted_name = layer_name::to_checkpoint(base_layer_name);
+
+        BaseLayerParams base_params;
+
+        // peft wraps the original Linear as `base_layer`, so the frozen base weight is
+        // `<layer>.base_layer.weight` — the adapters sit beside it as `<layer>.lora_A.lora.weight`.
+        // Looking up `<layer>.weight` (no `.base_layer`) matched nothing in the checkpoint for ANY
+        // layer, so every merge aborted with "Missing base weight for LoRA merger".
+        //
+        // This mirrors what the Python codec already does when it seeds its lookup
+        // (`inference_package.py`: `base if base.endswith(".base_layer") else base + ".base_layer"`),
+        // and it is the same name the handoff map records as `trainingBaseLayerName`.
+        const std::string base_module = layer_name::with_base_layer(adjusted_name);
+
+        // Look for different weight parameter types
+        std::string weight_quantized_name = base_module + ".weight_quantized";
+        std::string weight_scale_name = base_module + ".weight_scale";
+        std::string weight_zero_point_name = base_module + ".weight_zero_point";
+        std::string weight_name = base_module + ".weight";
+
+        // Try to get quantized weight
+        auto quantized_tensor = GetParameterIfType(
+                checkpoint_state,
+                weight_quantized_name.c_str(),
+                ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8
+        );
+
+        if (quantized_tensor.has_value()) {
+            auto [tensor, buffer] = CreateUserManagedCopy(quantized_tensor.value());
+            base_params.weight_quantized = std::move(tensor);
+            base_params.weight_quantized_buffer = buffer;
+            base_params.has_quantized = true;
+            LOGI("Found quantized weight: %s", weight_quantized_name.c_str());
+        } else {
+            // Parameter doesn't exist or has wrong type
+            LOGI("Quantized weight %s not found or has wrong type", weight_quantized_name.c_str());
+        }
+
+        // Try to get weight scale
+        auto scale_tensor = GetParameterIfType(
+                checkpoint_state,
+                weight_scale_name.c_str(),
+                ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT  // Assuming scales are float
+        );
+
+        if (scale_tensor.has_value()) {
+            auto [tensor, buffer] = CreateUserManagedCopy(scale_tensor.value());
+            base_params.x_scale = std::move(tensor);
+            base_params.x_scale_buffer = buffer;
+            LOGI("Found weight scale: %s", weight_scale_name.c_str());
+        } else {
+            LOGI("Weight scale %s not found or has wrong type", weight_scale_name.c_str());
+        }
+
+        // Try to get weight zero point
+        auto zero_point_tensor = GetParameterIfType(
+                checkpoint_state,
+                weight_zero_point_name.c_str(),
+                ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8
+        );
+
+        if (zero_point_tensor.has_value()) {
+            auto [tensor, buffer] = CreateUserManagedCopy(zero_point_tensor.value());
+            base_params.x_zero_point = std::move(tensor);
+            base_params.x_zero_point_buffer = buffer;
+            LOGI("Found weight zero point: %s", weight_zero_point_name.c_str());
+        } else {
+            LOGI("Weight zero point %s not found or has wrong type", weight_zero_point_name.c_str());
+        }
+
+        // Try to get regular weight
+        auto weight_tensor = GetParameterIfType(
+                checkpoint_state,
+                weight_name.c_str(),
+                ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT  // Regular weights are typically float
+        );
+
+        if (weight_tensor.has_value()) {
+            auto [tensor, buffer] = CreateUserManagedCopy(weight_tensor.value());
+            base_params.weight = std::move(tensor);
+            base_params.weight_buffer = buffer;
+            base_params.has_weight = true;
+            LOGI("Found non-quantized weight: %s", weight_name.c_str());
+        } else {
+            LOGI("Non-quantized weight %s not found or has wrong type", weight_name.c_str());
+        }
+
+        if (base_params.has_quantized || base_params.has_weight) {
+            base_layer_params_[adjusted_name] = std::move(base_params);
+            LOGI("Extracted base layer params for: %s", adjusted_name.c_str());
+        } else {
+            LOGW("No parameters found for base layer: %s", adjusted_name.c_str());
+        }
+    }
+}
+
+// Extract adapter parameters from checkpoint
+void WeightMerger::extract_adapter_params(Ort::CheckpointState& checkpoint_state) {
+    LOGI("Extracting adapter parameters...");
+
+    for (const auto& [base_layer_name, mapping] : peft_mapping_) {
+        std::string adjusted_base_name = layer_name::to_checkpoint(base_layer_name);
+
+        adapter_params_[adjusted_base_name] = std::unordered_map<std::string, AdapterParams>();
+
+        // Extract adapter_B
+        if (!mapping.adapter_B.empty()) {
+            std::string adapter_name = layer_name::to_checkpoint(mapping.adapter_B);
+            adapter_name += ".weight";
+
+            try {
+                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
+                AdapterParams params;
+                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
+                params.data = std::move(adapter_tensor);
+                params.raw_buffer = buffer;
+                adapter_params_[adjusted_base_name]["adapter_B"] = std::move(params);
+                LOGI("Found adapter_B param: %s", adapter_name.c_str());
+            } catch (const std::exception& e) {
+                LOGW("Parameter not found or error extracting adapter_B for %s: %s", adapter_name.c_str(), e.what());
+            }
+        }
+
+        // Extract shared_A
+        if (!mapping.shared_A.empty()) {
+            std::string adapter_name = layer_name::to_checkpoint(mapping.shared_A);
+            adapter_name += ".weight";
+
+            try {
+                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
+                AdapterParams params;
+                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
+                params.data = std::move(adapter_tensor);
+                params.raw_buffer = buffer;
+                adapter_params_[adjusted_base_name]["shared_A"] = std::move(params);
+                LOGI("Found shared_A param: %s", adapter_name.c_str());
+            } catch (const std::exception& e) {
+                LOGW("Parameter not found or error extracting shared_A for %s: %s", adapter_name.c_str(), e.what());
+            }
+        }
+
+        // Extract intermediate
+        if (!mapping.intermediate.empty()) {
+            std::string adapter_name = layer_name::to_checkpoint(mapping.intermediate);
+            adapter_name += ".weight";
+
+            try {
+                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
+                AdapterParams params;
+                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
+                params.data = std::move(adapter_tensor);
+                params.raw_buffer = buffer;
+                adapter_params_[adjusted_base_name]["intermediate"] = std::move(params);
+                LOGI("Found intermediate param: %s", adapter_name.c_str());
+            } catch (const std::exception& e) {
+                LOGW("Parameter not found or error extracting intermediate for %s: %s", adapter_name.c_str(), e.what());
+            }
+        }
+
+        // Extract adapter_A (for LoRA)
+        if (!mapping.adapter_A.empty()) {
+            std::string adapter_name = layer_name::to_checkpoint(mapping.adapter_A);
+            adapter_name += ".weight";
+
+            try {
+                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
+                AdapterParams params;
+                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
+                params.data = std::move(adapter_tensor);
+                params.raw_buffer = buffer;
+                adapter_params_[adjusted_base_name]["adapter_A"] = std::move(params);
+                LOGI("Found adapter_A param: %s", adapter_name.c_str());
+            } catch (const std::exception& e) {
+                LOGW("Parameter not found or error extracting adapter_A for %s: %s", adapter_name.c_str(), e.what());
+            }
+        }
+    }
+}
+
+// Load + version-gate weight_handoff_map.json — the single source of tensor identity (#8/#9/#23).
+// Delegates to the ONE shared reader in handoff_io.h (also used by the load side, session_cache.h).
+bool WeightMerger::load_handoff_map(const std::string& json_path) {
+    bool ok = load_handoff_entries(json_path, /*readerVersion=*/"1.0", handoff_map_, &merger_models_);
+    LOGI("Loaded handoff map: %zu entries, %zu merger model(s)", handoff_map_.size(), merger_models_.size());
+    return ok;
+}
+
+const HandoffEntry* WeightMerger::find_handoff_entry(const std::string& base_layer_name) const {
+    // The merge loop works in "adjusted" space (`backbone.model.<layer>`, no `.base_layer`), while the
+    // handoff map keys entries by the raw training name (`base_model.model.model.<layer>.base_layer`).
+    // Only the `.base_layer` half of that difference was handled, so every merged layer failed to find
+    // its entry and `save_merged_parameters` wrote nothing while reporting per-layer errors — the merge
+    // ran 60/60 and still left all 60 `.bin` files untouched.
+    //
+    // Try both prefix forms and both suffix forms rather than assuming one direction.
+    for (const auto& key : layer_name::candidate_handoff_keys(base_layer_name)) {
+        auto it = handoff_map_.find(key);
+        if (it != handoff_map_.end()) return &it->second;
+    }
+    return nullptr;
+}
+
+bool WeightMerger::load_merger_models(const std::string& models_directory) {
+    LOGI("Loading merger models from: %s", models_directory.c_str());
+    if (merger_models_.empty()) {
+        LOGE("No merger models in the handoff map; load_handoff_map must run first");
+        return false;
+    }
+    try {
+        // Load one session per resolved MergerVariant, filename from the map (no hard-coded names).
+        // #6: the map's tag is parsed into the typed enum here, so an unrecognized variant fails
+        // closed at load time instead of silently never matching at dispatch time.
+        for (const auto& [tag, filename] : merger_models_) {
+            std::optional<MergerVariant> variant = merger_variant_from_wire(tag);
+            if (!variant) {
+                LOGE("handoff map declares unknown merger variant '%s'", tag.c_str());
+                return false;
+            }
+            std::string path = models_directory + "/" + filename;
+            merger_sessions_[*variant] = std::make_unique<Ort::Session>(
+                    Ort::Env(), path.c_str(), Ort::SessionOptions{});
+            LOGI("Loaded merger session '%s' <- %s", tag.c_str(), filename.c_str());
+        }
+        return true;
+    } catch (const std::exception& e) {
+        LOGE("Error loading merger models: %s", e.what());
+        return false;
+    }
+}
+
+// Resolve this layer's merger variant from its adapter shape + quantization (#6: a typed
+// MergerVariant, not a manufactured string that had to coincidentally match the handoff map's
+// mergerModels keys). nullopt = no merger applies to this layer, which the caller treats as fatal.
+std::optional<MergerVariant> WeightMerger::resolve_merger_variant(const std::string& base_layer_name) {
+    auto adapter_it = adapter_params_.find(base_layer_name);
+    if (adapter_it == adapter_params_.end()) {
+        return std::nullopt;
+    }
+
+    auto& adapters = adapter_it->second;
+    const bool has_shared_A = adapters.find("shared_A") != adapters.end();   // MARS shares A
+    const bool has_adapter_A = adapters.find("adapter_A") != adapters.end(); // LoRA has its own A
+    const bool has_quantized = base_layer_params_[base_layer_name].has_quantized;
+
+    if (has_shared_A && has_quantized) return MergerVariant::MARS_Q;
+    if (has_adapter_A && has_quantized) return MergerVariant::LORA_Q;
+    if (has_adapter_A && !has_quantized) return MergerVariant::LORA;
+
+    LOGW("Unable to determine merger variant for: %s", base_layer_name.c_str());
+    return std::nullopt;
+}
+
+bool WeightMerger::run_merger_model(MergerVariant variant, const std::string& base_layer_name,
+                                   const PeftMapping& mapping) {
+    LOGI("Running %s merger for: %s", to_wire(variant), base_layer_name.c_str());
+
+    if (merger_sessions_.find(variant) == merger_sessions_.end()) {
+        LOGE("Merger model not found for variant: %s", to_wire(variant));
+        return false;
+    }
+
+    try {
+        auto& session = merger_sessions_[variant];
+        auto& base_params = base_layer_params_[base_layer_name];
+        auto& adapter_params = adapter_params_[base_layer_name];
+
+        // Create parameter tracker
+        ParameterTracker tracker(base_layer_name);
+
+        // Prepare input tensors based on merger type
+        std::vector<Ort::Value> input_tensors;
+        std::vector<const char*> input_names;
+
+        // Storage for scalar values (must persist during inference)
+        // Take these from the caller's mapping. They used to be read as
+        // `peft_mapping_[base_layer_name]`, but `base_layer_name` here is the ADJUSTED name
+        // (`backbone.model.…`) while `peft_mapping_` is keyed by the RAW name
+        // (`base_model.model.model.…`). `operator[]` therefore inserted a fresh default entry on every
+        // single layer, which caused BOTH observed failures:
+        //   1. it mutated `peft_mapping_` while `merge_and_export_weights` was range-for iterating it,
+        //      rehashing mid-traversal — the loop ran 12 times for 60 layers and revisited one;
+        //   2. alpha/rank/adapter_index came back default-constructed 0, so the merger computed
+        //      `weight + 0 * (B @ A)` == weight and every "successful" merge wrote byte-identical data
+        //      (the `merge wrote no new weights: all 60 unchanged` assertion).
+        float alpha_value = mapping.alpha;
+        int64_t adapter_index_value = mapping.adapter_index;
+        int64_t rank_value = mapping.rank;
+
+        if (variant == MergerVariant::LORA) {
+            // LoRA merger inputs: base_weight, adapter_A, adapter_B, alpha
+            if (!base_params.weight) {
+                LOGE("Missing base weight for LoRA merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.weight));
+            input_names.push_back("weight");
+            tracker.used_base_params.push_back("weight");
+
+            if (adapter_params.find("adapter_A") == adapter_params.end() ||
+                !adapter_params["adapter_A"].data) {
+                LOGE("Missing adapter_A for LoRA merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["adapter_A"].data));
+            input_names.push_back("adapter_A");
+            tracker.used_adapter_params.push_back("adapter_A");
+
+            if (adapter_params.find("adapter_B") == adapter_params.end() ||
+                !adapter_params["adapter_B"].data) {
+                LOGE("Missing adapter_B for LoRA merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
+            input_names.push_back("adapter_B");
+            tracker.used_adapter_params.push_back("adapter_B");
+
+            // Create alpha tensor with persistent memory
+            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+            std::vector<int64_t> scalar_shape = {};
+            auto alpha_tensor = Ort::Value::CreateTensor<float>(
+                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
+            input_tensors.push_back(std::move(alpha_tensor));
+            input_names.push_back("alpha");
+
+            // #37 instrumentation, first merged layer only: the shapes and magnitudes actually fed to
+            // `base + scale * (B @ A)`. A merge that is the exact identity at B == 0 but ruinous at
+            // B != 0 is decided entirely by these tensors, and nothing logged them.
+            static bool logged_lora_inputs = false;
+            if (!logged_lora_inputs) {
+                logged_lora_inputs = true;
+                for (size_t i = 0; i < input_tensors.size(); ++i) {
+                    if (!input_tensors[i].IsTensor()) continue;
+                    auto info = input_tensors[i].GetTensorTypeAndShapeInfo();
+                    auto shape = info.GetShape();
+                    std::string dims;
+                    for (size_t d = 0; d < shape.size(); ++d) {
+                        dims += std::to_string(shape[d]);
+                        if (d + 1 < shape.size()) dims += "x";
+                    }
+                    double norm = 0.0, amax = 0.0;
+                    if (info.GetElementType() == ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT) {
+                        const float* p = input_tensors[i].GetTensorData<float>();
+                        const size_t n = info.GetElementCount();
+                        for (size_t k = 0; k < n; ++k) {
+                            const double v = static_cast<double>(p[k]);
+                            norm += v * v;
+                            amax = std::max(amax, std::abs(v));
+                        }
+                        norm = std::sqrt(norm);
+                    }
+                    LOGI("MERGE-INPUT %s dims=[%s] count=%zu l2=%f absmax=%f",
+                         input_names[i], dims.c_str(), (size_t) info.GetElementCount(), norm, amax);
+                }
+            }
+
+        } else if (variant == MergerVariant::LORA_Q) {
+            // LoRA quantized merger inputs
+            if (!base_params.weight_quantized) {
+                LOGE("Missing quantized weight for LoRA quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.weight_quantized));
+            input_names.push_back("weight_quantized");
+            tracker.used_base_params.push_back("weight_quantized");
+
+            if (!base_params.x_scale) {
+                LOGE("Missing x_scale for LoRA quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.x_scale));
+            input_names.push_back("x_scale");
+            tracker.used_base_params.push_back("x_scale");
+
+            if (!base_params.x_zero_point) {
+                LOGE("Missing x_zero_point for LoRA quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.x_zero_point));
+            input_names.push_back("x_zero_point");
+            tracker.used_base_params.push_back("x_zero_point");
+
+            if (adapter_params.find("adapter_A") == adapter_params.end() ||
+                !adapter_params["adapter_A"].data) {
+                LOGE("Missing adapter_A for LoRA quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["adapter_A"].data));
+            input_names.push_back("adapter_A");
+            tracker.used_adapter_params.push_back("adapter_A");
+
+            if (adapter_params.find("adapter_B") == adapter_params.end() ||
+                !adapter_params["adapter_B"].data) {
+                LOGE("Missing adapter_B for LoRA quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
+            input_names.push_back("adapter_B");
+            tracker.used_adapter_params.push_back("adapter_B");
+
+            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+            std::vector<int64_t> scalar_shape = {};
+            auto alpha_tensor = Ort::Value::CreateTensor<float>(
+                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
+            input_tensors.push_back(std::move(alpha_tensor));
+            input_names.push_back("alpha");
+
+        } else if (variant == MergerVariant::MARS_Q) {
+            // MARS quantized merger inputs
+            if (!base_params.weight_quantized) {
+                LOGE("Missing quantized weight for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.weight_quantized));
+            input_names.push_back("weight_quantized");
+            tracker.used_base_params.push_back("weight_quantized");
+
+            if (!base_params.x_scale) {
+                LOGE("Missing x_scale for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.x_scale));
+            input_names.push_back("x_scale");
+            tracker.used_base_params.push_back("x_scale");
+
+            if (!base_params.x_zero_point) {
+                LOGE("Missing x_zero_point for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*base_params.x_zero_point));
+            input_names.push_back("x_zero_point");
+            tracker.used_base_params.push_back("x_zero_point");
+
+            if (adapter_params.find("shared_A") == adapter_params.end() ||
+                !adapter_params["shared_A"].data) {
+                LOGE("Missing shared_A for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["shared_A"].data));
+            input_names.push_back("shared_A");
+            tracker.used_adapter_params.push_back("shared_A");
+
+            if (adapter_params.find("adapter_B") == adapter_params.end() ||
+                !adapter_params["adapter_B"].data) {
+                LOGE("Missing adapter_B for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
+            input_names.push_back("adapter_B");
+            tracker.used_adapter_params.push_back("adapter_B");
+
+            if (adapter_params.find("intermediate") == adapter_params.end() ||
+                !adapter_params["intermediate"].data) {
+                LOGE("Missing intermediate for MARS quantized merger");
+                return false;
+            }
+            input_tensors.push_back(std::move(*adapter_params["intermediate"].data));
+            input_names.push_back("intermediate");
+            tracker.used_adapter_params.push_back("intermediate");
+
+            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+            std::vector<int64_t> scalar_shape = {};
+
+            auto alpha_tensor = Ort::Value::CreateTensor<float>(
+                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
+            input_tensors.push_back(std::move(alpha_tensor));
+            input_names.push_back("alpha");
+
+            auto adapter_index_tensor = Ort::Value::CreateTensor<int64_t>(
+                    memory_info, &adapter_index_value, 1, scalar_shape.data(), scalar_shape.size());
+            input_tensors.push_back(std::move(adapter_index_tensor));
+            input_names.push_back("adapter_index");
+
+            auto rank_tensor = Ort::Value::CreateTensor<int64_t>(
+                    memory_info, &rank_value, 1, scalar_shape.data(), scalar_shape.size());
+            input_tensors.push_back(std::move(rank_tensor));
+            input_names.push_back("rank");
+        }
+
+        // Get output names
+        std::vector<const char*> output_names;
+        if (variant == MergerVariant::LORA) {
+            output_names.push_back("merged_weight");
+        } else { // lora_q or mars_q
+            output_names.push_back("merged_weight_quantized");
+            output_names.push_back("merged_zero_point");
+            output_names.push_back("merged_scale");
+        }
+
+        // Run inference
+        std::vector<Ort::Value> output_tensors = session->Run(
+                Ort::RunOptions{nullptr},
+                input_names.data(),
+                input_tensors.data(),
+                input_tensors.size(),
+                output_names.data(),
+                output_names.size()
+        );
+
+        // Store outputs BEFORE freeing input memory
+        MergedOutput output;
+        if (variant == MergerVariant::LORA) {
+            output.has_weight = true;
+            auto [output_tensor, buffer] = CreateUserManagedCopy(output_tensors[0]);
+            output.merged_weight_buffer = buffer;
+            output.merged_weight = std::move(output_tensor);
+        } else { // lora_q or mars_q
+            output.has_quantized = true;
+            auto [output_tensor, buffer] = CreateUserManagedCopy(output_tensors[0]);
+            output.merged_weight_quantized_buffer = buffer;
+            output.merged_weight_quantized = std::move(output_tensor);
+
+            auto [output_tensor1, buffer1] = CreateUserManagedCopy(output_tensors[1]);
+            output.merged_zero_point_buffer = buffer1;
+            output.merged_zero_point = std::move(output_tensor1);
+
+            auto [output_tensor2, buffer2] = CreateUserManagedCopy(output_tensors[2]);
+            output.merged_scale_buffer = buffer2;
+            output.merged_scale = std::move(output_tensor2);
+        }
+
+        // Store the merged output
+        merged_outputs_[base_layer_name] = std::move(output);
+
+        // Deliberately NOT freeing here: `free_used_parameters` erases from `adapter_params_` and
+        // releases allocator buffers, and doing that mid-merge mutates state the surrounding loop
+        // still depends on. (This was not what caused the revisited-layer bug — that was the
+        // `peft_mapping_[...]` insert below — but mutating containers mid-traversal is the same
+        // hazard and is not worth keeping.) Deferred to release_merge_inputs(); costs ~50 MB of
+        // retained base weights on a 135M model, and free-as-you-go can return as a measured
+        // optimization once it is demonstrably safe.
+        merge_trackers_.push_back(tracker);
+
+        // Clear input and output tensors
+        input_tensors.clear();
+        output_tensors.clear();
+
+        LOGI("Completed %s merger for: %s", to_wire(variant), base_layer_name.c_str());
+
+    } catch (const std::exception& e) {
+        LOGE("Error running merger model %s for %s: %s", to_wire(variant), base_layer_name.c_str(), e.what());
+        return false;
+    }
+    return true;
+}
+
+// Add this method to your WeightMerger class
+// Release every buffer the merge borrowed, after the loop has finished. Split out from the merge so
+// the maps are never mutated while `merge_and_export_weights` is walking them.
+void WeightMerger::release_merge_inputs() {
+    for (const auto& tracker : merge_trackers_) {
+        free_used_parameters(tracker);
+    }
+    merge_trackers_.clear();
+}
+
+void WeightMerger::free_used_parameters(const ParameterTracker& tracker) {
+    //LOGI("Freeing used parameters for layer: %s", tracker.base_layer_name.c_str());
+
+    // Free base layer parameters that were used
+    auto base_it = base_layer_params_.find(tracker.base_layer_name);
+    if (base_it != base_layer_params_.end()) {
+        auto& base_params = base_it->second;
+
+        for (const auto& param_name : tracker.used_base_params) {
+            if (param_name == "weight_quantized" && base_params.weight_quantized_buffer) {
+                //LOGI("Freeing base weight_quantized buffer");
+                allocator_.Free(base_params.weight_quantized_buffer);
+                base_params.weight_quantized_buffer = nullptr;
+                base_params.weight_quantized.reset();
+            }
+            else if (param_name == "x_scale" && base_params.x_scale_buffer) {
+                //LOGI("Freeing base x_scale buffer");
+                allocator_.Free(base_params.x_scale_buffer);
+                base_params.x_scale_buffer = nullptr;
+                base_params.x_scale.reset();
+            }
+            else if (param_name == "x_zero_point" && base_params.x_zero_point_buffer) {
+                //LOGI("Freeing base x_zero_point buffer");
+                allocator_.Free(base_params.x_zero_point_buffer);
+                base_params.x_zero_point_buffer = nullptr;
+                base_params.x_zero_point.reset();
+            }
+            else if (param_name == "weight" && base_params.weight_buffer) {
+                //LOGI("Freeing base weight buffer");
+                allocator_.Free(base_params.weight_buffer);
+                base_params.weight_buffer = nullptr;
+                base_params.weight.reset();
+            }
+        }
+    }
+
+    // Free adapter parameters that were used
+    auto adapter_it = adapter_params_.find(tracker.base_layer_name);
+    if (adapter_it != adapter_params_.end()) {
+        auto& adapter_map = adapter_it->second;
+
+        for (const auto& param_name : tracker.used_adapter_params) {
+            auto param_it = adapter_map.find(param_name);
+            if (param_it != adapter_map.end() && param_it->second.raw_buffer) {
+                //LOGI("Freeing adapter %s buffer", param_name.c_str());
+                allocator_.Free(param_it->second.raw_buffer);
+                param_it->second.raw_buffer = nullptr;
+                param_it->second.data.reset();
+                // Remove the empty adapter parameter entry
+                adapter_map.erase(param_it);
+            }
+        }
+
+        // If no more adapter parameters for this layer, remove the entire entry
+        if (adapter_map.empty()) {
+            LOGI("free: erasing adapter entry for %s", tracker.base_layer_name.c_str());
+            adapter_params_.erase(adapter_it);
+        }
+    }
+}
+
+
+// Helper function to convert OrtValue to vector for saving
+template<typename T>
+std::vector<T> WeightMerger::ortvalue_to_vector(const Ort::Value& tensor) {
+    const T* data = tensor.GetTensorData<T>();
+    size_t size = tensor.GetTensorTypeAndShapeInfo().GetElementCount();
+    return std::vector<T>(data, data + size);
+}
+
+// Write every merged tensor to the exact per-tensor .bin the inference graph references.
+// #9 fail-closed: returns false if ANY role of ANY layer could not be written. A partially-merged
+// inference/ directory is worse than no merge at all — some tensors trained, some frozen — so the
+// caller must surface this rather than report success.
+bool WeightMerger::save_merged_parameters(const std::string& output_directory) {
+    LOGI("Saving merged parameters to: %s", output_directory.c_str());
+    std::filesystem::create_directories(output_directory);
+
+    // #37: decide the package's weight orientation ONCE, by observation, before writing anything.
+    //
+    // The merger computes in checkpoint convention (`[out, in]`); the inference initializer is an ONNX
+    // MatMul right-hand side (`[in, out]`). Which of those the on-disk `.bin` holds is *observable*
+    // wherever the weight is non-square: exactly one of the two orientations matches the shape the
+    // handoff map declares.
+    //
+    // Observation beats `transposePolicy` here because every package exported before 2026-08-14
+    // declares `no_transpose` — the field it was derived from was never assigned — and those packages
+    // are still on devices. Trusting the declaration would keep corrupting them. A square weight
+    // (`q_proj`) cannot decide its own orientation, so the non-square ones (`v_proj`) settle it for the
+    // whole package, mirroring `handoff_map.py::resolve_package_transpose_policy`.
+    // Every non-square layer is checked, not just the first: a package that mixed conventions would
+    // otherwise be silently half-corrupted by whichever layer the map happened to iterate first.
+    // Disagreement is unresolvable, so it fails closed rather than picking a side.
+    bool transpose_for_inference = false;
+    bool orientation_observed = false;
+    const char* orientation_source = "declared";
+    for (const auto& [base_layer_name, output] : merged_outputs_) {
+        const HandoffEntry* e = find_handoff_entry(base_layer_name);
+        if (!e || !output.has_weight || !output.merged_weight) continue;
+        auto s = output.merged_weight->GetTensorTypeAndShapeInfo().GetShape();
+        const std::vector<int64_t>& declared = e->shape_for("weight");
+        if (s.size() != 2 || declared.size() != 2 || s[0] == s[1]) continue;  // square decides nothing
+
+        bool layer_transposed;
+        if (declared[0] == s[0] && declared[1] == s[1]) {
+            layer_transposed = false;
+        } else if (declared[0] == s[1] && declared[1] == s[0]) {
+            layer_transposed = true;
+        } else {
+            LOGE("merge orientation: layer %s has merged shape [%lld,%lld] but the handoff map "
+                 "declares [%lld,%lld] on disk — neither that shape nor its transpose. Refusing to "
+                 "write a weight whose layout cannot be established.",
+                 base_layer_name.c_str(), (long long) s[0], (long long) s[1],
+                 (long long) declared[0], (long long) declared[1]);
+            return false;
+        }
+
+        if (orientation_observed && layer_transposed != transpose_for_inference) {
+            LOGE("merge orientation: layer %s disagrees with earlier layers about weight orientation "
+                 "(this layer says transpose=%d, the package so far says %d). A package must use one "
+                 "convention throughout; refusing to merge.",
+                 base_layer_name.c_str(), static_cast<int>(layer_transposed),
+                 static_cast<int>(transpose_for_inference));
+            return false;
+        }
+        transpose_for_inference = layer_transposed;
+        orientation_observed = true;
+        orientation_source = "observed";
+    }
+
+    if (!orientation_observed) {
+        // Every adapted layer is square (an MHA model with no GQA adapts q_proj/v_proj at identical
+        // shapes), so orientation is not observable and the declaration is the only source left.
+        // This is strictly better than the hardcoded guess that stood here: a guess would corrupt half
+        // of all such packages, and `write_raw_tensor_atomic`'s shape check cannot catch it either,
+        // because a square tensor's transpose still matches the declared shape.
+        for (const auto& [base_layer_name, output] : merged_outputs_) {
+            const HandoffEntry* e = find_handoff_entry(base_layer_name);
+            if (e && output.has_weight) {
+                transpose_for_inference = (e->transposePolicy == "already_transposed_for_inference");
+                break;
+            }
+        }
+        LOGW("merge orientation: no non-square adapted weight, so orientation is UNOBSERVABLE and the "
+             "map's transposePolicy is being trusted. Packages exported before 2026-08-14 declare "
+             "'no_transpose' unconditionally and are wrong; if this model was exported before then, "
+             "re-export it.");
+    }
+    LOGI("merge orientation: transpose_for_inference=%d (source=%s)",
+         static_cast<int>(transpose_for_inference), orientation_source);
+
+    bool all_ok = true;
+    for (auto& [base_layer_name, output] : merged_outputs_) {
+        try {
+            // Tensor identity comes from the handoff map — NO string-rewrite on device (the old
+            // inference_name path is gone). Fail closed if a merged layer has no map entry.
+            const HandoffEntry* entry = find_handoff_entry(base_layer_name);
+            if (!entry) {
+                LOGE("no handoff entry for merged layer %s; refusing to guess a filename",
+                     base_layer_name.c_str());
+                all_ok = false;
+                continue;
+            }
+
+            // Local copy so the lambda captures a plain variable (capturing a structured binding is a
+            // C++20 extension; this file is built as C++17).
+            const std::string layer_name = base_layer_name;
+
+            // Write the merged tensor's raw bytes to the exact per-tensor .bin the inference graph
+            // references (map's externalDataLocation[role]), atomically + with a .sha256 sidecar.
+            auto save_role = [&](const std::string& role, const std::unique_ptr<Ort::Value>& val) {
+                if (!val) return;
+                auto loc = entry->externalDataLocation.find(role);
+                if (loc == entry->externalDataLocation.end()) {
+                    LOGE("handoff entry %s has no externalDataLocation[%s]",
+                         layer_name.c_str(), role.c_str());
+                    all_ok = false;
+                    return;
+                }
+                std::string path = output_directory + "/" + loc->second;
+                // Pass the map's declared on-disk shape plus the package-wide orientation observed
+                // above, so the write both produces the layout the inference graph will read and
+                // verifies that it did (#37).
+                if (write_raw_tensor_atomic(path, *val, entry->shape_for(role),
+                                            transpose_for_inference)) {
+                    LOGI("merged %s [%s] -> %s", layer_name.c_str(), role.c_str(), loc->second.c_str());
+                } else {
+                    LOGE("failed writing merged %s [%s]", layer_name.c_str(), role.c_str());
+                    all_ok = false;
+                }
+            };
+
+            if (output.has_quantized) {
+                save_role("weight_quantized", output.merged_weight_quantized);
+                save_role("zero_point", output.merged_zero_point);
+                save_role("scale", output.merged_scale);
+
+                if (output.merged_weight_quantized_buffer) {
+                    allocator_.Free(output.merged_weight_quantized_buffer);
+                    output.merged_weight_quantized_buffer = nullptr;
+                }
+                if (output.merged_zero_point_buffer) {
+                    allocator_.Free(output.merged_zero_point_buffer);
+                    output.merged_zero_point_buffer = nullptr;
+                }
+                if (output.merged_scale_buffer) {
+                    allocator_.Free(output.merged_scale_buffer);
+                    output.merged_scale_buffer = nullptr;
+                }
+                output.merged_weight_quantized.reset();
+                output.merged_zero_point.reset();
+                output.merged_scale.reset();
+
+            } else if (output.has_weight) {
+                save_role("weight", output.merged_weight);
+                if (output.merged_weight_buffer) {
+                    allocator_.Free(output.merged_weight_buffer);
+                    output.merged_weight_buffer = nullptr;
+                }
+                output.merged_weight.reset();
+            }
+
+        } catch (const std::exception& e) {
+            LOGE("Error saving parameters for layer %s: %s", base_layer_name.c_str(), e.what());
+            all_ok = false;
+        }
+    }
+    return all_ok;
+}
+
+
+// Main method to perform weight merging
+bool WeightMerger::merge_and_export_weights(Ort::CheckpointState& checkpoint_state,
+                              const std::string& peft_mapping_path,
+                              const std::string& merger_models_directory,
+                              const std::string& output_directory) {
+    LOGI("Starting weight merging process...");
+
+    // Load PEFT mapping
+    if (!load_peft_mapping(peft_mapping_path)) {
+        LOGE("Failed to load PEFT mapping");
+        return false;
+    }
+
+    // Load the handoff map FIRST — it provides the resolved merger filenames + tensor identity that
+    // both the session loading and the save side now key off (single source of truth, #8/#9). The map
+    // lives in the merger models directory (the inference package dir).
+    handoff_dir_ = merger_models_directory;
+    if (!load_handoff_map(merger_models_directory + "/weight_handoff_map.json")) {
+        LOGE("Failed to load weight_handoff_map.json (required by #9)");
+        return false;
+    }
+
+    // Load merger models (filenames resolved from the handoff map's mergerModels).
+    if (!load_merger_models(merger_models_directory)) {
+        LOGE("Failed to load merger models");
+        return false;
+    }
+
+    // Extract parameters from checkpoint
+    extract_base_layer_params(checkpoint_state);
+    extract_adapter_params(checkpoint_state);
+
+    // Process each base layer
+    for (const auto& [base_layer_name, mapping] : peft_mapping_) {
+        std::string adjusted_name = layer_name::to_checkpoint(base_layer_name);
+
+        // Diagnostic: adapter_params_ should shrink by exactly one entry per merged layer. Anything
+        // else means entries are disappearing that this loop did not consume.
+        LOGI("merge loop: layer=%s adapters_remaining=%zu base_remaining=%zu",
+             adjusted_name.c_str(), adapter_params_.size(), base_layer_params_.size());
+
+        // Determine appropriate merger type
+        std::optional<MergerVariant> variant = resolve_merger_variant(adjusted_name);
+        if (!variant) {
+            // #9 fail-closed: skipping leaves this layer at its frozen base weights while its peers
+            // are merged, i.e. a silently half-trained model. Abort instead.
+            LOGE("unresolved merger variant for layer %s; aborting the merge", adjusted_name.c_str());
+            return false;
+        }
+
+        // Run the appropriate merger. A miss here (no merger graph shipped for this variant) used to
+        // LOGE and continue, so `merge()` reported success having merged NOTHING — the package shipped a
+        // `lora_q` graph while the device resolved `lora`, and all 60 tensors stayed at base weights.
+        // Same fail-closed rule as the unresolved-variant branch above.
+        if (!run_merger_model(*variant, adjusted_name, mapping)) {
+            LOGE("merger failed for layer %s; aborting the merge", adjusted_name.c_str());
+            return false;
+        }
+    }
+
+    // Save merged parameters. A partial write must NOT report success (#9).
+    const bool saved = save_merged_parameters(output_directory);
+    release_merge_inputs();  // deferred cleanup: safe now that nothing is iterating
+    if (!saved) {
+        LOGE("Weight merging failed: one or more merged tensors could not be written");
+        return false;
+    }
+
+    LOGI("Weight merging process completed successfully");
+    return true;
+}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.h b/android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.h
similarity index 59%
rename from android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.h
rename to android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.h
index 7d9a78d..d0fcbf0 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.h
+++ b/android/MobileTransformers/MobileTransformers/src/main/cpp/weight_merger.h
@@ -2,10 +2,9 @@
 // Created by martinkorelic on 20. 07. 25.
 //
 
-#ifndef ORTTRANSFORMER_WEIGHT_MERGER_H
-#define ORTTRANSFORMER_WEIGHT_MERGER_H
+#ifndef MOBILETRANSFORMERS_WEIGHT_MERGER_H
+#define MOBILETRANSFORMERS_WEIGHT_MERGER_H
 
-#include "weight_serializer.h"
 #include <jni.h>
 #include <string>
 #include <unordered_map>
@@ -16,7 +15,11 @@
 #include <filesystem>
 #include <android/log.h>
 #include <nlohmann/json.hpp>
+// Was reached transitively via weight_serializer.h until that dead TensorProto layer was deleted (#23).
+#include "onnxruntime/onnxruntime_training_cxx_api.h"
 #include "logging.h"
+#include "handoff_io.h"  // #23: shared HandoffEntry + load_handoff_entries + check_compat (one reader)
+#include "constants/merger_variant.h"  // #6: typed MergerVariant (parity-checked wire values)
 
 struct PeftMapping {
     std::string adapter_B;
@@ -28,6 +31,9 @@ struct PeftMapping {
     std::string adapter_A; // For LoRA
 };
 
+// HandoffEntry (one entry of weight_handoff_map.json, #8 schema) now lives in handoff_io.h so the merger
+// WRITE side and the session_cache LOAD side share ONE definition + ONE reader (#23).
+
 struct BaseLayerParams {
     std::unique_ptr<Ort::Value> weight_quantized;
     std::unique_ptr<Ort::Value> x_scale;
@@ -79,7 +85,13 @@ class WeightMerger {
     std::unordered_map<std::string, BaseLayerParams> base_layer_params_;
     std::unordered_map<std::string, std::unordered_map<std::string, AdapterParams>> adapter_params_;
     std::unordered_map<std::string, MergedOutput> merged_outputs_;
-    std::unordered_map<std::string, std::unique_ptr<Ort::Session>> merger_sessions_;
+    // Keyed by the TYPED variant (#6), not by a raw tag string.
+    std::unordered_map<MergerVariant, std::unique_ptr<Ort::Session>> merger_sessions_;
+
+    // weight_handoff_map.json (#9): tensor identity + resolved merger filenames, keyed by base layer.
+    std::unordered_map<std::string, HandoffEntry> handoff_map_;
+    std::unordered_map<std::string, std::string> merger_models_; // MergerVariant tag -> ONNX filename
+    std::string handoff_dir_; // package dir holding model.onnx + the .bin files + merger ONNX + map
 
     Ort::MemoryInfo memory_info_;
     Ort::AllocatorWithDefaultOptions allocator_;
@@ -100,12 +112,20 @@ class WeightMerger {
     // Helper function to get tensor shape
     std::vector<int64_t> get_tensor_shape(const Ort::Value& tensor);
 
-    // Replace prefix in parameter name
-    std::string replace_prefix(const std::string& name, const std::string& old_prefix, const std::string& new_prefix);
+    // Layer-name conversions live in layer_name.h — ONE definition shared by every consumer, and the
+    // twin of Python's handoff_map._strip_wrapper_prefixes. A per-class replace_prefix helper used to
+    // live here and was open-coded at 9 call sites with the prefixes as literals; five device-only
+    // defects came from those literals disagreeing. Do not reintroduce it.
 
     // Load and parse PEFT mapping from JSON
     bool load_peft_mapping(const std::string& json_path);
 
+    // Load + version-gate weight_handoff_map.json (the single source of tensor identity, #8/#9).
+    bool load_handoff_map(const std::string& json_path);
+
+    // Look up the handoff entry for a merge layer, tolerating the optional ".base_layer" suffix.
+    const HandoffEntry* find_handoff_entry(const std::string& base_layer_name) const;
+
     // Extract base layer parameters from checkpoint
     void extract_base_layer_params(Ort::CheckpointState& checkpoint_state);
 
@@ -115,24 +135,28 @@ class WeightMerger {
     // Load ONNX merger models
     bool load_merger_models(const std::string& models_directory);
 
-    // Determine the appropriate merger type based on available parameters
-    std::string get_merger_type(const std::string& base_layer_name);
+    // Resolve this layer's merger variant from adapter shape + quantization (nullopt = none applies).
+    std::optional<MergerVariant> resolve_merger_variant(const std::string& base_layer_name);
 
     // Run the appropriate merger model
-    void run_merger_model(const std::string& merger_type, const std::string& base_layer_name);
+    /** Returns false if no merger graph is loaded for `variant` or the merge fails. */
+    bool run_merger_model(MergerVariant variant, const std::string& base_layer_name,
+                          const PeftMapping& mapping);
 
     // Free used parameters after merging
     void free_used_parameters(const ParameterTracker& tracker);
 
+    /** Deferred cleanup of borrowed merge inputs; run only after the merge loop completes. */
+    void release_merge_inputs();
+    std::vector<ParameterTracker> merge_trackers_;
+
     // Helper function to convert OrtValue to vector for saving
     template<typename T>
     std::vector<T> ortvalue_to_vector(const Ort::Value& tensor);
 
-    // Save merged parameters using OrtValueSerializer
-    void save_merged_parameters(const std::string& output_directory);
-
-    // Helper function to create correct tensor names for inference initializers
-    std::string inference_name(const std::string& layer_name);
+    // Save merged parameters to the map-keyed per-tensor .bin files (atomic + checksum).
+    // Returns false if any role of any layer could not be written (#9 fail-closed).
+    bool save_merged_parameters(const std::string& output_directory);
 
 public:
     WeightMerger();
@@ -144,4 +168,4 @@ class WeightMerger {
                                   const std::string& output_directory);
 };
 
-#endif //ORTTRANSFORMER_WEIGHT_MERGER_H
\ No newline at end of file
+#endif //MOBILETRANSFORMERS_WEIGHT_MERGER_H
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/DataUtil.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/DataUtil.kt
new file mode 100644
index 0000000..947bd21
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/DataUtil.kt
@@ -0,0 +1,379 @@
+package com.martinkorelic.mobiletransformers
+
+import org.json.JSONObject
+
+/**
+ * Pads a batch into the tensors a training step binds.
+ *
+ * Takes the pad token rather than the whole tokenizer: that is all it ever used, and depending on
+ * [ORTTokenizerNative] made the collator un-unit-testable (its `init` loads the native library). The
+ * label-padding rule below is the half that decides the exported graph's label rank, so it needs to be
+ * pinned on the host — the same reason `GenerationInputs`, `training_inputs.h` and `layer_name.h` are
+ * shaped as pure seams.
+ */
+class DataCollatorForSupervisedDataset(private val padToken: Int?) {
+
+    constructor(tokenizer: ORTTokenizerNative) : this(tokenizer.padToken)
+
+    fun collate(batch: List<ORTDataCurator.TrainingSample>): CollatedBatch {
+        val padToken = this.padToken
+        val padLabel = -100
+
+        val maxLength = batch.maxOf { it.inputIds.size }
+
+        val inputIdsPadded = batch.map { sample ->
+            val padded = sample.inputIds + List(maxLength - sample.inputIds.size) { padToken }
+            padded.map { it?.toLong() ?: 0 }.toLongArray()
+        }
+
+        // Per-SEQUENCE labels must NOT be padded to the sequence length.
+        //
+        // Padding them would turn one label per example back into one per token, which is precisely
+        // what the native side uses to infer the label rank: `training_inputs.h::labels_shape` reads
+        // `batch*seq` as `[batch, seq]` and `batch` as `[batch]`. Padding here would make a
+        // classification graph receive a per-token label tensor and either throw inside ORT or, worse,
+        // bind a wrongly-shaped tensor. The two halves have to agree, and this is the half that decides.
+        val labelsPadded = batch.map { sample ->
+            if (sample.perSequenceLabel) {
+                sample.labels.map { it.toLong() }.toLongArray()
+            } else {
+                val padded = sample.labels + List(maxLength - sample.labels.size) { padLabel }
+                padded.map { it.toLong() }.toLongArray()
+            }
+        }
+
+        // Create attention mask: 1 for non-pad tokens, 0 for pad tokens
+        val attentionMaskPadded = batch.map { sample ->
+            // Original tokens get attention (1), padded tokens don't (0)
+            val originalLength = sample.inputIds.size
+            val paddingLength = maxLength - originalLength
+
+            val attentionMask = List(originalLength) { 1L } + List(paddingLength) { 0L }
+            attentionMask.toLongArray()
+        }
+
+        return CollatedBatch(
+            inputIds = inputIdsPadded.toTypedArray(),
+            labels = labelsPadded.toTypedArray(),
+            attentionMask = attentionMaskPadded.toTypedArray(),
+            sequenceLength = maxLength,
+            batchSize = batch.size
+        )
+    }
+
+    data class CollatedBatch(
+        val inputIds: Array<LongArray>,
+        val labels: Array<LongArray>,
+        val attentionMask: Array<LongArray>,
+        val sequenceLength: Int,
+        val batchSize: Int
+    )
+}
+
+// Interface for preprocessing functions
+interface TaskPreprocessor {
+    fun preprocess(json: JSONObject): Pair<String, String>
+
+    /**
+     * The per-SEQUENCE class label for this example, or `null` when the objective is token-level.
+     *
+     * #33: a sequence-classification graph declares `labels[batch]` — one label per example, not one
+     * per token — which is the axis that separates it from every decoder objective
+     * (`TaskSpec.label_shape`). The native binder already handles both: `training_inputs.h` derives the
+     * label rank from how many label elements the caller actually supplies.
+     *
+     * Additive with a default rather than a changed signature, because [TaskPreprocessor] is public
+     * API — callers pass their own through `DatasetConfig.customPreprocess`. Returning `null` (the
+     * default) keeps every existing preprocessor on the token-level path unchanged.
+     *
+     * When this returns non-null, [preprocess] is not consulted for the label; only its input text is.
+     */
+    fun classLabel(json: JSONObject): Int? = null
+
+    /**
+     * Whether this task's examples must be tokenized **the way `generate` will tokenize the prompt**
+     * at inference, rather than as bare text.
+     *
+     * #37. Declaring `true` makes the curator, for every row:
+     *  1. render the prompt through the package's chat template when it ships one — matching
+     *     `ORTGeneratorNative.generate`, which wraps its prompt via
+     *     [ORTConversationState.addUserMessage] whenever `tokenizer.chatTemplate` is non-null;
+     *  2. **prepend BOS**, which `generate` does for the first turn (`prependBos =
+     *     pastAttentionMaskLength == 0`) while `tokenize`'s own default is `false`;
+     *  3. terminate the completion with EOS, so the model has a stop signal instead of running to
+     *     `maxNewTokens`.
+     *
+     * (2) was a real, measured mismatch: training tokenized without BOS while every generation began
+ * with it. (1) *was* latent for every package: the export puts the template in a sibling
+ * `chat_template.jinja` that `ORTTokenizerNative` did not read, so `chatTemplate` was null and
+ * neither side templated. It reads the sibling now, so (1) is live wherever Pebble can render the
+ * template — SmolLM2's it can, FunctionGemma's it cannot. That is still why this is expressed as
+ * "match the generate path" rather than "apply the chat template": the two coincide only when a
+ * template is actually loaded, and whether one loads is now a per-package fact.
+     *
+     * **This does not, on its own, make the #37 tool-call demo converge.** With BOS parity and EOS in
+     * place the run still collapses to a single repeated token at inference despite a training loss
+     * of ~0.006 — see the #37 self-check for where that investigation stands.
+     *
+     * Additive with a default of `false` for the same reason as [classLabel] — [TaskPreprocessor] is
+     * public API, and every existing task (`cola`, `boolq`, …) keeps its raw formatting untouched.
+     */
+    fun formatsPromptForGeneration(): Boolean = false
+}
+
+/**
+ * The task names [getPreprocessFunctionForTask] accepts, and what each one reads.
+ *
+ * ### Why this is public
+ *
+ * `DatasetConfig.task` is a free-form string that must match one of these exactly, and the only
+ * record of the valid set was the `when` below. So the showcase app's Configuration screen offered a
+ * text field with the names listed in a help paragraph beside it — a typo produced
+ * `Unsupported task: mobileactions` at the start of a training run, minutes after the mistake was
+ * made and on a different screen from where it was made.
+ *
+ * Exposing the registry lets a caller offer a picker instead of a spelling test, and keeps that
+ * picker from drifting: [TASKS] and the dispatch are checked against each other by
+ * `DataUtilParseTest`, so adding a preprocessor without listing it here fails the build.
+ */
+object Tasks {
+    /** One row per supported preprocessor: the wire name and what its JSONL rows must contain. */
+    data class Task(val name: String, val description: String)
+
+    val TASKS: List<Task> = listOf(
+        Task("logiqa", "multiple-choice reading comprehension: text, question, options, answer"),
+        Task("boolq", "yes/no questions over a passage: question, passage, answer"),
+        Task("mini_personalqa", "personal question/answer pairs"),
+        Task("mini_recommendation", "recommendation prompts and responses"),
+        Task("cola", "grammatical-acceptability judgements, as generation"),
+        Task("cola_cls", "the same data as a sequence-classification objective"),
+        Task("mobile_actions", "instruction -> tool call, matching the Tool calls allowlist"),
+    )
+
+    /** Just the names, in declaration order. */
+    val NAMES: List<String> get() = TASKS.map { it.name }
+
+    fun describe(name: String): String? = TASKS.firstOrNull { it.name == name }?.description
+
+    /** Whether [name] resolves to a preprocessor in [getPreprocessFunctionForTask]. */
+    @JvmStatic
+    fun isRegistered(name: String?): Boolean =
+        name != null && NAMES.any { it.equals(name, ignoreCase = true) }
+
+    /**
+     * Settle the task for a run, and fail **here** if it names no preprocessor.
+     *
+     * ### Why this is a separate step
+     *
+     * `DatasetConfig.task ?: package.taskName` was resolved independently at two call sites and
+     * handed straight to [ORTTrainerNative]'s constructor, which builds the curator, which calls
+     * [getPreprocessFunctionForTask], which throws. That throw happened inside a `launch` on
+     * `LLMRepository`'s own scope, so it did not reach the caller's `try` at all — it reached the
+     * thread's uncaught handler and **took the whole app down**:
+     *
+     *     FATAL EXCEPTION: main
+     *     java.lang.IllegalArgumentException: Unsupported task: none.
+     *         at DataUtilKt.getPreprocessFunctionForTask(DataUtil.kt:175)
+     *         at ORTTrainerNative.<init>(ORTTrainerNative.kt:42)
+     *
+     * The message was also unhelpful in a specific way: `none` is not something the user typed. It is
+     * [ORTTrainingConfig]'s default, reached because the caller left `DatasetConfig.task` null and
+     * packages ship no task declaration — so the honest report is "nothing named a task", not
+     * "'none' is unsupported".
+     *
+     * Called before the coroutine is launched, this fails in the caller's frame where the app's
+     * `catch` can show it, and names both the valid set and where to set it.
+     *
+     * @param requested what the caller asked for ([com.martinkorelic.mobiletransformers.config.DatasetConfig.task]).
+     * @param declaredByPackage the installed package's own declaration, used when the caller names none.
+     * @param hasCustomPreprocess when true the name is never dispatched on, so anything is allowed.
+     */
+    @JvmStatic
+    fun resolve(
+        requested: String?,
+        declaredByPackage: String?,
+        hasCustomPreprocess: Boolean = false,
+    ): String {
+        val chosen = requested?.takeIf { it.isNotBlank() }
+            ?: declaredByPackage?.takeIf { it.isNotBlank() }
+            ?: UNSET
+        if (hasCustomPreprocess || isRegistered(chosen)) return chosen
+        val named = if (chosen == UNSET) {
+            "No task was named: DatasetConfig.task is unset and the installed package declares none"
+        } else {
+            "'$chosen' is not a known task"
+        }
+        throw IllegalArgumentException(
+            "$named. The trainer cannot parse a dataset without knowing its shape. Set " +
+                "DatasetConfig.task to one of ${NAMES.joinToString(", ")}, or supply a " +
+                "customPreprocess function.",
+        )
+    }
+
+    /** [ORTTrainingConfig.taskName]'s default — the sentinel meaning "nobody said". */
+    const val UNSET: String = "none"
+}
+
+// Factory function using the interface
+fun getPreprocessFunctionForTask(
+    taskName: String,
+    customPreprocess: TaskPreprocessor? = null
+): TaskPreprocessor {
+    if (customPreprocess != null) {
+        return customPreprocess
+    }
+
+    return when (taskName.lowercase()) {
+        "logiqa" -> LogiqaPreprocessor
+        "boolq" -> BoolqPreprocessor
+        "mini_personalqa" -> MiniPersonalQAPreprocessor
+        "mini_recommendation" -> MiniRecommendationPreprocessor
+        "cola" -> CoLAPreprocessor
+        "cola_cls" -> CoLAClassificationPreprocessor
+        "mobile_actions" -> MobileActionsPreprocessor
+        else -> throw IllegalArgumentException("Unsupported task: $taskName. Please provide a customPreprocess function.")
+    }
+}
+
+// Concrete implementations
+object LogiqaPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val labelMap = mapOf(0 to "A", 1 to "B", 2 to "C", 3 to "D")
+
+        val article = json.optString("text", "")
+        val question = json.optString("question", "")
+        val optionsArray = json.optJSONArray("options")
+        val answer = json.optInt("answer", -1)
+
+        var options = ""
+        if (optionsArray != null) {
+            for (i in 0 until optionsArray.length()) {
+                val option = optionsArray.optString(i, "")
+                options += "${labelMap[i]} $option\n"
+            }
+        }
+
+        val input = "Write a multi-choice question for the following article:\n" +
+                "Article: $article\n" +
+                "Question: $question\n" +
+                "Options: $options" +
+                "Answer: \n\n "
+
+        val label = labelMap[answer] ?: ""
+
+        return input to label
+    }
+}
+
+object BoolqPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val question = json.optString("question", "")
+        val passage = json.optString("passage", "")
+        val answer = json.optString("answer", "")
+
+        val input = "Q: $question?\nP: $passage\nA: \n\n "
+
+        return input to answer
+    }
+}
+
+object MiniPersonalQAPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val questionText = json.optString("question", "")
+        val choicesObject = json.optJSONObject("choices")
+        val correctAnswer = json.optString("correct_answer", "")
+
+        // Build the formatted question
+        var formatted = "Question: $questionText\n\n"
+
+        if (choicesObject != null) {
+            val keys = choicesObject.keys()
+            while (keys.hasNext()) {
+                val choiceKey = keys.next()
+                val choiceValue = choicesObject.optString(choiceKey, "")
+                formatted += "$choiceKey: $choiceValue\n"
+            }
+        }
+
+        val input = formatted + "\n\nAnswer: "
+        val label = correctAnswer
+
+        return input to label
+    }
+}
+
+object MiniRecommendationPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val userQuery = json.optString("prompt", "")
+        val recommendation = json.optString("recommendation", "")
+
+        val formatted = "Recommend best actions based on this user query: $userQuery"
+
+        val input = formatted + "\n\nAnswer: "
+
+        val label = recommendation
+
+        return input to label
+    }
+}
+
+object CoLAPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val sentence = json.optString("sentence", "")
+        val label = json.optInt("label", 0)
+
+        val input = "Is this sentence grammatically acceptable? $sentence\nA: "
+        val output = if (label == 1) "acceptable" else "unacceptable"
+
+        return input to output
+    }
+}
+
+/**
+ * The same CoLA data as a real sequence-classification objective (#33).
+ *
+ * [CoLAPreprocessor] stringifies the class index into `"acceptable"`/`"unacceptable"` so it fits the
+ * decoder's text-to-text contract — a workaround for having only one label shape. This one keeps the
+ * label a class index and lets the graph's `labels[batch]` input receive it directly.
+ *
+ * Registered as `cola_cls` rather than replacing `cola`, because the two are genuinely different
+ * objectives over the same file and a package declares which one it trains.
+ */
+object CoLAClassificationPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> =
+        json.optString("sentence", "") to ""
+
+    override fun classLabel(json: JSONObject): Int = json.optInt("label", 0)
+}
+/**
+ * The #37 tool-call objective: a natural-language instruction in, a function call as JSON out.
+ *
+ * Reads the rows `mobiletransformers agent-dataset` writes — from `google/mobile-actions`, from any
+ * corpus in that shape, or synthesised per-user from an app's own allowlist. All three paths emit the
+ * same two keys, which is what lets one preprocessor serve the imported corpus and the personalized
+ * set alike.
+ *
+ * The completion is **the exact JSON `FunctionCallValidator.validate` parses**, not a prose rendering
+ * of it. That is deliberate and is the whole design: what the model is supervised to emit and what the
+ * app will accept are the same object, so a model that has learned the task produces output that
+ * passes validation by construction rather than after a repair step.
+ *
+ * Prompt/answer split and `-100` masking are handled by [ORTDataCurator]; this only names the halves.
+ */
+object MobileActionsPreprocessor : TaskPreprocessor {
+    override fun preprocess(json: JSONObject): Pair<String, String> {
+        val prompt = json.optString("prompt", "")
+        val completion = json.optString("completion", "")
+        // Both blank-checked by the curator, which drops the row. A row missing either half is a
+        // generator bug rather than untrusted input, so it is not worth failing the whole run over.
+        return prompt to completion
+    }
+
+    /**
+     * #37: a tool call is produced by `MobileTransformerModel.generateToolCall`, which goes through
+     * the ordinary generate path. Its examples must therefore be tokenized the way that path
+     * tokenizes a prompt — BOS included — or the model is fitted to a token sequence it is never
+     * asked to continue.
+     */
+    override fun formatsPromptForGeneration(): Boolean = true
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/FileUtil.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/FileUtil.kt
similarity index 68%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/FileUtil.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/FileUtil.kt
index 911590b..08c1e37 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/FileUtil.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/FileUtil.kt
@@ -1,6 +1,13 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.content.res.AssetManager
+import com.martinkorelic.mobiletransformers.constants.CoreConfigId
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.constants.IndexingMode
+import com.martinkorelic.mobiletransformers.constants.MemoryConfigId
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.constants.SearchType
 import org.json.JSONObject
 import java.io.File
 import java.io.FileInputStream
@@ -37,13 +44,17 @@ fun parseTrainingArguments(jsonPath: String): ORTTrainingConfig {
         parseSchedulerConfigFromRoot(schedulerType, trainConfig)
     }
 
-    // Parse device options
+    // Parse device options.
+    //
+    // `low_mem` is the default HERE and nowhere else: exported training configs carry no device
+    // section, so this branch decides the allocator for every training run, and `high_perf`'s arena
+    // is what got a 270M LoRA run killed at 3.4 GB. Inference keeps `high_perf` — a forward-only
+    // session benefits from the arena and does not accumulate a backward plan.
     val deviceOptions = if (trainConfig.has("deviceOptions")) {
         val deviceOptionsJson = trainConfig.getJSONObject("deviceOptions")
-        parseDeviceOptions(deviceOptionsJson)
+        parseDeviceOptions(deviceOptionsJson, defaultMemoryConfigId = MemoryConfigId.LOW_MEM.wire)
     } else {
-        // Fallback: try to parse from root level for backward compatibility
-        parseDeviceOptionsFromRoot(trainConfig)
+        parseDeviceOptions(trainConfig, defaultMemoryConfigId = MemoryConfigId.LOW_MEM.wire)
     }
 
     // Parse dataset options
@@ -116,68 +127,67 @@ fun parseDatasetOptionsFromRoot(trainConfig: JSONObject): DatasetOptions {
     )
 }
 
-// Helper function to parse device options from a dedicated JSON object
-fun parseDeviceOptions(deviceOptionsJson: JSONObject): DeviceOptions {
+/**
+ * Parse device options, validating every closed-set field through its enum's `fromWire` (#6).
+ *
+ * The fields stay `String` because they cross the JNI boundary as strings, but an unrecognized value
+ * now throws at the parse boundary instead of being handed to native code that would quietly fall
+ * back to a default execution provider or memory profile.
+ */
+fun parseDeviceOptions(
+    deviceOptionsJson: JSONObject,
+    /**
+     * What to use when the config declares no `memoryConfigId`.
+     *
+     * Exported `training_config.json` files carry no device section at all, so this default IS the
+     * setting for every training run — and `high_perf` (arena + memory pattern) is what took a
+     * 270M-parameter LoRA run to 3.4 GB and got it killed. See [ORTTrainingConfig.deviceOptions].
+     */
+    defaultMemoryConfigId: String = MemoryConfigId.HIGH_PERF.wire,
+): DeviceOptions {
     return DeviceOptions(
         enableProfiling = deviceOptionsJson.optBoolean("enableProfiling", false),
-        coreConfigId = deviceOptionsJson.optString("coreConfigId", "opt1"),
-        memoryConfigId = deviceOptionsJson.optString("memoryConfigId", "high_perf"),
-        executionProvider = deviceOptionsJson.optString("executionProvider", "cpu")
+        coreConfigId = CoreConfigId.fromWire(deviceOptionsJson.optString("coreConfigId", "opt1")).wire,
+        memoryConfigId =
+            MemoryConfigId.fromWire(
+                deviceOptionsJson.optString("memoryConfigId", defaultMemoryConfigId),
+            ).wire,
+        executionProvider =
+            ExecutionProvider.fromWire(deviceOptionsJson.optString("executionProvider", "cpu")).wire,
     )
 }
 
-// Helper function to parse device options from root level (backward compatibility)
-fun parseDeviceOptionsFromRoot(trainConfig: JSONObject): DeviceOptions {
-    return DeviceOptions(
-        enableProfiling = trainConfig.optBoolean("enableProfiling", false),
-        coreConfigId = trainConfig.optString("coreConfigId", "opt1"),
-        memoryConfigId = trainConfig.optString("memoryConfigId", "high_perf"),
-        executionProvider = trainConfig.optString("executionProvider", "cpu")
-    )
-}
-
-private fun parseSchedulerConfig(schedulerType: String, schedulerOptions: JSONObject): SchedulerConfig {
-    return when (schedulerType.lowercase()) {
-        "linear" -> SchedulerConfig.Linear(
-            learningRate = schedulerOptions.optDouble("learningRate", 1e-4).toFloat(),
-            startFactor = schedulerOptions.optDouble("startFactor", 1.0).toFloat(),
-            endFactor = schedulerOptions.optDouble("endFactor", 0.333).toFloat(),
+// Backward compatibility: the same fields read from the config root.
+fun parseDeviceOptionsFromRoot(trainConfig: JSONObject): DeviceOptions = parseDeviceOptions(trainConfig)
+
+/**
+ * Build the scheduler config from [options], dispatching on the TYPED [SchedulerType].
+ *
+ * #6/#10 fix: this used to `when` on the raw string and fall through to
+ * `println("Warning: Unknown scheduler type ...")` + a silent Linear default. `println` goes to
+ * stdout, which Android drops on release builds — so a typo'd `"consine"` trained on a completely
+ * different LR schedule with no visible signal. `SchedulerType.fromWire` throws instead, which is the
+ * canonical "typed fail-closed parsing" rule. The root-level variant was a verbatim copy of this
+ * function; both now share it, differing only in which JSONObject the values are read from.
+ */
+private fun parseSchedulerConfig(schedulerType: String, options: JSONObject): SchedulerConfig =
+    when (SchedulerType.fromWire(schedulerType.lowercase())) {
+        SchedulerType.LINEAR -> SchedulerConfig.Linear(
+            learningRate = options.optDouble("learningRate", 1e-4).toFloat(),
+            startFactor = options.optDouble("startFactor", 1.0).toFloat(),
+            endFactor = options.optDouble("endFactor", 0.333).toFloat(),
         )
 
-        "cosine" -> SchedulerConfig.Cosine(
-            learningRate = schedulerOptions.optDouble("learningRate", 1e-4).toFloat(),
-            minLearningRate = schedulerOptions.optDouble("minLearningRate", 0.0).toFloat(),
-            warmupSteps = schedulerOptions.optInt("warmupSteps", 10)
+        SchedulerType.COSINE -> SchedulerConfig.Cosine(
+            learningRate = options.optDouble("learningRate", 1e-4).toFloat(),
+            minLearningRate = options.optDouble("minLearningRate", 0.0).toFloat(),
+            warmupSteps = options.optInt("warmupSteps", 10),
         )
-
-        else -> {
-            println("Warning: Unknown scheduler type '$schedulerType', using linear scheduler")
-            SchedulerConfig.Linear()
-        }
     }
-}
-
-private fun parseSchedulerConfigFromRoot(schedulerType: String, trainConfig: JSONObject): SchedulerConfig {
-    // Backward compatibility: parse from root level
-    return when (schedulerType.lowercase()) {
-        "linear" -> SchedulerConfig.Linear(
-            learningRate = trainConfig.optDouble("learningRate", 1e-4).toFloat(),
-            startFactor = trainConfig.optDouble("startFactor", 1.0).toFloat(),
-            endFactor = trainConfig.optDouble("endFactor", 0.333).toFloat(),
-        )
-
-        "cosine" -> SchedulerConfig.Cosine(
-            learningRate = trainConfig.optDouble("learningRate", 1e-4).toFloat(),
-            minLearningRate = trainConfig.optDouble("minLearningRate", 0.0).toFloat(),
-            warmupSteps = trainConfig.optInt("warmupSteps", 10)
-        )
 
-        else -> {
-            println("Warning: Unknown scheduler type '$schedulerType', using linear scheduler")
-            SchedulerConfig.Linear()
-        }
-    }
-}
+// Backward compatibility: the same fields read from the config root instead of a "scheduler" object.
+private fun parseSchedulerConfigFromRoot(schedulerType: String, trainConfig: JSONObject): SchedulerConfig =
+    parseSchedulerConfig(schedulerType, trainConfig)
 
 fun parseGenerationArguments(jsonPath: String): ORTGenerationConfig {
 
@@ -197,7 +207,9 @@ fun parseGenerationArguments(jsonPath: String): ORTGenerationConfig {
     val sampling = if (json.has("sampling")) {
         val samplingJson = json.getJSONObject("sampling")
         SamplingOptions(
-            method = samplingJson.optString("method", "greedy"),
+            // #6: validated at the boundary — an unknown method used to reach the native
+            // sampler, and ORTGeneratorGenAI silently treated it as greedy.
+            method = SamplingMethod.fromWire(samplingJson.optString("method", "greedy")).wire,
             temperature = samplingJson.optDouble("temperature", 1.0).toFloat(),
             topK = samplingJson.optInt("topK", 10),
             topP = samplingJson.optDouble("topP", 0.9).toFloat(),
@@ -258,7 +270,9 @@ fun parseRagArguments(jsonPath: String): ORTRagConfig {
         onnxName = json.optString("onnxName", "embedding_model"),
         embeddingDimension = json.optInt("embeddingDimension", 256),
         topK = json.optInt("topK", 10),
-        searchType = json.optString("searchType", "semantic"),
+        searchType = SearchType.fromWire(json.optString("searchType", "semantic")).wire,
+        minScore = json.optDouble("minScore", 0.0),
+        indexingMode = IndexingMode.fromWire(json.optString("indexingMode", "precompute")).wire,
         maxTextLength = json.optInt("maxTextLength", 1024),
         chunkSize = json.optInt("chunkSize", 512),
         chunkOverlap = json.optInt("chunkOverlap", 50),
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenAISpike.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenAISpike.kt
new file mode 100644
index 0000000..91bc378
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenAISpike.kt
@@ -0,0 +1,24 @@
+package com.martinkorelic.mobiletransformers
+
+/**
+ * JNI binding for the GenAI external-data-swap spike (#10, Gate 0.1). Backed by `cpp/genai_spike.cpp`.
+ *
+ * [runOneToken] loads `<dir>` with the stable `OgaCreateModel`, generates one greedy token, and returns
+ * `"token=<id>;fp=<logits fingerprint>;rssPre=..;rssLoaded=..;rssTok=.."`. The device test drives it before
+ * and after overwriting one external weight `.bin` and asserts the fingerprint changes — proving GenAI reads
+ * the package's external data at construction (F2), with no graph rewrite and no fork.
+ */
+object GenAISpike {
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+    external fun runOneToken(dir: String, prompt: String): String
+
+    /** Parse the `key=value;...` metrics string returned by [runOneToken]. */
+    fun parse(result: String): Map<String, String> =
+        result.split(";").mapNotNull {
+            val kv = it.split("=", limit = 2)
+            if (kv.size == 2) kv[0] to kv[1] else null
+        }.toMap()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenerateCallback.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenerateCallback.kt
new file mode 100644
index 0000000..28b3499
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/GenerateCallback.kt
@@ -0,0 +1,36 @@
+package com.martinkorelic.mobiletransformers
+
+/**
+ * Public per-token generation progress (#19), mapped 1:1 from the internal `InferenceProgress` so app code
+ * never imports repository/`ORT*` types.
+ */
+data class GenerateProgress(
+    val token: String,
+    val tokenId: Int,
+    val totalDecodedTokens: Int,
+    val prefillTimeMs: Long = 0L,
+    val timeToLoadModelMs: Long = 0L,
+    val generationTimeMs: Long = 0L,
+    val avgTokensPerSecond: Double = 0.0,
+    val isCompleted: Boolean = false,
+    /** Tokens the prompt occupied, after templating and after any trim. */
+    val promptTokenCount: Int = 0,
+    /** Tokens the model can attend to at once, or 0 when the package declares none. */
+    val contextLimit: Int = 0,
+)
+
+/**
+ * Public streaming callback for [MobileTransformerModel.generate] (#19). Mirrors the internal
+ * `GenerationCallback`; the facade drives the identical ordered sequence on every engine
+ * (`onStartGeneration` → N×`onPartialResult` → `onCompletion`, or `onError`) — cross-engine parity is
+ * locked by #24.
+ */
+interface GenerateCallback {
+    fun onStartGeneration(progress: GenerateProgress) {}
+
+    fun onPartialResult(progress: GenerateProgress) {}
+
+    fun onCompletion(progress: GenerateProgress) {}
+
+    fun onError(error: Throwable) {}
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformerModel.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformerModel.kt
new file mode 100644
index 0000000..6d1da5a
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformerModel.kt
@@ -0,0 +1,259 @@
+package com.martinkorelic.mobiletransformers
+
+import com.martinkorelic.mobiletransformers.agent.FunctionCallValidator
+import com.martinkorelic.mobiletransformers.agent.RejectedCallException
+import com.martinkorelic.mobiletransformers.agent.ToolCallResult
+import com.martinkorelic.mobiletransformers.agent.ToolCallParser
+import com.martinkorelic.mobiletransformers.agent.ToolPromptBuilder
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedRoundResult
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.PromptAssembler
+import com.martinkorelic.mobiletransformers.rag.PromptStrategy
+import com.martinkorelic.mobiletransformers.runtime.ClassificationResult
+import com.martinkorelic.mobiletransformers.runtime.GenerationResult
+import com.martinkorelic.mobiletransformers.runtime.GroundedResult
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.IngestResult
+import com.martinkorelic.mobiletransformers.runtime.MergeResult
+import com.martinkorelic.mobiletransformers.runtime.ModelSession
+import com.martinkorelic.mobiletransformers.runtime.PushResult
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+import com.martinkorelic.mobiletransformers.training.TrainingJob
+
+/**
+ * The stable public model handle (#17, extended by #19). Every method delegates to the [ModelSession]; no
+ * engine logic and no `ORT*`/`*Native`/`Job`/repository type appears in this class's surface. Obtained
+ * from [MobileTransformers.fromPretrained].
+ */
+class MobileTransformerModel internal constructor(
+    private val session: ModelSession,
+    val capabilities: RuntimeCapabilities,
+    val repoId: String,
+) {
+    /** The engine resolved for this handle (Native floor or GenAI). */
+    val engine: InferenceEngine get() = capabilities.engine
+
+    /** Features actually installed in this package. */
+    val installedFeatures: Set<ModelFeature> get() = capabilities.availableFeatures
+
+    /** #19: select/validate the PEFT method against the installed package (no native call, no download). */
+    suspend fun applyPeft(peft: PeftConfig) = session.applyPeft(peft)
+
+    /**
+     * One-shot training: suspends until the run finishes and returns the result.
+     *
+     * For status/event flows, cooperative cancellation or resume, use [trainingJob].
+     */
+    suspend fun train(
+        dataset: DatasetConfig,
+        config: TrainConfig = TrainConfig(),
+        callback: TrainCallback? = null,
+    ): TrainingResult = session.train(dataset, config, callback)
+
+    /**
+     * The lifecycle-shaped training handle for this model (#18): `status`/`events` flows, cooperative
+     * `cancel(saveCheckpoint)`, and `checkpoint()`/`canResume`.
+     *
+     * The whole `training/` package was unreachable before this accessor existed — in particular there
+     * was no way to cancel a run from the public API.
+     */
+    fun trainingJob(): TrainingJob = session.trainingJob()
+
+    suspend fun merge(): MergeResult = session.merge()
+
+    suspend fun generate(
+        prompt: String,
+        config: GenerationConfig = GenerationConfig(),
+        callback: GenerateCallback? = null,
+    ): GenerationResult = session.generate(prompt, config, callback)
+
+    suspend fun retrieve(
+        query: String,
+        config: RagConfig = RagConfig(),
+        callback: RetrieveCallback? = null,
+    ): RetrievalResult = session.retrieve(query, config, callback)
+
+    /** #26: ingest a `.txt`/`.md`/`.jsonl` file into the RAG vector store. */
+    suspend fun ingest(
+        path: String,
+        config: RagConfig = RagConfig(),
+        progress: IngestionProgress? = null,
+    ): IngestResult = session.ingest(path, config, progress)
+
+    /**
+     * #33: classify [text] with a sequence-classification package.
+     *
+     * The other half of encoder support. Fine-tuning a BERT-family classifier on device worked end to
+     * end and the result could never be *asked* anything — this handle offered generate, retrieve,
+     * ingest and train, every one of which assumes a decoder.
+     *
+     * Check [RuntimeCapabilities.supportsClassification] first. Asking a decoder to classify throws
+     * rather than reading generation logits as class scores, which would be a confident wrong answer
+     * rather than an error.
+     *
+     * ```kotlin
+     * if (model.capabilities.supportsClassification) {
+     *     val result = model.classify("this sentence is grammatical")
+     *     show(result.best?.label, result.best?.score)
+     * }
+     * ```
+     *
+     * @param device where to run it; defaults to the same CPU floor as everything else.
+     * @param topK how many labels to return in [ClassificationResult.top]. The full ranking is always
+     *   in `scores`.
+     */
+    suspend fun classify(
+        text: String,
+        device: DeviceConfig = DeviceConfig(),
+        topK: Int = 5,
+    ): ClassificationResult = session.classify(text, device, topK)
+
+    /**
+     * #27: grounded generation — retrieve → assemble prompt → generate. `result.prompt` is inspectable.
+     *
+     * Pass [callback] to stream the answer as it is produced; it observes the generation leg, so its
+     * first event doubles as "retrieval is done". A grounded turn is the slowest thing this SDK does
+     * — an embedding pass, a vector search, then a decode over a prompt several hundred tokens long
+     * — and it was the only one with no way to watch it happen.
+     *
+     * Pass [retrieveCallback] to see the matches **as soon as they are retrieved**, rather than in
+     * the returned [GroundedResult] after the answer is complete. A UI that wants to show its
+     * sources before the answer they produced needs them at that moment, not at the end.
+     */
+    suspend fun generateWithRag(
+        query: String,
+        rag: RagConfig = RagConfig(),
+        generation: GenerationConfig = GenerationConfig(),
+        promptStrategy: PromptStrategy = PromptAssembler.DEFAULT,
+        callback: GenerateCallback? = null,
+        retrieveCallback: RetrieveCallback? = null,
+    ): GroundedResult =
+        session.generateWithRag(query, rag, generation, promptStrategy, callback, retrieveCallback)
+
+    /** #19 surface; throws `NotImplementedFeatureException` until the #22 adapter push-back lands. */
+    suspend fun pushAdapter(hubConfig: HubConfig, repoId: String): PushResult =
+        session.pushAdapter(hubConfig, repoId)
+
+    /**
+     * #37: generate a **validated tool call** for `instruction`, or a first-class refusal.
+     *
+     * This is the seam the tool-call feature was missing: the validator and the intent binder existed
+     * and were tested, but nothing routed generated text into them, so raw output and the boundary that
+     * judges it never met outside of unit tests.
+     *
+     * The safety contract holds by construction. [ToolCallResult.Accepted] is the only carrier of a
+     * [com.martinkorelic.mobiletransformers.agent.ValidatedCall], only [FunctionCallValidator] can build
+     * one, and `IntentBinder` accepts nothing else — so there is no path from model output to an Android
+     * intent that skips the allowlist, and the reachable set of intents is fixed when `validator` is
+     * constructed.
+     *
+     * Build `validator` from the action schema written beside the training set, so the boundary enforced
+     * here is the same artifact the model was trained toward:
+     *
+     * ```kotlin
+     * val validator = FunctionCallValidator.fromSchema(File(packageDir, "action_schema.json"))
+     * when (val result = model.generateToolCall("wake me at 07:30", validator)) {
+     *     is ToolCallResult.Accepted -> show(result.dryRun())   // willExecute = false
+     *     is ToolCallResult.Rejected -> show("I can't do that: ${result.reason}")
+     *     is ToolCallResult.NoCall   -> show(result.raw)        // it answered in words
+     * }
+     * ```
+     *
+     * **[ToolCallResult.NoCall] is why this is usable as the only chat entry point.** Declare the
+     * allowlist on every turn and let the outcome say what happened: prose comes back as prose, a
+     * call comes back validated. That removes the "am I asking for a tool call right now?" switch a
+     * caller would otherwise have to put in front of the user, who has no way to know the answer
+     * before seeing the reply.
+     *
+     * @param parser how to read a call out of the model's text. Defaults to the one suited to this
+     *   package's base model — **FunctionGemma does not emit JSON**, so a fixed JSON reader rejected
+     *   every well-formed call it made. A parser chooses *which candidate* to check and nothing else;
+     *   every allowlist and rule check still runs, so it cannot admit an undeclared action.
+     * @param declareTools prepend the allowlist as a tool declaration the model can read. Without it
+     *   the model is asked to call one of a set of functions it was never shown, which only a model
+     *   fine-tuned on this exact allowlist can do. Turn it off when the caller has already framed the
+     *   prompt itself.
+     */
+    suspend fun generateToolCall(
+        instruction: String,
+        validator: FunctionCallValidator,
+        config: GenerationConfig = GenerationConfig(),
+        parser: ToolCallParser = ToolCallParser.forDialect(capabilities.toolCalling.dialect),
+        declareTools: Boolean = true,
+        callback: GenerateCallback? = null,
+    ): ToolCallResult {
+        val prompt = if (declareTools) {
+            // The whole turn, not declarations glued to an instruction: FunctionGemma emits its call
+            // grammar inside a model turn, and nothing else on the device supplies that framing.
+            ToolPromptBuilder.prompt(validator.allowlist, parser, instruction)
+        } else {
+            instruction
+        }
+        // Suppress the tokenizer's chat template only when the builder above emitted turns of its own
+        // (the FunctionGemma dialect), or the two framings nest. The JSON dialect emits no turn
+        // markers, so there the template is still what supplies them and must be left alone.
+        // Harmless before the tokenizer learned to read `chat_template.jinja` — no package had a
+        // template to apply — and a live distinction now that they do.
+        val framedHere = declareTools && ToolPromptBuilder.framesOwnTurns(parser)
+        val raw = session.generate(
+            prompt,
+            if (framedHere) config.copy(applyChatTemplate = false) else config,
+            callback,
+).text
+        val call = parser.parse(raw)
+            // Not a refusal: the model said something that is not a call. The raw text is the answer,
+            // and reporting it as "rejected" both misleads the user and hides parser mismatches —
+            // see ToolCallResult.NoCall.
+            ?: return ToolCallResult.NoCall(raw = raw)
+        return try {
+            ToolCallResult.Accepted(raw = raw, call = validator.validate(call))
+        } catch (e: RejectedCallException) {
+            // Refusal is the expected answer for untrusted output, so it is a value, not a throw.
+            ToolCallResult.Rejected(raw = raw, reason = e.message ?: "rejected")
+        }
+    }
+
+    /**
+     * #35/#36: run **one** federated round on this device — import the cohort's global adapter, train
+     * locally under [localTraining]'s bounds, and export this device's update.
+     *
+     * Nothing is uploaded here: the round returns bytes and accepts bytes, so the transport (HTTPS to
+     * `federated serve`, or `adb` in a device test) stays the caller's choice. `config` is checked
+     * first and fails closed naming the missing protection — consent, TLS, auth, or the default-off
+     * `BuildConfig.FEDERATION_ENABLED` — before any tensor is read.
+     *
+     * ```kotlin
+     * val result = model.federatedRound(
+     *     config = FederatedConfig(gatewayUrl = "https://…", clientAuthToken = token,
+     *                              consent = FederatedConsent.GRANTED),
+     *     globalRecord = previousAggregate,   // null for round 0
+     *     roundNumber = 1,
+     *     localTraining = { round -> model.train(dataset, TrainConfig(maxSteps = 20)) },
+     * )
+     * upload(result.update)                   // result.payloadBytes is the #36 DoD measurement
+     * ```
+     */
+    suspend fun federatedRound(
+        config: FederatedConfig,
+        globalRecord: ByteArray?,
+        roundNumber: Int,
+        localTraining: LocalRoundTraining,
+        metrics: Map<String, Double> = emptyMap(),
+        train: Boolean = true,
+    ): FederatedRoundResult =
+        session.federatedRound(config, globalRecord, roundNumber, localTraining, metrics, train)
+
+    fun close() = session.close()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformers.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformers.kt
new file mode 100644
index 0000000..3ffb01b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformers.kt
@@ -0,0 +1,256 @@
+package com.martinkorelic.mobiletransformers
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Build
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.hub.DownloadProgress
+import com.martinkorelic.mobiletransformers.hub.DownloadProgressListener
+import com.martinkorelic.mobiletransformers.hub.HubDownloader
+import com.martinkorelic.mobiletransformers.hub.HubResolver
+import com.martinkorelic.mobiletransformers.packages.CacheIndex
+import com.martinkorelic.mobiletransformers.internal.runtime.RepositoryBackedModelSession
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+import com.martinkorelic.mobiletransformers.packages.DeviceCapabilities
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.PackageTask
+import com.martinkorelic.mobiletransformers.packages.ToolCallSupport
+import com.martinkorelic.mobiletransformers.repository.LLMRepository
+import com.martinkorelic.mobiletransformers.runtime.GenAiSupport
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.ModelRuntimeFactory
+import com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+/**
+ * Stable, HF-style entry point to the MobileTransformers SDK (#17). [fromPretrained] returns a
+ * [MobileTransformerModel] whose work is delegated to a [RepositoryBackedModelSession] wrapping the existing
+ * repositories — no engine rewrite. Public types stay neutral; the `ORT*` names remain internal.
+ */
+object MobileTransformers {
+
+    /**
+     * Load a locally-installed package into a working [MobileTransformerModel].
+     *
+     * The remote pull/install path is #21; this foundation resolves an already-installed package in
+     * [cacheDir] and models engine selection (Native default; GenAI is a *selectable* engine over the SAME
+     * package, not a second download — see [ModelFeature]). Fails closed with [ModelNotInstalledException]
+     * when the package is absent.
+     */
+    @JvmStatic
+    suspend fun fromPretrained(
+        context: Context,
+        repoId: String,
+        cacheDir: String = context.filesDir.absolutePath,
+        revision: String = "main",
+        variant: String? = null,
+        features: Set<ModelFeature> = setOf(ModelFeature.Inference),
+        engine: InferenceEngine = InferenceEngine.NATIVE,
+        hubConfig: HubConfig? = null,
+        onDownloadProgress: DownloadProgressListener? = null,
+    ): MobileTransformerModel {
+        val sanitized = PackageFormat.sanitizeRepoId(repoId)
+        val modelDir = File(cacheDir, sanitized)
+        if (!modelDir.isDirectory) {
+            // #21: not installed -> manifest-first pull + atomic install, then load.
+            val genaiRequested = engine == InferenceEngine.GENAI || features.any { it == ModelFeature.GenAI }
+            // Shared with PackageDownloadWorker: the two download paths must agree on which groups a
+            // feature set implies, or a background pull installs a different package than this one.
+            val featureGroups = DeviceCapabilities.downloadGroups(features)
+            try {
+                HubDownloader.downloadAndInstall(
+                    cacheDir = File(cacheDir),
+                    repoId = repoId,
+                    revision = revision,
+                    variant = variant,
+                    features = featureGroups,
+                    genai = genaiRequested,
+                    // #21: real device capabilities so VariantSelector can reject an incompatible
+                    // variant BEFORE downloading it, instead of taking manifest.defaultVariant blind.
+                    abis = DeviceCapabilities.abis(),
+                    totalMemMb = DeviceCapabilities.totalMemoryMb(context),
+                    endpoint = hubConfig?.endpoint ?: HubResolver.DEFAULT_ENDPOINT,
+                    token = hubConfig?.token,
+                    // Forwarded whole: the pull reports bytes, rate and phase, and re-deriving a
+                    // narrower triple here is what left the facade unable to say anything useful
+                    // about a multi-gigabyte transfer.
+                    onProgress = { progress -> onDownloadProgress?.onProgress(progress) },
+                )
+            } catch (e: Exception) {
+                throw ModelNotInstalledException(
+                    "package '$repoId' is not installed at $modelDir and the Hub pull failed: ${e.message}",
+                )
+            }
+            if (!modelDir.isDirectory) {
+                throw ModelNotInstalledException(repoId, cacheDir)
+            }
+        }
+
+        val repo = LLMRepository(context.applicationContext, cacheDir, initialModel = sanitized)
+        // #19: fail at construction (not first use) if a requested genuine feature isn't installed.
+        // Engine selectors (GenAI/ManualInference) are not downloads — skip them here.
+        val installed = detectFeatures(repo)
+        if (installed.isEmpty()) {
+            throw MissingArtifactException(
+                "package '$repoId' has no usable train/inference/embedding config under $modelDir",
+            )
+        }
+
+        features.filterNot { it.isEngineSelector }.forEach { requested ->
+            if (requested !in installed) throw FeatureNotInstalledException(requested, installed)
+        }
+
+        // GenAI is a selectable engine over the one shared package; #11 owns real GenAI wiring + fallback.
+        // Requesting the GenAI/ManualInference feature only sets the engine — it never downloads a 2nd group.
+        val resolvedEngine =
+            if (features.any { it == ModelFeature.GenAI }) InferenceEngine.GENAI else engine
+
+        // #19: GenAI needs the genai config in the shared package; else fail closed (no silent fallback here).
+        val genaiInstalled = File(modelDir, "inference/genai_config.json").isFile
+        if (resolvedEngine == InferenceEngine.GENAI && !genaiInstalled) {
+            throw EngineUnavailableException(
+                InferenceEngine.GENAI,
+                "inference/genai_config.json not found in the installed package (re-export with GenAI).",
+            )
+        }
+
+        // #17/#19: what a picker may offer — ModelRuntimeFactory's OWN rule, asked ahead of time.
+        //
+        // This used to apply two of the factory's three conditions, omitting the manifest's
+        // `supportedEngines`. FunctionGemma ships a genai_config.json but declares
+        // `supportedEngines: ["native"]`, so the facade advertised GenAI, the app offered it, and the
+        // factory then refused it mid-load with "explicitly requested but not selectable". See
+        // ModelRuntimeFactory.enginesAvailableFor.
+        val declaredEngines = declaredEnginesFor(modelDir)
+        val availableEngines = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = declaredEngines,
+            genaiConfigPresent = genaiInstalled,
+            genaiAvailable = GenAiSupport.available(),
+        )
+        if (resolvedEngine == InferenceEngine.GENAI && InferenceEngine.GENAI !in availableEngines) {
+            // Named at load, where the package is in hand, rather than as a null runtime discovered
+            // at the first generate() — which is what "Generation session was never created" was.
+            throw EngineUnavailableException(
+                InferenceEngine.GENAI,
+                "the installed package declares supportedEngines=${declaredEngines ?: "(none)"} for " +
+                    "its variant, so GenAI is not a valid engine for it. Gemma-3 packages are " +
+                    "exported through optimum rather than the GenAI builder and are Native-only. " +
+                    "Load it with engine=NATIVE.",
+            )
+        }
+
+        val capabilities =
+            RuntimeCapabilities(
+                engine = resolvedEngine,
+                availableEngines = availableEngines,
+                supportsTraining = repo.isTrainingAvailable,
+                supportsMerge = repo.isTrainingAvailable,
+                supportsRag = repo.isRagAvailable,
+                supportsEmbedding = repo.isRagAvailable,
+                // #34: scheduled training is exactly as available as training is — the scheduler is
+                // a WorkManager wrapper over the same TrainingJob, with no extra package requirement.
+                supportsScheduledTraining = repo.isTrainingAvailable,
+                availableFeatures = detectFeatures(repo),
+                // What the package IS, not only what it can do. Without this a caller cannot tell a
+                // classification encoder from a chat decoder, and can only discover the difference by
+                // asking for generation and reading the failure.
+                task = PackageTask.read(
+                    PackagePaths.forCache(modelDir.parentFile, modelDir.name).inference,
+                ),
+                // From the model's own chat template, with the names as a fallback. `repoId` is
+                // included because the manifest's `baseModelId` is provenance, not an install key —
+                // and because passing only the architecture (`gemma3_text`) is exactly the bug this
+                // replaces.
+                trainingParameterCount = manifestOf(modelDir)?.trainingParameterCount ?: 0L,
+            // Which fine-tuning technique this package carries. Recorded by the exporter since
+            // the training stage existed; read here for the first time.
+            peftMethods = manifestOf(modelDir)?.peftMethods.orEmpty().toSet(),
+                toolCalling = ToolCallSupport.read(
+                    tokenizerDir = PackagePaths.forCache(modelDir.parentFile, modelDir.name).tokenizer,
+                    hints = listOf(repoId, sanitized),
+                ),
+            )
+
+        val session =
+            RepositoryBackedModelSession(
+                repo = repo,
+                capabilities = capabilities,
+                modelDir = modelDir,
+                inferencePackagePath = PackagePaths.forCache(modelDir.parentFile, modelDir.name).inference.absolutePath,
+            )
+        return MobileTransformerModel(session, capabilities, repoId)
+    }
+
+    /**
+     * The model packages already installed in [cacheDir], newest-agnostic and cheap enough to call
+     * from a screen's initial load.
+     *
+     * #17/#19 gap found building the showcase app: `CacheIndex.list` existed, but nothing on the
+     * public entry point exposed it, so an app could not answer "what do I already have?" — which is
+     * the first question a Models screen has to answer, and the reason the old sample app simply
+     * assumed an `adb push`ed package that no real user can produce.
+     *
+     * Returns an empty list when [cacheDir] does not exist yet: "nothing installed" is a normal
+     * first-run state, not an error.
+     */
+    @JvmStatic
+    fun installed(cacheDir: String): List<CacheIndex.InstalledPackage> =
+        CacheIndex.list(File(cacheDir))
+
+    /** Convenience overload using the same default [cacheDir] as [fromPretrained]. */
+    @JvmStatic
+    fun installed(context: Context): List<CacheIndex.InstalledPackage> =
+        installed(context.filesDir.absolutePath)
+
+    /**
+     * The installed variant's declared engines, or `null` when the package declares none.
+     *
+     * Mirrors `LLMRepository.installedSupportedEngines` deliberately: the facade must answer "may I
+     * offer GenAI" from the same declaration the loader will judge the request against.
+     */
+    private fun declaredEnginesFor(modelDir: File): Set<String>? =
+        manifestOf(modelDir)?.supportedEnginesFor()
+
+    /** The installed manifest, or null when absent or unreadable. Never throws: it is a hint source. */
+    private fun manifestOf(modelDir: File): MobileTransformersManifest? {
+        val manifestFile = File(modelDir, PackageFormat.MANIFEST_FILENAME)
+        if (!manifestFile.isFile) return null
+        return runCatching { MobileTransformersManifest.load(manifestFile) }.getOrNull()
+    }
+
+    private fun detectFeatures(repo: LLMRepository): Set<ModelFeature> =
+        detectFeatures(
+            inference = repo.isInferenceAvailable || repo.isGenerationAvailable,
+            training = repo.isTrainingAvailable,
+            rag = repo.isRagAvailable,
+        )
+
+    /**
+     * The stage-presence → feature-group rule, with nothing Android in it so it can be asserted.
+     *
+     * Split out because the [inference] input is where a real defect lived: it was
+     * `LLMRepository.isGenerationAvailable`, i.e. "`inference/generation_config.json` exists", so
+     * every ENCODER package — a sequence classifier, an embedder — reported no Inference feature at
+     * all. Installing DistilBERT SST-2 from the catalog therefore failed at `fromPretrained` with
+     * "Feature 'Inference' is not installed for this package", naming the one group the package
+     * definitely had. An encoder simply has no HF generation config, and never will.
+     *
+     * The rule itself is the same for every task: a group is installed when its stage is on disk.
+     */
+    internal fun detectFeatures(
+        inference: Boolean,
+        training: Boolean,
+        rag: Boolean,
+    ): Set<ModelFeature> {
+        val features = mutableSetOf<ModelFeature>()
+        if (inference) features += ModelFeature.Inference
+        if (training) features += ModelFeature.Training
+        if (rag) {
+            features += ModelFeature.Rag
+            features += ModelFeature.Embedding
+        }
+        return features
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformersException.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformersException.kt
new file mode 100644
index 0000000..e691ea0
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/MobileTransformersException.kt
@@ -0,0 +1,59 @@
+package com.martinkorelic.mobiletransformers
+
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+
+/**
+ * Public exception hierarchy for the SDK facade (#19 owns the canonical set).
+ *
+ * Every fail-closed path in the facade raises through this sealed hierarchy — never a bare `Exception`,
+ * never a silent fallback. Friendly messages name the exact missing artifact/path so a caller can act.
+ *
+ * The Python `exceptions.py` mirrors this hierarchy at the ROOT + INTENT level, not 1:1 by subclass name:
+ * the Python set is export/hub-shaped (`ConfigValidationError`, `ExportError`, `ManifestError`,
+ * `NoCompatibleVariant`, `HandoffError`, `MergeError`, `UnsupportedModelError`, `HubError`) while this
+ * Kotlin set is device/facade-shaped. Both roots mean "anything the library raises"; do not force a false
+ * 1:1 rename across the language boundary.
+ */
+// `open` (not `sealed`): subclasses live across packages now (e.g. `hub.AdapterUploadDisabledException`),
+// which a sealed base — constrained to one package — would forbid.
+open class MobileTransformersException(message: String, cause: Throwable? = null) :
+    Exception(message, cause)
+
+/** The requested model/package is not installed in the cache (remote pull is #21). */
+class ModelNotInstalledException(message: String) : MobileTransformersException(message) {
+    constructor(repoId: String, cacheDir: String) : this(
+        "Model '$repoId' is not installed at $cacheDir. Pull it first — fromPretrained downloads " +
+            "a package that is not already in the cache.",
+    )
+}
+
+/** A required artifact (manifest, weight handoff, an `inference/`/`train/` config, …) is missing. */
+class MissingArtifactException(message: String) : MobileTransformersException(message) {
+    constructor(feature: ModelFeature, expectedPath: String) : this(
+        "$feature is not available: expected '$expectedPath' was not found in the installed package.",
+    )
+}
+
+/** The requested PEFT method/parameters do not match what the installed package was exported with. */
+class PeftMismatchException(requested: String, supported: List<String>) :
+    MobileTransformersException(
+        "Requested PEFT '$requested' is not supported by this package. Exported with: " +
+            "${supported.joinToString(", ").ifEmpty { "<none declared>" }}. On-device training can only " +
+            "re-run within the exported PEFT topology, not change it.",
+    )
+
+/** A feature was requested that the installed package does not carry. */
+class FeatureNotInstalledException(feature: ModelFeature, installed: Set<ModelFeature>) :
+    MobileTransformersException(
+        "Feature '$feature' is not installed for this package. Installed features: " +
+            "${installed.joinToString(", ").ifEmpty { "<none>" }}.",
+    )
+
+/** The requested inference engine cannot run against this package (e.g. GenAI without a genai config). */
+class EngineUnavailableException(engine: InferenceEngine, reason: String) :
+    MobileTransformersException("Engine '$engine' is unavailable: $reason")
+
+/** A public API surface exists but its behavior is not implemented in this tier (e.g. pushAdapter). */
+class NotImplementedFeatureException(name: String) :
+    MobileTransformersException("'$name' is not implemented in this version.")
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/NativeLibrary.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/NativeLibrary.kt
new file mode 100644
index 0000000..ecd3190
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/NativeLibrary.kt
@@ -0,0 +1,23 @@
+package com.martinkorelic.mobiletransformers
+
+/**
+ * Single owner of `System.loadLibrary("mobiletransformers")`.
+ *
+ * Every class declaring `external fun` must touch this before its first native call. Previously only
+ * [ORTGeneratorGenAI] and [GenAISpike] loaded the library, so the whole Native path — tokenizer,
+ * generator, trainer, retriever — worked *only* if a GenAI class happened to be constructed first. The
+ * sample app got away with it; `MobileTransformers.fromPretrained` did not, and failed with
+ * `UnsatisfiedLinkError: No implementation found for ... createTokenizerSession` on a real device. JVM
+ * tests never touch JNI, so nothing host-side could catch it.
+ *
+ * Loading happens in the object's static initializer, so the JVM guarantees it runs exactly once and
+ * that concurrent callers block until it completes.
+ */
+internal object NativeLibrary {
+    init {
+        System.loadLibrary("mobiletransformers")
+    }
+
+    /** Touch the object to force its static initializer. */
+    fun ensureLoaded() = Unit
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTChatTemplateHandler.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTChatTemplateHandler.kt
similarity index 98%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTChatTemplateHandler.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTChatTemplateHandler.kt
index 86916a0..ec4eeed 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTChatTemplateHandler.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTChatTemplateHandler.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.util.Log
 import io.pebbletemplates.pebble.PebbleEngine
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTConversationState.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTConversationState.kt
similarity index 63%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTConversationState.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTConversationState.kt
index c2f1110..7f9381f 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTConversationState.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTConversationState.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 
 class ORTConversationState(
@@ -31,16 +31,41 @@ class ORTConversationState(
     }
 
     /**
-     * Adds a new assistant message after the LLM has stopped computing
+     * Adds a new assistant message after the LLM has stopped computing.
+     *
+     * #23: advance the consumed-prefix marker by the assistant content's RENDERED offset, not the
+     * decoded `content.length`. `currentConversationLength` is an index into the chat-template's
+     * rendered text (used by [buildNewUserMessageTemplate] to slice the next-turn delta); chat templates
+     * routinely add/trim whitespace around a turn's content, so the decoded length under/over-counts the
+     * rendered position and the next delta starts mid-content — the "one token from the previous
+     * assistant message keeps prepending" bug. Locating the content inside the re-rendered history
+     * anchors the marker exactly at the end of the rendered content (before the turn's closing markup),
+     * so the next user delta cleanly re-feeds the closer the KV cache does not yet hold.
      */
     fun addAssistantMessage(content: String) {
+        // `currentConversationLength` here is the sent prefix ending at the assistant generation opener.
+        val openerPrefixLen = currentConversationLength
 
-        // Add what the newly produced message length
-        currentConversationLength += content.length
-
-        // Create the full conversation history
         conversationHistory.add(mapOf("role" to "assistant", "content" to content))
 
+        val rendered = renderHistory(addGenerationPrompt = false)
+        currentConversationLength = if (rendered.length > openerPrefixLen) {
+            val tail = rendered.substring(openerPrefixLen)
+            val idx = tail.indexOf(content)
+            if (idx >= 0) openerPrefixLen + idx + content.length
+            else openerPrefixLen + content.length // fallback: template transformed the content
+        } else {
+            openerPrefixLen + content.length
+        }
+    }
+
+    private fun renderHistory(addGenerationPrompt: Boolean): String {
+        val context = mutableMapOf<String, Any>(
+            "messages" to conversationHistory,
+            "add_generation_prompt" to addGenerationPrompt
+        )
+        context.putAll(specialTokens)
+        return templateHandler?.buildInput(context) ?: ""
     }
 
     /**
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTDataCurator.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTDataCurator.kt
similarity index 66%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTDataCurator.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTDataCurator.kt
index ca57682..fa264e4 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTDataCurator.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTDataCurator.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.util.Log
 import org.json.JSONObject
@@ -34,6 +34,36 @@ class ORTDataCurator(
     private var allSamples: List<TrainingSample> = emptyList()
     private var inMemoryIndex = 0
 
+    /**
+     * #37: the chat-template renderer used for tasks whose preprocessor declares
+     * [TaskPreprocessor.chatFormatted]. Built once — compiling the Pebble template per row would cost
+     * a template compile for every example in the dataset.
+     *
+     * Null when the package ships no chat template, in which case a chat-formatted task degrades to
+     * the raw prompt: that is the same shape `generate` would use for such a package, so the two
+     * halves still agree.
+     */
+    private val chatTemplateHandler: ORTChatTemplateHandler? by lazy {
+        tokenizer.chatTemplate?.let { ORTChatTemplateHandler(it) }
+    }
+
+    private val chatSpecialTokens: Map<String, String> by lazy { tokenizer.getSpecialTokensWithContent() }
+
+    /**
+     * Renders one prompt exactly as [ORTGeneratorNative.generate] renders the first turn of a fresh
+     * conversation: a **new** [ORTConversationState] per row (so every row is a first message, with
+     * the template's system-prompt injection and `add_generation_prompt`), and no explicit system
+     * prompt — matching `GenerationConfig.systemPrompt`'s `null` default.
+     *
+     * A caller that generates with a *custom* `systemPrompt` changes the inference-side prompt and
+     * would need a dataset rendered the same way; that knob is not plumbed through `DatasetConfig`
+     * today, and is recorded as a follow-up rather than silently approximated here.
+     */
+    private fun renderChatPrompt(content: String): String? {
+        val handler = chatTemplateHandler ?: return null
+        return ORTConversationState(handler, chatSpecialTokens, null).addUserMessage(content)
+    }
+
     init {
         initialize()
     }
@@ -259,18 +289,42 @@ class ORTDataCurator(
         try {
             val json = JSONObject(line)
 
+            // #33: a sequence-classification objective supervises ONE label per example, not one per
+            // token. The preprocessor declares which it is by whether `classLabel` returns a value —
+            // the shape comes from data, not from branching on the task name here (the curator's
+            // `taskName` namespace is dataset-shaped: `cola`, `boolq`, ... and is disjoint from
+            // `TaskType` entirely).
+            val perSequenceLabel = customPreprocess?.classLabel(json)
+            if (perSequenceLabel != null) {
+                return sequenceClassificationSample(json, perSequenceLabel)
+            }
+
             // Step 1: Get input and label text (e.g. prompt + response)
-            val (inputText, labelText) = customPreprocess?.preprocess(json)
+            val (rawInput, labelText) = customPreprocess?.preprocess(json)
                 ?: return null
 
-            if (inputText.isBlank() || labelText.isBlank()) return null
+            if (rawInput.isBlank() || labelText.isBlank()) return null
+
+            // #37: tokenize the prompt the way `generate` will. Two parts, and only the first is
+            // conditional on the package: the chat template is applied when the tokenizer loaded one
+            // (it often has not — see `formatsPromptForGeneration`), while BOS is prepended
+            // unconditionally for such tasks because `generate` always prepends it on the first turn
+            // and `tokenize` defaults to not doing so.
+            val matchGeneration = customPreprocess.formatsPromptForGeneration()
+            val inputText = if (matchGeneration) renderChatPrompt(rawInput) ?: rawInput else rawInput
 
             // Step 2: Tokenize prompt and answer separately (like Python code)
-            val promptTokens = tokenizer.tokenize(inputText)
-            val answerTokens = tokenizer.tokenize(
+            val promptTokens = tokenizer.tokenize(inputText, prependBos = matchGeneration)
+            val rawAnswerTokens = tokenizer.tokenize(
                 labelText
             ) // No special tokens for answer
 
+            // A chat turn ends with EOS. Without it the model has no stop signal and runs to
+            // `maxNewTokens`, trailing whatever follows a well-formed call.
+            val eos = tokenizer.eosToken
+            val answerTokens =
+                if (matchGeneration && eos != null) rawAnswerTokens + eos else rawAnswerTokens
+
             // Step 3: Concatenate the token seq  uences
             val fullInputIds = (promptTokens + answerTokens).toMutableList()
 
@@ -294,9 +348,37 @@ class ORTDataCurator(
         }
     }
 
+    /**
+     * A classification example: the text is the whole input, and the label is one class index.
+     *
+     * No prompt/answer split and no -100 masking — both are causal-LM constructs. The whole sequence
+     * is attended to and the single label supervises the pooled representation.
+     */
+    private fun sequenceClassificationSample(json: JSONObject, label: Int): TrainingSample? {
+        val (inputText, _) = customPreprocess?.preprocess(json) ?: return null
+        if (inputText.isBlank()) return null
+
+        val inputIds = tokenizer.tokenize(inputText).toMutableList()
+        if (inputIds.isEmpty()) return null
+        if (removeLongSamples && maxContextLength != null && inputIds.size >= maxContextLength) {
+            return null
+        }
+
+        return TrainingSample(inputIds = inputIds, labels = listOf(label), perSequenceLabel = true)
+    }
+
+    /**
+     * One example: the input tokens, and either one label per token or one per sequence.
+     *
+     * Which of the two is recorded explicitly rather than inferred from `labels.size`, because at
+     * `sequenceLength == 1` the two are indistinguishable by count — the same ambiguity
+     * `training_inputs.h::labels_shape` resolves in favour of `[batch, seq]` so the decoder keeps its
+     * shipped shape.
+     */
     data class TrainingSample(
         val inputIds: List<Int>,
-        val labels: List<Int>
+        val labels: List<Int>,
+        val perSequenceLabel: Boolean = false,
     )
 
     data class DatasetProgress(
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenerationConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGenerationConfig.kt
similarity index 55%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenerationConfig.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGenerationConfig.kt
index 8d168ac..f62e6a8 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenerationConfig.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGenerationConfig.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 data class SamplingOptions (
     val method : String = "greedy",
@@ -18,7 +18,22 @@ data class ORTGenerationConfig(
     val systemPrompt : String? = null,
     var loadMergedWeights : Boolean = false,
     val sampling : SamplingOptions = SamplingOptions(),
-    val deviceOptions: DeviceOptions = DeviceOptions()
+    val deviceOptions: DeviceOptions = DeviceOptions(),
+    // #11: engine selector over the one shared package (null = auto-select; Native is the floor).
+    val engine: com.martinkorelic.mobiletransformers.runtime.InferenceEngine? = null,
+    /**
+ * Wrap the prompt in the package's chat template when it ships one Pebble can render.
+ *
+ * False means **the caller has already framed its own turns** and a second framing would nest one
+ * inside the other. `generateToolCall` sets it: `ToolPromptBuilder` emits a complete
+ * `<start_of_turn>…` prompt deliberately, because it cannot rely on a Jinja engine rendering
+ * FunctionGemma's 13 KB template on a phone.
+ *
+ * This became load-bearing the moment the tokenizer started reading `chat_template.jinja`. Before
+ * that `chatTemplate` was null for every package, so nothing templated and the conflict could not
+ * arise — which is precisely why the double-framing hazard sat unnoticed.
+ */
+    val applyChatTemplate: Boolean = true,
 ) {
     fun overrideConfig(override: ORTGenerationConfig?): ORTGenerationConfig {
         if (override == null) return this
@@ -36,7 +51,16 @@ data class ORTGenerationConfig(
             timeStepUpdate = if (override.timeStepUpdate != defaultConfig.timeStepUpdate) override.timeStepUpdate else this.timeStepUpdate,
             systemPrompt = override.systemPrompt ?: this.systemPrompt,
             deviceOptions = if (override.deviceOptions != defaultConfig.deviceOptions) override.deviceOptions else this.deviceOptions,
-            sampling = if (override.sampling != defaultConfig.sampling) override.sampling else this.sampling
+            sampling = if (override.sampling != defaultConfig.sampling) override.sampling else this.sampling,
+            engine = override.engine ?: this.engine,
+            // Follows the same "differs from the default means the caller meant it" rule as the rest.
+            // The default is true, so only an explicit false overrides.
+            applyChatTemplate =
+            if (override.applyChatTemplate != defaultConfig.applyChatTemplate) {
+                override.applyChatTemplate
+            } else {
+                this.applyChatTemplate
+            },
         )
     }
 }
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorGenAI.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorGenAI.kt
new file mode 100644
index 0000000..d572472
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorGenAI.kt
@@ -0,0 +1,190 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.internal.runtime.HandoffPrecondition
+import com.martinkorelic.mobiletransformers.repository.GenerationCallback
+import com.martinkorelic.mobiletransformers.runtime.EngineCapabilities
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.ModelRuntime
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+/**
+ * GenAI [ModelRuntime] engine (#11) — the ONNX Runtime GenAI implementation over the SAME `inference/`
+ * package the Native engine reads. Backed by `cpp/genai_runtime.cpp` (stable C API; runs on the
+ * genai-paired stock ORT `libort_gen.so`). The generation loop lives here in Kotlin (one JNI step per
+ * token) so it drives the **identical** [GenerationCallback]/[InferenceProgress] sequence as
+ * [ORTGeneratorNative] — the facade/UI never branch on engine.
+ *
+ * Supersedes the deleted `ORTGenAINative` (which threw `NotImplementedError`) and `onnx-genai.cpp`.
+ */
+class ORTGeneratorGenAI(
+    val cacheDir: String,
+    private val tokenizer: ORTTokenizerNative,
+    private var _generationConfig: ORTGenerationConfig,
+) : ModelRuntime {
+
+    private val LOG_TAG = "ORTGeneratorGenAI"
+    private var handle: Long = 0
+    private var modelLoadTimeMs: Long = 0L
+
+    /**
+     * Same chat-template rendering the Native engine applies (#24 parity).
+     *
+     * Without this the two engines were fed *different token sequences* for one `generate(prompt)`
+     * call: Native rendered the prompt through the model's chat template while GenAI passed the raw
+     * string to `OgaGenerator`. On the same package the first greedy token then differed ("Hello" vs
+     * ","), which reads as a weights/graph divergence but is purely prompt construction — and it is
+     * exactly what Gate 0.1 #1 asserts.
+     */
+    private val conversationState: ORTConversationState? = tokenizer.chatTemplate?.let {
+        ORTConversationState(
+            ORTChatTemplateHandler(it),
+            tokenizer.getSpecialTokensWithContent(),
+            _generationConfig.systemPrompt,
+        )
+    }
+
+    override val capabilities: EngineCapabilities =
+        EngineCapabilities(
+            engine = InferenceEngine.GENAI,
+            supportsStreaming = true,
+            // Reads the SAME external-initializer folder as Native (Gate 0.1), so it must run the
+            // same fail-closed gate — hardcoding `true` would have loaded base weights after a merge
+            // with no warning, the exact silent downgrade #23 forbids on the Native side.
+            supportsLoadMergedWeights =
+                HandoffPrecondition.mergedWeightsPresent(PackagePaths.forCache(cacheDir, _generationConfig.repoName).inference),
+            maxContextLength = _generationConfig.maxSequenceLength,
+        )
+
+    override suspend fun load(cacheDir: String, config: ORTGenerationConfig) {
+        _generationConfig = config
+        val start = System.currentTimeMillis()
+        val dir = PackagePaths.forCache(cacheDir, config.repoName).inference.absolutePath
+        // #23 parity: same map-driven precondition the Native engine runs. An absent map means
+        // nothing was merged (fall back to base); a present-but-broken one throws.
+        if (config.loadMergedWeights && !HandoffPrecondition.loadMergedWeightsReady(File(dir))) {
+            Log.w(LOG_TAG, "No weight_handoff_map.json in $dir; loading base weights")
+            config.loadMergedWeights = false
+        }
+        handle = nativeCreate(dir)
+        if (handle == 0L) {
+            throw IllegalStateException("GenAI OgaCreateModel failed for $dir (see logcat GenAIRuntime)")
+        }
+        val s = config.sampling
+        // #24: the ONE source for the native sampling ordinal, identical to ORTGeneratorNative.
+        nativeSetSampling(
+            handle, SamplingMethod.fromWire(s.method).nativeOrdinal, s.temperature, s.topK, s.topP, s.seed,
+        )
+        modelLoadTimeMs = System.currentTimeMillis() - start
+    }
+
+    override fun generate(
+        promptText: String,
+        generationArgs: ORTGenerationConfig,
+        callback: GenerationCallback?,
+    ): String {
+        val decodedText = StringBuilder()
+        try {
+            check(handle != 0L) { "GenAI session not loaded" }
+            generationArgs.systemPrompt?.let { conversationState?.setSystemPrompt(it) }
+            // Skipped when the caller framed its own turns — see ORTGenerationConfig.applyChatTemplate.
+            // Kept in step with Native deliberately: the whole point of rendering here is that the two
+            // engines feed the model the SAME token sequence for one generate(prompt) call.
+            val renderedPrompt = conversationState
+            ?.takeIf { generationArgs.applyChatTemplate }
+            ?.addUserMessage(promptText)
+            ?: promptText
+            if (!nativeStart(handle, renderedPrompt, generationArgs.maxSequenceLength)) {
+                throw IllegalStateException("GenAI failed to start generation")
+            }
+
+            var decoded = 0
+            val genStart = System.currentTimeMillis()
+            var prefillTimeMs = 0L
+
+            callback?.onStartGeneration(
+                InferenceProgress(
+                    token = "", tokenId = -1, totalDecodedTokens = 0,
+                    prefillTimeMs = 0L, timeToLoadModelMs = modelLoadTimeMs,
+                    generationTimeMs = 0L, avgTokensPerSecond = 0.0, isCompleted = false,
+                ),
+            )
+
+            while (decoded < generationArgs.maxSequenceLength && !nativeIsDone(handle)) {
+                val piece = nativeStep(handle)
+                if (decoded == 0) prefillTimeMs = System.currentTimeMillis() - genStart
+                val tokenId = nativeLastToken(handle)
+                if (tokenId < 0) break
+
+                val genMs = System.currentTimeMillis() - genStart
+                val avgTps = if (genMs > 0) decoded.toDouble() / (genMs / 1000.0) else 0.0
+                val isEos = tokenizer.isEosToken(tokenId)
+                if (!isEos) decodedText.append(piece)
+
+                callback?.onPartialResult(
+                    InferenceProgress(
+                        // Suppressed on EOS for the same reason as Native (see ORTGeneratorNative):
+                        // the facade rebuilds the public text from these partials, so an emitted
+                        // turn marker becomes part of the answer. The two engines must agree.
+                        token = if (isEos) "" else piece, tokenId = tokenId, totalDecodedTokens = decoded,
+                        prefillTimeMs = prefillTimeMs, timeToLoadModelMs = modelLoadTimeMs,
+                        generationTimeMs = genMs, avgTokensPerSecond = avgTps, isCompleted = isEos,
+                    ),
+                )
+                decoded++
+                if (isEos) break
+            }
+
+            // Multi-turn parity with Native: the reply has to go back into the transcript, or a second
+            // generate would re-render the conversation without it. Gated on the same flag as the
+            // user turn — see ORTGenerationConfig.applyChatTemplate.
+            conversationState
+            ?.takeIf { generationArgs.applyChatTemplate }
+            ?.addAssistantMessage(decodedText.toString())
+
+            callback?.onCompletion(
+                InferenceProgress(
+                    token = "", tokenId = -1, totalDecodedTokens = decoded,
+                    prefillTimeMs = prefillTimeMs, timeToLoadModelMs = modelLoadTimeMs,
+                    generationTimeMs = System.currentTimeMillis() - genStart,
+                    // #24: was hardcoded 0.0, so GenAI always reported zero throughput through
+                    // GenerationResult.avgTokensPerSecond. Recompute over the full run.
+                    avgTokensPerSecond = finalAvgTps(decoded, genStart), isCompleted = true,
+                ),
+            )
+        } catch (e: Throwable) {
+            Log.e(LOG_TAG, e.toString())
+            callback?.onError(e)
+        }
+        return decodedText.toString()
+    }
+
+    override fun release() {
+        if (handle != 0L) {
+            nativeRelease(handle)
+            handle = 0
+        }
+        modelLoadTimeMs = 0L
+    }
+
+    private fun finalAvgTps(decoded: Int, genStart: Long): Double {
+        val elapsedMs = System.currentTimeMillis() - genStart
+        return if (elapsedMs > 0) decoded.toDouble() / (elapsedMs / 1000.0) else 0.0
+    }
+
+    private external fun nativeCreate(dir: String): Long
+    private external fun nativeSetSampling(h: Long, method: Int, temperature: Float, topK: Int, topP: Float, seed: Int)
+    private external fun nativeStart(h: Long, prompt: String, maxNewTokens: Int): Boolean
+    private external fun nativeIsDone(h: Long): Boolean
+    private external fun nativeStep(h: Long): String
+    private external fun nativeLastToken(h: Long): Int
+    private external fun nativeRelease(h: Long)
+
+    companion object {
+        init {
+            NativeLibrary.ensureLoaded()
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorNative.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorNative.kt
new file mode 100644
index 0000000..d928115
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorNative.kt
@@ -0,0 +1,489 @@
+package com.martinkorelic.mobiletransformers
+
+import android.util.Log
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.internal.runtime.GenerationInputs
+import com.martinkorelic.mobiletransformers.internal.runtime.HandoffPrecondition
+import com.martinkorelic.mobiletransformers.repository.GenerationCallback
+import com.martinkorelic.mobiletransformers.runtime.EngineCapabilities
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.ModelRuntime
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+class ORTGeneratorNative(val cacheDir : String, private var tokenizer: ORTTokenizerNative, var _generationConfig : ORTGenerationConfig) : ModelRuntime {
+
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+
+    private var LOG_TAG = "ORTGeneratorNative"
+
+    private var inferenceModel : Long = 0
+
+    // #11: the guaranteed engine floor. maxContextLength reflects the configured generation length.
+    // #23: supportsLoadMergedWeights now reflects the hardened handoff precondition for THIS model —
+    // it is a non-throwing presence query (schema + file existence, no hashing); the throwing,
+    // checksum-verifying gate lives in createInferenceModel below.
+    override val capabilities: EngineCapabilities
+        get() = EngineCapabilities(
+            engine = InferenceEngine.NATIVE,
+            supportsStreaming = true,
+            supportsLoadMergedWeights = HandoffPrecondition.mergedWeightsPresent(inferenceDir()),
+            maxContextLength = _generationConfig.maxSequenceLength,
+        )
+
+    private fun inferenceDir(): File = PackagePaths.forCache(cacheDir, _generationConfig.repoName).inference
+
+    /** #11 [ModelRuntime.load]: open the Native session over `<cacheDir>/<repoName>/inference`. */
+    override suspend fun load(cacheDir: String, config: ORTGenerationConfig) {
+        generationConfig = config
+        // #23: a freshly loaded session starts a fresh conversation — clear any KV/attention/history
+        // state so a new session never inherits the previous conversation's prepend state.
+        resetConversation()
+        createInferenceModel()
+    }
+
+    /** #11 [ModelRuntime.release]. */
+    override fun release() = destroySession()
+
+    private var modelLoadTimeMs : Long = 0L
+
+    var pastAttentionMaskLength : Int = 0
+
+    var generationConfig: ORTGenerationConfig
+        get() = _generationConfig
+        set(value) {
+            if (_generationConfig != value) {
+                _generationConfig = value
+                updateSamplingOptions(_generationConfig.sampling)
+            }
+        }
+
+    // Conversation state if we are using multi-turn conversation
+    val conversationState: ORTConversationState? = tokenizer.chatTemplate?.let {
+        ORTConversationState(
+            ORTChatTemplateHandler(it),
+            tokenizer.getSpecialTokensWithContent(),
+            generationConfig.systemPrompt
+        )
+    }
+
+    suspend fun createInferenceModel() {
+        var start : Long = 0L
+        if (generationConfig.trackMetrics) {
+            start = System.currentTimeMillis()
+        }
+
+        if (generationConfig.loadMergedWeights) {
+            // #23: map-driven, fail-closed load precondition (replaces the retired inference/merged probe).
+            // #9 writes merged tensors as flat per-tensor <name>.bin in inference/, keyed by
+            // weight_handoff_map.json (+ sibling .sha256). loadMergedWeightsReady throws (naming the
+            // offending tensor) if the map is present but any .bin is missing or its checksum fails —
+            // no silent downgrade. An ABSENT map means nothing was merged: fall back to base weights.
+            if (!HandoffPrecondition.loadMergedWeightsReady(inferenceDir())) {
+                Log.w(LOG_TAG, "No weight_handoff_map.json in ${inferenceDir().absolutePath}; loading base weights")
+                generationConfig.loadMergedWeights = false
+            }
+        }
+
+        // Check if ONNX name has .onnx extension, add it if missing
+        if (!generationConfig.onnxName.endsWith(".onnx", ignoreCase = true)) {
+            generationConfig.onnxName += ".onnx"
+        }
+
+        // Create the inference session
+        inferenceModel = createInferenceSession(
+            PackagePaths.forCache(cacheDir, generationConfig.repoName).inference.absolutePath,
+            generationConfig.onnxName,
+            cacheDir,
+            generationConfig.loadMergedWeights,
+            generationConfig.deviceOptions.coreConfigId,
+            generationConfig.deviceOptions.memoryConfigId,
+            generationConfig.deviceOptions.executionProvider,
+            generationConfig.deviceOptions.enableProfiling
+        )
+
+        // #23 fail-closed: a 0 handle means native session construction failed. When merged weights
+        // were requested that is specifically "the merged tensors could not be applied" — dtype/shape
+        // and byte-size validation are C++-side, so the Kotlin precondition above cannot catch them.
+        // Never continue with a session built from the frozen base weights: it would generate
+        // confidently from an untrained model.
+        if (inferenceModel == 0L) {
+            throw MissingArtifactException(
+                if (generationConfig.loadMergedWeights) {
+                    "failed to create the native inference session with merged weights from " +
+                        "${inferenceDir().absolutePath} (see logcat for the offending tensor); " +
+                        "refusing to fall back to base weights"
+                } else {
+                    "failed to create the native inference session for " +
+                        "${inferenceDir().absolutePath}/${generationConfig.onnxName}"
+                },
+            )
+        }
+
+        // Update with sampling configurations
+        updateSamplingOptions(generationConfig.sampling)
+
+        if (generationConfig.trackMetrics) {
+            modelLoadTimeMs = System.currentTimeMillis() - start
+        }
+    }
+
+    /**
+     * Generation loop with KV caching enabled in native inference model.
+     * This generation loop generates token by token.
+     * Generates multi-turn conversation if chat template is enabled in tokenizer configuration.
+     */
+    override fun generate(promptText: String,
+                         generationArgs : ORTGenerationConfig,
+                         callback: GenerationCallback?) : String {
+
+        val decodedText = StringBuilder()
+
+        // Apply new system prompt if exists
+        generationArgs.systemPrompt?.let {
+            conversationState?.setSystemPrompt(it)
+        }
+
+        var inputText = promptText
+
+        try {
+
+            // `applyChatTemplate = false` means the caller framed its own turns (generateToolCall via
+            // ToolPromptBuilder); templating again would nest one framing inside the other.
+            conversationState?.takeIf { generationArgs.applyChatTemplate }?.let {
+                // NOTE: Sometimes one token from the previous assistant message keeps prepending and sometimes not
+                // TODO: Will need fix
+                inputText = it.addUserMessage(inputText)
+            }
+
+            // Generate input tokens, but do not add if we already have past attention mask
+            var inputTokens = tokenizer.tokenize(inputText, prependBos = pastAttentionMaskLength == 0)
+
+            if (inputTokens == null) {
+                Log.d(LOG_TAG, "Failed to generate tokens for the prompt.")
+                return ""
+            }
+
+            var (inputIds, attentionMask, positionIds) = createModelInputs(inputTokens)
+            val generatedIds = inputIds
+
+            // Captured before the loop mutates inputIds down to a single token per step.
+            val promptTokens = inputIds.size
+            val contextLimit = tokenizer.maximumTokenLength
+
+            var decoded = 0
+
+            var currentGenerationTime : Long = 0L
+            var cumulativeGenerationTime : Long = 0L
+            var prefillStartMs : Long = 0L
+            var prefillTimeMs : Long = 0L
+            var avgTokensPerS : Double = 0.0
+            var isEosToken : Boolean = false
+
+            Log.d(LOG_TAG, "Starting generation...")
+
+            callback?.onStartGeneration(
+                InferenceProgress(
+                    token = "",
+                    tokenId = -1,
+                    totalDecodedTokens = decoded,
+                    prefillTimeMs = prefillTimeMs,
+                    timeToLoadModelMs = modelLoadTimeMs,
+                    generationTimeMs = cumulativeGenerationTime,
+                    avgTokensPerSecond =  avgTokensPerS,
+                    isCompleted = this.tokenizer.isEosToken(inputIds.last().toInt()),
+                    promptTokenCount = promptTokens,
+                    contextLimit = contextLimit,
+                )
+            )
+
+            prefillStartMs = System.currentTimeMillis()
+
+            // #24: maxSequenceLength carries the public `maxNewTokens` (new tokens to emit), so the
+            // bound is EXCLUSIVE — `maxNewTokens = N` must emit exactly N tokens. This was `<=`, one
+            // more token than GenAI produced for the same config; the two engines are now identical.
+            while (decoded < generationArgs.maxSequenceLength) {
+
+                // Trim maximum tokens from beginning of the sequence if they go over the limit
+                if (inputIds.size > tokenizer.maximumTokenLength) {
+                    val trimmedInputs = tokenizer.trimModelInputs(inputIds, attentionMask, positionIds)
+                    inputIds = trimmedInputs.first
+                    attentionMask = trimmedInputs.second
+                    positionIds = trimmedInputs.third
+                }
+
+                Log.d(LOG_TAG, inputIds.toString())
+
+                if (generationArgs.trackMetrics && decoded == 0) {
+                    prefillTimeMs = prefillStartMs - System.currentTimeMillis()
+                } else if (generationArgs.trackMetrics) {
+                    currentGenerationTime = System.currentTimeMillis()
+                }
+
+                val nextTokenId = performInferenceStep(
+                    inferenceModel,
+                    inputIds.toLongArray(),
+                    attentionMask.toLongArray(),
+                    positionIds.toLongArray(),
+                    1,
+                    attentionMask.size,
+                    inputIds.size,
+                    this.tokenizer.vocabSize
+                )
+
+                if (generationArgs.trackMetrics && decoded != 0) {
+                    cumulativeGenerationTime += (System.currentTimeMillis() - currentGenerationTime)
+                }
+
+                if (generationArgs.trackMetrics && decoded == 0) {
+                    prefillTimeMs = System.currentTimeMillis() - prefillStartMs
+                } else if (generationArgs.trackMetrics) {
+                    avgTokensPerS = decoded.toDouble() / (cumulativeGenerationTime / 1000.0)
+                }
+
+                // Append the next token ID to generated ids
+                generatedIds.add(nextTokenId.toLong())
+
+                // Replace the next input id (since we are generating token by token)
+                inputIds = mutableListOf(nextTokenId.toLong())
+
+                // Update the attention mask to reflect the new token
+                attentionMask.add(1L)
+
+                // Update position IDs by appending the next position index
+                val nextPositionId = positionIds.last() + 1
+                positionIds = mutableListOf(nextPositionId)
+
+                val decodedToken = tokenizer.decodeToken(nextTokenId)
+
+                // Append the new token to the decoded text
+                isEosToken = this.tokenizer.isEosToken(inputIds.last().toInt())
+
+                // Let's not append eosToken
+                if (!isEosToken)
+                    decodedText.append(decodedToken)
+
+                // The end-of-turn marker is scaffolding, not content, and it must not reach a caller
+                // as TEXT. `decodedText` above has always excluded it — but the public
+                // `GenerationResult.text` is rebuilt by the facade from these partials, so emitting
+                // the raw piece put "<|im_end|>" both into the streaming bubble and into the final
+                // answer for every chat model whose eos_token is its turn marker (SmolLM2, Qwen2.5).
+                // The token id is still reported, so a caller that wants to know it ended on EOS can.
+                val emittedToken = if (isEosToken) "" else decodedToken
+
+                // Emit token if needed
+                callback?.onPartialResult(
+                    InferenceProgress(
+                        token = emittedToken,
+                        tokenId = inputIds.last().toInt(),
+                        totalDecodedTokens = decoded,
+                        prefillTimeMs = prefillTimeMs,
+                        timeToLoadModelMs = modelLoadTimeMs,
+                        generationTimeMs = cumulativeGenerationTime,
+                        avgTokensPerSecond =  avgTokensPerS,
+                        isCompleted = isEosToken,
+                        promptTokenCount = promptTokens,
+                        contextLimit = contextLimit,
+                    )
+                )
+                decoded++
+
+                Log.d(LOG_TAG, decodedText.toString())
+
+                // Break if end of sequence
+                // Also break if assistant has completed the sequence if multi-turn is enabled
+                if (isEosToken)
+                    break
+            }
+
+            // If using multi-turn conversation, we need to add assistant message back. Gated on the
+            // same flag as the user turn: recording a reply to a turn that was never added would leave
+            // the transcript describing a conversation that did not happen.
+            conversationState?.takeIf { generationArgs.applyChatTemplate }?.let {
+                it.addAssistantMessage(decodedText.toString())
+                // The native KV cache holds every token that has been *run through* the model. The loop
+                // appends a mask slot for each newly sampled token, and the last sampled token has not
+                // been fed forward, so the cache length is exactly `attentionMask.size - 1`.
+                //
+                // This was `- 2`, so the next turn built a mask one entry short of `past + new` and ORT
+                // aborted the process inside the first attention Add:
+                //   "Attempting to broadcast an axis by a dimension other than 1. 51 by 52".
+                // Only reachable on a *second* generate in one session, which no host test can reach.
+                pastAttentionMaskLength = attentionMask.size - 1
+            }
+
+            callback?.onCompletion(
+                InferenceProgress(
+                    token = "",
+                    tokenId = -1,
+                    totalDecodedTokens = decoded,
+                    prefillTimeMs = prefillTimeMs,
+                    timeToLoadModelMs = modelLoadTimeMs,
+                    generationTimeMs = cumulativeGenerationTime,
+                    avgTokensPerSecond =  avgTokensPerS,
+                    isCompleted = true,
+                    promptTokenCount = promptTokens,
+                    contextLimit = contextLimit,
+            ))
+        } catch (e: Throwable) {
+            Log.e(LOG_TAG, e.toString())
+            callback?.onError(e)
+        }
+
+        return decodedText.toString()
+    }
+
+    fun resetConversation() {
+        conversationState?.resetForNewConversation()
+        pastAttentionMaskLength = 0
+        // Reset the NATIVE cache too. Clearing only the Kotlin counter left the session still holding
+        // the previous conversation's keys and values, so the two halves disagreed about how many
+        // tokens were cached — the same disagreement that surfaces as a short attention mask.
+        if (inferenceModel != 0L) {
+            nativeResetKvCache(inferenceModel)
+        }
+    }
+
+    /**
+     * The KV-cache length according to the SESSION, which is the only authority on it.
+     *
+     * `pastAttentionMaskLength` is kept as a mirror for logging and for the `prependBos` decision, but
+     * the mask is built from this. Two independent counts of the same thing is what allowed a mask of
+     * `past + new - 1` to be sent, and on a transformers >= 4.57 graph that fails inside ORT at
+     * `/model/Gather_5` with a message naming neither the mask nor the cache.
+     */
+    private fun cachedTokenCount(): Int =
+        if (inferenceModel != 0L) nativePastSequenceLength(inferenceModel) else 0
+
+    /**
+     * Numbers off one prefill pass over [tokens], for conformance assertions.
+     *
+     * The device mirror of the host's `train_inference_parity` gate: same causal shift, so
+     * [InferenceMetrics.crossEntropyNats] is directly comparable to the number the exporter checks.
+     * Nothing else on device could see logits at all — `performInferenceStep` samples internally and
+     * returns a token id — which is why post-merge numerical correctness went unasserted.
+     *
+     * Runs as a single pass against an EMPTY cache (it resets first, and the native side resets after),
+     * so repeated calls are independent and the conversation is not advanced.
+     */
+    fun inferenceMetrics(tokens: IntArray, vocabSize: Int): InferenceMetrics {
+        check(inferenceModel != 0L) { "inference session is not open" }
+        require(tokens.size >= 2) {
+            "need at least 2 tokens to score one (prediction, target) pair, got ${tokens.size}"
+        }
+        nativeResetKvCache(inferenceModel)
+        val plan = GenerationInputs.plan(tokens, pastLength = 0)
+        val raw = nativeInferenceMetrics(
+            inferenceModel,
+            plan.inputIds.toLongArray(),
+            plan.attentionMask.toLongArray(),
+            plan.positionIds.toLongArray(),
+            1,
+            plan.attentionMask.size,
+            tokens.size,
+            vocabSize,
+        ) ?: error("native inference metrics returned no result")
+        pastAttentionMaskLength = 0
+        return InferenceMetrics(
+            argmax = raw[0].toInt(),
+            maxLogit = raw[1],
+            sum = raw[2],
+            sumOfSquares = raw[3],
+            crossEntropyNats = raw[4],
+        )
+    }
+
+    /** @see inferenceMetrics */
+    data class InferenceMetrics(
+        val argmax: Int,
+        val maxLogit: Double,
+        val sum: Double,
+        val sumOfSquares: Double,
+        val crossEntropyNats: Double,
+    ) {
+        /**
+         * True when this reduction differs from [other] beyond float noise.
+         *
+         * Four statistics rather than one: a constant shift leaves `argmax` alone, a redistribution
+         * leaves `sum` alone. Used to assert a merge actually changed the computation.
+         */
+        fun differsFrom(other: InferenceMetrics, tolerance: Double = 1e-6): Boolean =
+            argmax != other.argmax ||
+                kotlin.math.abs(maxLogit - other.maxLogit) > tolerance ||
+                kotlin.math.abs(sum - other.sum) > tolerance ||
+                kotlin.math.abs(sumOfSquares - other.sumOfSquares) > tolerance
+    }
+
+    fun destroySession() {
+        releaseInferenceSession(inferenceModel)
+        resetConversation()
+        inferenceModel = 0
+        modelLoadTimeMs = 0L
+    }
+
+    /**
+     * The step inputs for [inputIds], continuing from whatever is already in the KV cache.
+     *
+     * The planning itself lives in [GenerationInputs] so it is host-testable — the position-ids/mask
+     * disagreement this used to carry was only reachable on a second turn, i.e. only on a phone. See
+     * that object for the invariant and the defect it now pins.
+     *
+     * Within a turn the decode loop continues the positions itself (`positionIds.last() + 1`), and
+     * `trimModelInputs` drops from the FRONT, so a trimmed sequence stays contiguous.
+     */
+    fun createModelInputs(inputIds: IntArray): Triple<MutableList<Long>, MutableList<Long>, MutableList<Long>> {
+        // Ask the session, do not trust the counter — see [cachedTokenCount].
+        val cached = cachedTokenCount()
+        if (cached != pastAttentionMaskLength) {
+            Log.w(
+                LOG_TAG,
+                "KV cache length $cached disagrees with the tracked $pastAttentionMaskLength; " +
+                    "using the session's value.",
+            )
+            pastAttentionMaskLength = cached
+        }
+        val plan = GenerationInputs.plan(inputIds, cached)
+        return Triple(plan.inputIds, plan.attentionMask, plan.positionIds)
+    }
+
+    fun updateSamplingOptions(args : SamplingOptions) {
+        // #24: single source for the native ordinal via SamplingMethod.nativeOrdinal (replaces the old
+        // methodMap). fromWire fails closed on an unknown method rather than silently defaulting to greedy.
+        // (topK is always passed explicitly here, so the C++ struct's top_k=50 default is never observed.)
+        val methodInt = SamplingMethod.fromWire(args.method).nativeOrdinal
+        setSamplingConfig(inferenceModel, methodInt, args.temperature, args.topK, args.topP, args.seed)
+    }
+
+    external fun performInferenceStep(session: Long, input_ids: LongArray, attention_mask: LongArray, position_ids : LongArray, batchSize: Int, sequenceLength: Int, pastSequenceLength : Int, vocabSize : Int) : Int
+
+    external fun createInferenceSession(inferenceModelPath : String, inferenceModelName : String, cacheDirPath : String, loadMergedWeights : Boolean, coreConfigId : String, memoryConfigId : String, executionProvider : String, enableProfiling : Boolean) : Long
+
+    external fun releaseInferenceSession(session: Long)
+
+    external fun setSamplingConfig(session: Long, samplingMethod : Int, temperature : Float, topK : Int, topP : Float, seed : Int)
+
+    /** Tokens currently in the session's KV cache — the single authority on the cache length. */
+    external fun nativePastSequenceLength(session: Long) : Int
+
+    /**
+     * One forward pass reduced to `[argmax, maxLogit, sum, sumOfSquares, causalCrossEntropyNats]`.
+     * A probe: it resets the KV cache afterwards and advances nothing. See [inferenceMetrics].
+     */
+    external fun nativeInferenceMetrics(
+        session: Long,
+        input_ids: LongArray,
+        attention_mask: LongArray,
+        position_ids: LongArray,
+        batchSize: Int,
+        sequenceLength: Int,
+        newTokenCount: Int,
+        vocabSize: Int,
+    ) : DoubleArray?
+
+    /** Drops the KV cache back to zero-length past for a new conversation. */
+    external fun nativeResetKvCache(session: Long)
+
+}
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTProgress.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTProgress.kt
new file mode 100644
index 0000000..757d076
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTProgress.kt
@@ -0,0 +1,44 @@
+package com.martinkorelic.mobiletransformers
+
+import com.martinkorelic.mobiletransformers.rag.RagMatch
+
+data class TrainingProgress(
+    val currentStep: Int,
+    val currentEpoch: Int,
+    val totalLoss: Float = 0f,
+    val epochLoss: Float,
+    val stepLoss: Float,
+    val learningRate: Float,
+    val stepDurationMs: Long,
+    val epochDurationMs: Long,
+    val totalDurationMs: Long,
+    val isCompleted: Boolean = false
+)
+
+data class InferenceProgress(
+    val token: String,
+    val tokenId : Int,
+    val totalDecodedTokens: Int,
+    val prefillTimeMs: Long = 0L,
+    val timeToLoadModelMs: Long = 0L,
+    val generationTimeMs: Long = 0L,
+    val avgTokensPerSecond: Double = 0.0,
+    val isCompleted: Boolean = false,
+    /**
+     * Tokens the prompt occupied, measured after templating and after any trim.
+     *
+     * Together with [totalDecodedTokens] and [contextLimit] this is what lets a caller say how much
+     * of the window a turn consumed. Nothing reported it before, so an app could show tokens/second
+     * but could not answer "how close am I to the limit" — the question that actually predicts the
+     * next turn being truncated.
+     */
+    val promptTokenCount: Int = 0,
+    /** Tokens the model can attend to at once, or 0 when the package declares none. */
+    val contextLimit: Int = 0,
+)
+
+data class RagResult(
+    val documents: List<RagMatch>?,
+    val embeddingTimeMs : Long = 0L,
+    val queryTimeMs : Long = 0L
+)
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRagConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRagConfig.kt
similarity index 78%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRagConfig.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRagConfig.kt
index 603da5a..e3bf353 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRagConfig.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRagConfig.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 data class ORTRagArguments(
     val repoName: String? = null,
@@ -6,6 +6,8 @@ data class ORTRagArguments(
     val embeddingDimension: Int? = null,
     val topK: Int? = null,
     val searchType: String? = null,
+    val minScore: Double? = null,
+    val indexingMode: String? = null,
     val maxTextLength: Int? = null,
     val chunkSize: Int? = null,
     val chunkOverlap: Int? = null,
@@ -19,6 +21,8 @@ data class ORTRagConfig(
     val embeddingDimension : Int = 256,
     val topK: Int = 10,
     val searchType : String = "semantic", // semantic, text
+    val minScore: Double = 0.0,                  // #27: similarity floor for search hits
+    val indexingMode: String = "precompute",     // #27: precompute (v1) | dynamic (fail-closed stub, F7)
 
     // Text processing
     val maxTextLength: Int = 1024,               // Max chars per document
@@ -36,6 +40,8 @@ data class ORTRagConfig(
             embeddingDimension = override.embeddingDimension ?: this.embeddingDimension,
             topK = override.topK ?: this.topK,
             searchType = override.searchType ?: this.searchType,
+            minScore = override.minScore ?: this.minScore,
+            indexingMode = override.indexingMode ?: this.indexingMode,
             maxTextLength = override.maxTextLength ?: this.maxTextLength,
             chunkSize = override.chunkSize ?: this.chunkSize,
             chunkOverlap = override.chunkOverlap ?: this.chunkOverlap,
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRetriever.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRetriever.kt
similarity index 60%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRetriever.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRetriever.kt
index 4340cd2..15db41a 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTRetriever.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTRetriever.kt
@@ -1,15 +1,29 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.content.Context
-import com.martinkorelic.ortmobile.repository.RagCallback
+import com.martinkorelic.mobiletransformers.constants.SearchType
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.rag.DimensionRegistry
+import com.martinkorelic.mobiletransformers.rag.IngestionPipeline
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.ObjectBoxVectorStore
+import com.martinkorelic.mobiletransformers.rag.RagDocument
+import com.martinkorelic.mobiletransformers.rag.VectorStore
+import com.martinkorelic.mobiletransformers.repository.RagCallback
 
 class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _ragConfig : ORTRagConfig) {
 
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+
     private val LOG_TAG = "ORTRetriever"
 
-    // Tokenizer should be saved under cacheDir/modelName/embedding/tokenizer/...
-    // Embedding model saved under cacheDir/modelName/embedding/
-    // Vector database should be located under cacheDir/modelName/database/
+    // G2: every path below comes from PackagePaths. The comments this replaces described the layout in
+    // prose — and got it wrong: the vector store is at `embedding/database/`, not `database/`.
+    private val pkgPaths get() = PackagePaths.forCache(cacheDir, ragConfig.repoName)
+
     var embeddingTokenizer : ORTTokenizerNative? = null
     private var embeddingModel : Long = 0L
 
@@ -27,7 +41,7 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
 
         // Create tokenizer session if not initialized
         if (embeddingTokenizer == null) {
-            embeddingTokenizer = ORTTokenizerNative("$cacheDir/${ragConfig.repoName}/embedding/tokenizer")
+            embeddingTokenizer = ORTTokenizerNative(pkgPaths.embeddingTokenizer.absolutePath)
             embeddingTokenizer?.createTokenizerModel()
         }
 
@@ -41,7 +55,7 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
 
             // Create the embedding model
             embeddingModel = createEmbeddingSession(
-                "$cacheDir/${ragConfig.repoName}/embedding",
+                pkgPaths.embedding.absolutePath,
                 ragConfig.onnxName,
                 cacheDir,
                 ragConfig.deviceOptions.memoryConfigId,
@@ -62,19 +76,20 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
         }
     }
 
+    // The active VectorStore boundary over the live ObjectBox database (#25). Null until the DB exists.
+    private fun vectorStore(): VectorStore? = vectorDatabase?.let { ObjectBoxVectorStore(it) }
+
     fun query(queryText : String, ragArgs : ORTRagConfig, ragCallback: RagCallback? = null) {
         // Generate input tokens, but do not add if we already have past attention mask
         ragCallback?.onQueryStart()
 
         try {
 
-            if (ragArgs.searchType == null) {
-                ragCallback?.onError(Throwable("No search type was defined."))
-                return
-            }
-
-            when (ragArgs.searchType) {
-                "semantic" -> {
+            // #6/#25: dispatch on the TYPED SearchType, not the raw wire string. (The old
+            // `searchType == null` guard above this was dead — the field is non-null String.)
+            // fromWire throws on an unrecognized value, which the surrounding catch reports.
+            when (SearchType.fromWire(ragArgs.searchType)) {
+                SearchType.SEMANTIC -> {
                     val inputTokens = embeddingTokenizer?.tokenize(queryText, prependCls = true, appendSep = true, dropZero = true)
 
                     val (inputIds, attentionMask, tokenTypeIds) = prepareEmbeddingInputs(
@@ -99,7 +114,9 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
                     if (embeddings != null) {
 
                         val queryStartTimeMs = System.currentTimeMillis()
-                        val documents = vectorDatabase?.queryDocuments(embeddings, ragArgs.topK)
+                        // Retrieval routes through the VectorStore boundary (#25), not ObjectBox directly.
+                        // #27: honor the configured similarity floor.
+                        val documents = vectorStore()?.search(embeddings, ragArgs.topK, ragArgs.minScore)
                         val queryTimeMs = System.currentTimeMillis() - queryStartTimeMs
 
                         ragCallback?.onQueryResults(
@@ -113,9 +130,9 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
                         ragCallback?.onError(Throwable("Failed to generate embeddings for query text"))
                     }
                 }
-                "text" -> {
+                SearchType.TEXT -> {
                     val queryStartTimeMs = System.currentTimeMillis()
-                    val documents = vectorDatabase?.queryByContent(queryText, ragArgs.topK.toLong())?.map { it to 1.0 }
+                    val documents = vectorStore()?.textSearch(queryText, ragArgs.topK)
                     val queryTimeMs = System.currentTimeMillis() - queryStartTimeMs
 
                     ragCallback?.onQueryResults(
@@ -127,10 +144,6 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
                     )
                 }
 
-                else -> {
-                    ragCallback?.onError(Throwable("Unknown searchType: ${ragArgs.searchType}."))
-                    return
-                }
             }
 
 
@@ -169,9 +182,46 @@ class ORTRetriever(val cacheDir : String, val applicationContext: Context, var _
         return Triple(inputIds, attentionMask, tokenTypeIds)
     }
 
-    suspend fun ingestData() {
-        // TODO: Implement ingesting text data for now from filesystem (.md, .txt,...)
-        // TODO: Simply chunking
+    /**
+     * #26: chunk → embed → store the given [documents]. Fails closed on an unsupported embedding
+     * dimension before any work; binds the real on-device embedder (tokenizer + [performEmbeddingStep])
+     * into the pure [IngestionPipeline]. Returns the number of chunks inserted.
+     */
+    suspend fun ingestData(documents: List<RagDocument>, progress: IngestionProgress? = null): Int {
+        DimensionRegistry.requireSupported(ragConfig.embeddingDimension)
+        val store = vectorStore()
+            ?: throw IllegalStateException("vector store not initialized; call createEmbeddingModel() first")
+        val tokenizer = embeddingTokenizer
+            ?: throw IllegalStateException("embedding tokenizer not initialized")
+
+        return IngestionPipeline.ingest(
+            documents = documents,
+            chunkSize = ragConfig.chunkSize,
+            chunkOverlap = ragConfig.chunkOverlap,
+            store = store,
+            progress = progress,
+            embed = { chunk ->
+                val tokens = tokenizer.tokenize(chunk, prependCls = true, appendSep = true, dropZero = true)
+                if (tokens == null) {
+                    null
+                } else {
+                    val (inputIds, attentionMask, tokenTypeIds) = prepareEmbeddingInputs(
+                        inputTokens = tokens,
+                        maxSequenceLength = tokenizer.maximumTokenLength ?: 512,
+                        padTokenId = tokenizer.padToken ?: 0,
+                    )
+                    performEmbeddingStep(
+                        session = embeddingModel,
+                        inputIds = inputIds,
+                        attentionMask = attentionMask,
+                        tokenTypeIds = tokenTypeIds,
+                        batchSize = 1,
+                        sequenceLength = inputIds.size,
+                        embeddingDim = ragConfig.embeddingDimension,
+                    )
+                }
+            },
+        )
     }
 
     suspend fun destroyEmbeddingModel() {
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTScheduler.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTScheduler.kt
similarity index 68%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTScheduler.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTScheduler.kt
index 9fa6df5..3e689b4 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTScheduler.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTScheduler.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import kotlin.math.*
 
@@ -153,11 +153,47 @@ class LinearLRScheduler(
         currentLR = baseLr * startFactor
     }
 
+    /**
+     * Restore the schedule position. Mirrors [CosineLRScheduler.loadFromState]: only `currentStep`
+     * is restored from the state — `baseLr`/`startFactor`/`endFactor`/`totalIters` are constructor
+     * arguments rebuilt from `training_config.json`, so nothing is reconstructed lossily here.
+     *
+     * These two methods were `TODO("Not yet implemented")`, and [ORTTrainerNative.saveTrainingState]
+     * calls `stateDict()` on every checkpoint. `TODO` throws [NotImplementedError], which is an
+     * `Error` and so slips past the `catch (e: Exception)` around the save — meaning any run using
+     * the DEFAULT linear schedule died at the first checkpoint.
+     */
     override fun loadFromState(state: SchedulerState) {
-        TODO("Not yet implemented")
+        currentStep = state.currentStep
+        // `currentLR` is what the last step() returned, i.e. the factor at currentStep - 1.
+        currentLR = if (currentStep <= 0) baseLr * startFactor else calculateLR(currentStep - 1)
     }
 
-    override fun stateDict(): SchedulerState {
-        TODO("Not yet implemented")
+    /** The factor curve of [step], without advancing — shared by [step] and [loadFromState]. */
+    private fun calculateLR(step: Int): Float {
+        val factor = when {
+            step >= totalIters -> endFactor
+            totalIters <= 1 -> endFactor
+            else -> {
+                val progress = step.toFloat() / (totalIters - 1).toFloat()
+                startFactor + (endFactor - startFactor) * progress
+            }
+        }
+        return baseLr * factor
     }
+
+    /**
+     * Projected onto the shared [SchedulerState] record — deliberately NO format change, so
+     * `training_state.json` and [com.martinkorelic.mobiletransformers.training.CheckpointInfo]
+     * (which reads `currentStep`/`totalSteps`) stay byte-compatible with existing checkpoints.
+     * The linear schedule has no warmup phase, and its LR range is `[baseLr*endFactor, baseLr*startFactor]`.
+     */
+    override fun stateDict(): SchedulerState =
+        SchedulerState(
+            totalSteps = totalIters,
+            warmupSteps = 0,
+            minLr = baseLr * endFactor,
+            initialLr = baseLr * startFactor,
+            currentStep = currentStep,
+        )
 }
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTokenizerNative.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTokenizerNative.kt
similarity index 80%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTokenizerNative.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTokenizerNative.kt
index d64d6ec..361b318 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTokenizerNative.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTokenizerNative.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.util.Log
 import com.google.gson.Gson
@@ -13,6 +13,11 @@ import java.io.File
  */
 class ORTTokenizerNative (private val tokenizerDir : String) {
 
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+
     val LOG_TAG = "ORTTokenizerNative"
 
     var vocabSize: Int = 0
@@ -30,7 +35,6 @@ class ORTTokenizerNative (private val tokenizerDir : String) {
 
     // Tokenizer config
     private val tokenizerConfigFileName = "tokenizer_config.json"
-    private var applyChatTemplate : Boolean = false
 
     // Important text control tokens
     // This tokens should be set
@@ -65,11 +69,16 @@ class ORTTokenizerNative (private val tokenizerDir : String) {
 
     init {
 
-        val modelFields = readModelFieldsFromJson("${tokenizerDir}/ortmobile_tokenizer_config.json")
+        val modelFields = readModelFieldsFromJson("${tokenizerDir}/mobiletransformers_tokenizer_config.json")
         loadTokenizerConfiguration("${tokenizerDir}/${tokenizerConfigFileName}")
         // Load special token map
         loadSpecialTokensMapFromFile("$tokenizerDir/$specialTokenFileName")
 
+        // Deliberately AFTER the special-token map is populated. The probe render feeds the same
+        // context a real turn does, and templates routinely reference `bos_token`/`eos_token`; probing
+        // before the map exists would fail templates that work perfectly in use.
+        validateChatTemplate()
+
         if (!modelFields) {
             Log.e(LOG_TAG, "Error reading training_config.json fields for tokenizer.")
         }
@@ -179,22 +188,32 @@ class ORTTokenizerNative (private val tokenizerDir : String) {
                 tokenizerConfig["model_max_length"]?.asInt?.let { maxLength -> maximumTokenLength = if (maxLength == 0) Int.MAX_VALUE else maxLength }
             }
 
-            // Extract the chat template
-            chatTemplate = tokenizerConfig["chat_template"]?.asString
+            // Extract the chat template. Only a CANDIDATE at this point — [validateChatTemplate]
+            // decides whether it survives, once the special-token map is loaded.
+            chatTemplate = resolveChatTemplate(tokenizerConfig, tokenizerConfigFile.parentFile)
 
             if (chatTemplate == null)   {
-                Log.w(LOG_TAG, "Chat template not found in $tokenizerConfigPath. No chat template will be used.")
+                Log.w(LOG_TAG, "Chat template not found for $tokenizerDir. Prompts will NOT be turn-wrapped.")
                 return
             }
 
-            applyChatTemplate = true
-
         } catch (e: Exception) {
             e.printStackTrace()
             return
         }
     }
 
+    /**
+ * Drop the resolved template unless Pebble can actually evaluate it.
+     *
+ * Delegates to [validatedChatTemplate]; the logic lives in the companion because this class
+ * cannot be constructed off-device — its `init` loads the native library — and the resolution
+ * rules are exactly the part worth testing on the JVM.
+ */
+    private fun validateChatTemplate() {
+        chatTemplate = validatedChatTemplate(chatTemplate, getSpecialTokensWithContent())
+    }
+
     fun readModelFieldsFromJson(filePath: String): Boolean {
         try {
             // Read the JSON file from internal storage
@@ -459,6 +478,16 @@ class ORTTokenizerNative (private val tokenizerDir : String) {
                  appendSep : Boolean = false,
                  dropZero : Boolean = false) : IntArray {
 
+        // Fail closed on an unopened session. `tokenizeString` dereferences this handle in native
+        // code, so a 0 here is a SIGSEGV that takes down the whole instrumentation run and names
+        // nothing — the constructor reads the configs but deliberately does NOT open the native
+        // session, so calling tokenize() before createTokenizerModel() is an easy and silent mistake.
+        // (It cost a device run on 2026-08-14.)
+        check(tokenizerModel != 0L) {
+            "tokenizer session is not open: call createTokenizerModel() before tokenize(). " +
+                "The constructor only loads the JSON configs."
+        }
+
         var tokens = tokenizeString(tokenizerModel, sequence)
 
         // Drop trailing zeros if requested
@@ -690,4 +719,95 @@ class ORTTokenizerNative (private val tokenizerDir : String) {
     external fun createTokenizerSession(tokenizerFilePath : String) : Long
 
     external fun releaseTokenizerSession(tokenizerModel: Long)
+
+    /**
+ * Chat-template resolution, kept static and side-effect-free so it can be tested on the JVM.
+     *
+ * The instance side of this class cannot be constructed off-device — `init` runs
+ * `System.loadLibrary` — so anything living only there is unreachable by the host suite. That is
+ * how the sibling-file bug survived: nothing host-side could observe [resolveChatTemplate]'s
+ * result. Mirrors the shape of `packages.ToolCallSupport`.
+ */
+    companion object {
+        private const val TAG = "ORTTokenizerNative"
+
+        /** Where the exporter puts the template, as a sibling of `tokenizer_config.json`. */
+        const val CHAT_TEMPLATE_FILE_NAME = "chat_template.jinja"
+
+    /**
+ * The package's Jinja chat template, from either place it may live.
+     *
+ * The sibling file is the normal case, and reading only the inline key was the bug:
+ * `export/pipeline.py::_emit_chat_template` writes the template to
+ * [CHAT_TEMPLATE_FILE_NAME] beside `tokenizer_config.json` and leaves **no** `chat_template`
+ * key behind, and the installers flatten it into `tokenizer/`. So the key lookup found
+ * nothing for every package the exporter has ever produced, [ORTConversationState] was never
+ * constructed, and no plain-chat prompt was ever wrapped in the model's turn format.
+     *
+ * The inline key is still checked first: packages predating that change carry it, and one
+ * shipping both is stating a deliberate override.
+     *
+ * Note this does NOT share `ToolCallSupport.readChatTemplate`. That function's fallback
+ * returns the whole of `tokenizer_config.json` when the substring matches — correct for
+ * sniffing a dialect out of it, useless as a template, and megabytes wide on a large vocab.
+ */
+        @JvmStatic
+        fun resolveChatTemplate(tokenizerConfig: JsonObject?, tokenizerDir: File?): String? {
+            // Guard the type instead of calling asString blind: chat_template is sometimes a LIST of
+            // named templates ({name, template}) rather than a string, and asString throws on that.
+            val inline = tokenizerConfig?.get("chat_template")
+            ?.takeIf { it.isJsonPrimitive }
+            ?.asString
+            ?.takeIf { it.isNotBlank() }
+            if (inline != null) return inline
+
+            val sibling = tokenizerDir?.let { File(it, CHAT_TEMPLATE_FILE_NAME) } ?: return null
+            if (!sibling.isFile) return null
+            return runCatching { sibling.readText(Charsets.UTF_8) }
+.onFailure { Log.w(TAG, "Could not read $sibling", it) }
+.getOrNull()
+            ?.takeIf { it.isNotBlank() }
+}
+
+    /**
+ * [candidate] if Pebble can evaluate it against a probe turn, otherwise null.
+     *
+ * A template that throws is strictly worse than no template: without this check the failure
+ * lands mid-generation, once per turn, rather than once at load. Pebble is not Jinja —
+ * FunctionGemma's template alone uses `namespace`, `dictsort` and macros it does not
+ * implement — so catching that here and falling back to an unwrapped prompt is the designed
+ * outcome, not a regression.
+     *
+ * @param specialTokens must already be populated; templates routinely reference
+ * `bos_token`/`eos_token`, and probing against an empty map would reject working templates.
+ */
+        @JvmStatic
+        fun validatedChatTemplate(candidate: String?, specialTokens: Map<String, String>): String? {
+            if (candidate == null) return null
+            val rendered = runCatching {
+                val context = mutableMapOf<String, Any>(
+                    "messages" to listOf(
+                        mapOf("role" to "user", "content" to "ping"),
+                        mapOf("role" to "assistant", "content" to "pong"),
+),
+                    "add_generation_prompt" to true,
+        )
+                context.putAll(specialTokens)
+                ORTChatTemplateHandler(candidate).buildInput(context)
+            }.getOrElse { failure ->
+                Log.w(TAG, "Chat template failed its probe render; continuing unwrapped.", failure)
+                return null
+    }
+
+            // A template evaluating to nothing is a silent prompt-eater — generation would be handed
+            // an empty string every turn. Treat it exactly like one that threw.
+            if (rendered.isBlank()) {
+                Log.w(TAG, "Chat template rendered empty on probe; continuing unwrapped.")
+                return null
+    }
+
+            Log.i(TAG, "Chat template active (${candidate.length} chars); prompts are turn-wrapped.")
+            return candidate
+    }
+    }
 }
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainerNative.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainerNative.kt
similarity index 78%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainerNative.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainerNative.kt
index 8762c2e..235f7c2 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainerNative.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainerNative.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.app.ActivityManager
 import android.content.Context
@@ -6,9 +6,10 @@ import android.os.Debug
 import android.util.Log
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
-import com.martinkorelic.ortmobile.repository.TrainingCallback
+import com.martinkorelic.mobiletransformers.repository.TrainingCallback
 import java.io.File
 import java.io.IOException
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
 
 data class TrainingState(
     val schedulerState: SchedulerState,
@@ -18,18 +19,27 @@ data class TrainingState(
 
 class ORTTrainerNative(private val context: Context, private val cacheDirPath: String, private var tokenizer: ORTTokenizerNative, private val trainingConfig: ORTTrainingConfig) {
 
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+
     private val LOG_TAG = "ORTTrainerNative"
 
     // Pointer to the model
     var model : Long = 0;
     var scheduler : LearningRateScheduler? = null
 
-    val trainingModelPath = "$cacheDirPath/${trainingConfig.repoName}/train/training_model.onnx"
-    val evalModelPath = "$cacheDirPath/${trainingConfig.repoName}/train/eval_model.onnx"
-    val checkpointPath = "$cacheDirPath/${trainingConfig.repoName}/train/checkpoint"
-    val optimizerPath = "$cacheDirPath/${trainingConfig.repoName}/train/optimizer_model.onnx"
+    // G2: one resolver for this package's stages; nothing below appends a stage name to a string.
+    private val pkgPaths = PackagePaths.forCache(cacheDirPath, trainingConfig.repoName)
+    private val trainDir = pkgPaths.train.absolutePath
 
-    val dataCurator = ORTDataCurator(tokenizer, "$cacheDirPath/${trainingConfig.repoName}/train/${trainingConfig.datasetOptions.trainFile}", trainingConfig.batchSize, trainingConfig.datasetOptions.maxSequenceLength, trainingConfig.datasetOptions.removeLongSamples, trainingConfig.datasetOptions.maxDatasetLength, trainingConfig.datasetOptions.datasetBatchSize, getPreprocessFunctionForTask(trainingConfig.taskName, trainingConfig.customPreprocess))
+    val trainingModelPath = "$trainDir/training_model.onnx"
+    val evalModelPath = "$trainDir/eval_model.onnx"
+    val checkpointPath = "$trainDir/checkpoint"
+    val optimizerPath = "$trainDir/optimizer_model.onnx"
+
+    val dataCurator = ORTDataCurator(tokenizer, "$trainDir/${trainingConfig.datasetOptions.trainFile}", trainingConfig.batchSize, trainingConfig.datasetOptions.maxSequenceLength, trainingConfig.datasetOptions.removeLongSamples, trainingConfig.datasetOptions.maxDatasetLength, trainingConfig.datasetOptions.datasetBatchSize, getPreprocessFunctionForTask(trainingConfig.taskName, trainingConfig.customPreprocess))
     private val dataCollator = DataCollatorForSupervisedDataset(tokenizer)
 
     // Training state
@@ -41,6 +51,11 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
     var epoch : Int = 0
     var accumulatedLoss = 0f
 
+    // Cooperative cancellation (#18): TrainingJob.cancel(...) sets this; the step/epoch loops check it and
+    // break cleanly so the existing saveModel + saveTrainingState path can run. Not a loop-logic change.
+    @Volatile
+    var cancelRequested : Boolean = false
+
 
     // Training metrics
 
@@ -62,12 +77,36 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
         val final_loss: Float,
         val peak_memory_mb: Long,
         val average_memory_mb: Float
-    )
+    ) {
+        /** #17: convert to the public mirror so no `ORT*` type reaches the facade surface. */
+        fun toPublic(): com.martinkorelic.mobiletransformers.runtime.TrainingSummary =
+            com.martinkorelic.mobiletransformers.runtime.TrainingSummary(
+                trainRuntimeSeconds = train_runtime_seconds,
+                trainStepsPerSecond = train_steps_per_second,
+                trainSamplesPerSecond = train_samples_per_second,
+                totalSteps = total_steps,
+                totalSamples = total_samples,
+                finalLoss = final_loss,
+                peakMemoryMb = peak_memory_mb,
+                averageMemoryMb = average_memory_mb,
+            )
+    }
 
     private val trainingMetrics = mutableListOf<TrainingStepMetrics>()
 
+    /**
+     * The run-level summary produced by [saveTrainingLogs], or null.
+     *
+     * Deliberately null unless `trainingConfig.profileMetrics` is on: the summary is computed from the
+     * per-step metric samples, which are only collected under that flag. Reporting zeros instead would
+     * be worse than reporting nothing.
+     */
+    @Volatile
+    var lastSummary: TrainingSummary? = null
+        private set
+
     init {
-        val requiresGrad = loadTrainableLayerNamesJSON("$cacheDirPath/${trainingConfig.repoName}/train/training_config.json")
+        val requiresGrad = loadTrainableLayerNamesJSON("$trainDir/training_config.json")
 
         if (requiresGrad == null) {
             Log.e(LOG_TAG, "No training config provided. Model cannot be initialized.")
@@ -79,7 +118,7 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
 
         // Load training state if available
         if (trainingConfig.loadFromState)
-            trainingState = loadTrainingState("$cacheDirPath/${trainingConfig.repoName}/train/training_state.json")
+            trainingState = loadTrainingState("$trainDir/training_state.json")
     }
 
     private fun loadTrainingState(trainingStatePath: String): TrainingState? {
@@ -111,7 +150,7 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
 
     private fun saveTrainingState(globalStep: Int, epoch: Int, scheduler: LearningRateScheduler): Boolean {
         return try {
-            val trainingStatePath = "$cacheDirPath/${trainingConfig.repoName}/train/training_state.json"
+            val trainingStatePath = "$trainDir/training_state.json"
             val trainingStateFile = File(trainingStatePath)
 
             // Ensure the directory exists
@@ -216,6 +255,11 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
 
             while (epoch < trainingConfig.numTrainEpochs && globalStep < totalSteps) {
 
+                if (cancelRequested) {
+                    Log.i(LOG_TAG, "Training cancelled at epoch $epoch (global step: $globalStep)")
+                    break
+                }
+
                 Log.i(LOG_TAG, "Starting epoch $epoch (global step: $globalStep)")
 
                 val epochStartTime = System.currentTimeMillis()
@@ -240,6 +284,11 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
 
                 for (batch in dataloader) {
 
+                    // Cooperative cancel (#18): break out so the outer while sees the flag and exits cleanly.
+                    if (cancelRequested) {
+                        break
+                    }
+
                     // End the training if global steps have been reached
                     if (globalStep >= totalSteps) {
                         break
@@ -418,8 +467,10 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
                     )
                 )
 
-                // Destroy training session and save model
-                destroySession(true)
+                // Save the checkpoint, and release the session unless the caller asked to keep it.
+                // `destroySession(true)` does both; splitting them is what lets a caller read the
+                // checkpoint it just trained (see keepSessionAtEnd).
+                if (trainingConfig.keepSessionAtEnd) saveModel(model, true) else destroySession(true)
 
                 // Callbacks: onSaveModelEnd
                 callback?.onSaveModelEnd(
@@ -434,7 +485,7 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
                         totalDurationMs = System.currentTimeMillis() - saveModelStart
                     )
                 )
-            } else {
+            } else if (!trainingConfig.keepSessionAtEnd) {
                 // Destroy training session without saving
                 destroySession(false)
             }
@@ -552,6 +603,8 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
                 average_memory_mb = avgMemoryMB
             )
 
+            lastSummary = summary
+
             // Create complete training log
             val trainingLog = mapOf(
                 "summary" to summary,
@@ -563,7 +616,7 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
             val jsonString = gson.toJson(trainingLog)
 
             // Save to internal storage
-            val file = File("$cacheDirPath/${trainingConfig.repoName}/train/training_logs.json")
+            val file = File("$trainDir/training_logs.json")
             file.writeText(jsonString)
 
             Log.i(LOG_TAG, "Training logs saved to: ${file.absolutePath}")
@@ -579,13 +632,50 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
         }
     }
 
+    /**
+     * Release the native training session. Idempotent.
+     *
+     * The handle used to be passed to `releaseTrainingSession` unconditionally and never cleared, so a
+     * second call — which the train->merge->generate flow makes, once at the end of training and once on
+     * teardown — freed an already-freed `TrainingSessionCache` and took the process down with SIGSEGV in
+     * `Java_..._releaseTrainingSession`. Zeroing the handle under the same guard makes the second call a
+     * no-op instead of a use-after-free.
+     */
+    @Synchronized
     fun destroySession(saveCheckpoint: Boolean) {
+        if (model == 0L) {
+            Log.d(LOG_TAG, "Training session already released; nothing to destroy.")
+            return
+        }
         Log.d(LOG_TAG, "Destroying training session and saving checkpoint...")
-        releaseTrainingSession(model, saveCheckpoint = saveCheckpoint)
+        val handle = model
+        model = 0L
+        releaseTrainingSession(handle, saveCheckpoint = saveCheckpoint)
     }
 
     fun mergeExportSessionWeights() {
-        mergeExportWeights(model, "$cacheDirPath/${trainingConfig.repoName}/train/training_config.json", "$cacheDirPath/${trainingConfig.repoName}/train", "$cacheDirPath/${trainingConfig.repoName}/inference/merged")
+        // #9 unified layout: the merger ONNX models + weight_handoff_map.json live in the inference
+        // package dir, and merged trainable tensors overwrite their per-tensor <name>.bin in place there
+        // (atomic rename + checksum on the native side). The old inference/merged subdir is retired.
+        // #23: the native LOAD side (ORTGeneratorNative + session_cache.h) now consumes the handoff map
+        // (map present + every externalDataLocation .bin exists + checksum valid), so these in-place
+        // merges are seen fail-closed at load time.
+        val inferenceDir = pkgPaths.inference.absolutePath
+        val merged = mergeExportWeights(
+            model,
+            "$trainDir/training_config.json",
+            inferenceDir,
+            inferenceDir,
+        )
+        // #9 fail-closed: the native merge reports partial/failed writes, and discarding that left a
+        // half-merged inference/ dir looking like a successful train→merge. Some tensors would carry
+        // the trained values and the rest the frozen base — the model still generates, just wrongly.
+        if (!merged) {
+            throw MissingArtifactException(
+                "weight merge failed for $inferenceDir (see logcat for the offending tensor); " +
+                    "the inference package may be partially merged",
+            )
+        }
     }
 
     external fun releaseTrainingSession(session: Long, saveCheckpoint : Boolean)
@@ -609,4 +699,18 @@ class ORTTrainerNative(private val context: Context, private val cacheDirPath: S
         outputDirectory: String?
     ): Boolean
 
+    /**
+     * #36: raw little-endian bytes of one ORT checkpoint parameter, or `null` if absent.
+     *
+     * Moves BYTES only — the federated record's format is owned by `federated/AdapterTensorCodec`,
+     * which is pinned byte-for-byte against the cross-language golden. See the C++ docstring for why
+     * the record is not assembled natively.
+     */
+    external fun nativeExportCheckpointTensor(session: Long, name: String): ByteArray?
+
+    /** #36: writes raw little-endian bytes back into one checkpoint parameter, by name. */
+    external fun nativeImportCheckpointTensor(session: Long, name: String, data: ByteArray): Boolean
+
+    /** The live training session handle, for the federated round to read/write checkpoint tensors. */
+    internal fun trainingSessionHandle(): Long = model
 }
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainingConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainingConfig.kt
similarity index 62%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainingConfig.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainingConfig.kt
index c08954f..55b770f 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTTrainingConfig.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTTrainingConfig.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 // Scheduler configuration classes
 sealed class SchedulerConfig {
@@ -46,6 +46,21 @@ data class ORTTrainingConfig(
 
     val mergeWeightsAtEnd : Boolean = true,
     val saveModelAtEnd : Boolean = true,
+
+    /**
+     * Keep the native training session OPEN when the run finishes (#36).
+     *
+     * `startTraining` releases the session on every exit path — with the checkpoint saved when
+     * [saveModelAtEnd], without it otherwise. That is why every post-training step in this library
+     * (the merge, the checkpoint cadence) happens *inside* `startTraining`: afterwards there is no
+     * session left to act on. A federated round has to read the checkpoint it just trained, and
+     * re-opening a session to do so would reload ~176 MB to look at the ~2 MB of adapter factors it
+     * had in memory a moment earlier.
+     *
+     * Default `false`, so every existing caller keeps the release-at-end behaviour it was written
+     * against. When true, the caller owns the session and MUST call [destroySession] itself.
+     */
+    val keepSessionAtEnd : Boolean = false,
     val loadFromState : Boolean = true,
     val profileMetrics : Boolean = false,
 
@@ -54,7 +69,24 @@ data class ORTTrainingConfig(
     val schedulerType: String = "linear", // Options: "linear", "cosine"
     val schedulerConfig: SchedulerConfig = SchedulerConfig.Linear(),
 
-    val deviceOptions: DeviceOptions = DeviceOptions(),
+    /**
+     * **Training defaults to `low_mem`, unlike inference.**
+     *
+     * `high_perf` maps to `EnableMemPattern()` + `EnableCpuMemArena()` in `setSessionOptions`. For a
+     * forward-only inference session that is the right trade. For a *training* session it is not:
+     * the memory pattern planner pre-allocates the whole activation plan for the backward pass, and
+     * the CPU arena grows to the peak and never returns it, so the process holds its high-water mark
+     * for the rest of the run.
+     *
+     * Measured: FunctionGemma-270M (268,098,176 parameters, ~1.07 GB of fp32 weights) reached
+     * **2.35 GB RSS + 1.02 GB swap** under `high_perf` and was SIGKILLed by `lmkd` on a 5.5 GB device
+     * — roughly 3x the model, for a LoRA run with 368,640 trainable parameters. Nothing about the
+     * model needs that; the allocator does.
+     *
+     * A caller that wants the throughput can still pass `high_perf` explicitly. The default is the
+     * one that finishes.
+     */
+    val deviceOptions: DeviceOptions = DeviceOptions(memoryConfigId = "low_mem"),
 
     var customPreprocess: TaskPreprocessor? = null
 ) {
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTVectorDatabase.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTVectorDatabase.kt
similarity index 80%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTVectorDatabase.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTVectorDatabase.kt
index 5a47e87..d6d2b64 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTVectorDatabase.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/ORTVectorDatabase.kt
@@ -1,25 +1,27 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import android.content.Context
 import android.util.Log
-import com.martinkorelic.ortmobile.entity.MyObjectBox
-import com.martinkorelic.ortmobile.entity.VectorEntity1024
-import com.martinkorelic.ortmobile.entity.VectorEntity1024_
-import com.martinkorelic.ortmobile.entity.VectorEntity256
-import com.martinkorelic.ortmobile.entity.VectorEntity128
-import com.martinkorelic.ortmobile.entity.VectorEntity128_
-import com.martinkorelic.ortmobile.entity.VectorEntity1536
-import com.martinkorelic.ortmobile.entity.VectorEntity1536_
-import com.martinkorelic.ortmobile.entity.VectorEntity256_
-import com.martinkorelic.ortmobile.entity.VectorEntity384
-import com.martinkorelic.ortmobile.entity.VectorEntity384_
-import com.martinkorelic.ortmobile.entity.VectorEntity512
-import com.martinkorelic.ortmobile.entity.VectorEntity512_
-import com.martinkorelic.ortmobile.entity.VectorEntity64
-import com.martinkorelic.ortmobile.entity.VectorEntity64_
-import com.martinkorelic.ortmobile.entity.VectorEntity768
-import com.martinkorelic.ortmobile.entity.VectorEntity768_
-import com.martinkorelic.ortmobile.entity.VectorEntityInterface
+import com.martinkorelic.mobiletransformers.entity.MyObjectBox
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.entity.VectorEntity1024
+import com.martinkorelic.mobiletransformers.entity.VectorEntity1024_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity256
+import com.martinkorelic.mobiletransformers.entity.VectorEntity128
+import com.martinkorelic.mobiletransformers.entity.VectorEntity128_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity1536
+import com.martinkorelic.mobiletransformers.entity.VectorEntity1536_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity256_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity384
+import com.martinkorelic.mobiletransformers.entity.VectorEntity384_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity512
+import com.martinkorelic.mobiletransformers.entity.VectorEntity512_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity64
+import com.martinkorelic.mobiletransformers.entity.VectorEntity64_
+import com.martinkorelic.mobiletransformers.entity.VectorEntity768
+import com.martinkorelic.mobiletransformers.entity.VectorEntity768_
+import com.martinkorelic.mobiletransformers.entity.VectorEntityInterface
+import com.martinkorelic.mobiletransformers.rag.DimensionRegistry
 import io.objectbox.*
 import io.objectbox.query.QueryBuilder
 import java.io.File
@@ -44,7 +46,9 @@ class ORTVectorDatabase private constructor(context: Context, cacheDir : String,
         @Volatile
         private var instances = mutableMapOf<String, ORTVectorDatabase>()
 
-        val SUPPORTED_DIMENSIONS = setOf(64, 128, 256, 384, 512, 768, 1024, 1536)
+        // Single declared source of supported dimensions (#25). Adding a dimension is one
+        // DimensionRegistry.register(dim) + its @HnswIndex VectorEntity<dim> entity.
+        val SUPPORTED_DIMENSIONS: Set<Int> get() = DimensionRegistry.SUPPORTED_DIMENSIONS
 
         fun getInstance(
             modelName: String,
@@ -77,7 +81,8 @@ class ORTVectorDatabase private constructor(context: Context, cacheDir : String,
         // Initialize ObjectBox
         boxStore = MyObjectBox.builder()
             .androidContext(context)
-            .directory(File("$cacheDir/$modelName/embedding/database"))
+            // G2: the store lives INSIDE the embedding stage; resolve the stage, then the sub-path.
+            .directory(PackagePaths.forCache(cacheDir, modelName).embeddingDatabase)
             .build()
 
         // Initialize only the box we need based on dimensions
@@ -123,15 +128,44 @@ class ORTVectorDatabase private constructor(context: Context, cacheDir : String,
         }
 
         return try {
+            // Named arguments deliberately: the entities declare (id, name, document, content, …) while
+            // this function's parameters read (name, content, document, …), and the positional calls that
+            // used to be here passed `content` into `document` and vice versa for every dimension. Stored
+            // documents came back with their text in `id` and their id in `text`, and `queryByContent`
+            // (which indexes `content`) was searching over ids instead of document bodies.
             val id = when (ortRagConfig.embeddingDimension) {
-                64 -> vectorBox64!!.put(VectorEntity64(0, name, content, document, embedding, metadata))
-                128 -> vectorBox128!!.put(VectorEntity128(0, name, content, document, embedding, metadata))
-                256 -> vectorBox256!!.put(VectorEntity256(0, name, content, document, embedding, metadata))
-                384 -> vectorBox384!!.put(VectorEntity384(0, name, content, document, embedding, metadata))
-                512 -> vectorBox512!!.put(VectorEntity512(0, name, content, document, embedding, metadata))
-                768 -> vectorBox768!!.put(VectorEntity768(0, name, content, document, embedding, metadata))
-                1024 -> vectorBox1024!!.put(VectorEntity1024(0, name, content, document, embedding, metadata))
-                1536 -> vectorBox1536!!.put(VectorEntity1536(0, name, content, document, embedding, metadata))
+                64 -> vectorBox64!!.put(VectorEntity64(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                128 -> vectorBox128!!.put(VectorEntity128(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                256 -> vectorBox256!!.put(VectorEntity256(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                384 -> vectorBox384!!.put(VectorEntity384(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                512 -> vectorBox512!!.put(VectorEntity512(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                768 -> vectorBox768!!.put(VectorEntity768(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                1024 -> vectorBox1024!!.put(VectorEntity1024(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
+                1536 -> vectorBox1536!!.put(VectorEntity1536(
+                    id = 0, name = name, document = document,
+                    content = content, embedding = embedding, metadata = metadata,
+                ))
                 else -> throw IllegalStateException("Unsupported dimensions: $ortRagConfig.embeddingDimension")
             }
 
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/PebbleUtil.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/PebbleUtil.kt
similarity index 99%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/PebbleUtil.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/PebbleUtil.kt
index c4c0b8a..fa5b21c 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/PebbleUtil.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/PebbleUtil.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 import io.pebbletemplates.pebble.error.PebbleException
 import io.pebbletemplates.pebble.extension.AbstractExtension
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/RetrieveCallback.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/RetrieveCallback.kt
new file mode 100644
index 0000000..6fb705d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/RetrieveCallback.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers
+
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+
+/**
+ * Public retrieval callback for [MobileTransformerModel.retrieve] (#19). Mirrors the internal
+ * `RagCallback`, delivering the neutral [RetrievalResult] (never `RagResult`/`RagMatch`/`ORT*`).
+ */
+interface RetrieveCallback {
+    fun onQueryResults(result: RetrievalResult) {}
+
+    fun onQueryEnd() {}
+
+    fun onError(error: Throwable) {}
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/SpecialTokenModel.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/SpecialTokenModel.kt
similarity index 86%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/SpecialTokenModel.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/SpecialTokenModel.kt
index ebcecdf..c1fc6d3 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/SpecialTokenModel.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/SpecialTokenModel.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile
+package com.martinkorelic.mobiletransformers
 
 data class TokenAttributes(
     var tokenId : Int?,
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/TrainCallback.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/TrainCallback.kt
new file mode 100644
index 0000000..9b48bbd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/TrainCallback.kt
@@ -0,0 +1,41 @@
+package com.martinkorelic.mobiletransformers
+
+/**
+ * Public training progress (#19), mapped 1:1 from the internal `TrainingProgress`.
+ */
+data class TrainProgress(
+    val currentStep: Int,
+    val currentEpoch: Int,
+    val totalLoss: Float = 0f,
+    val epochLoss: Float = 0f,
+    val stepLoss: Float = 0f,
+    val learningRate: Float = 0f,
+    val stepDurationMs: Long = 0L,
+    val epochDurationMs: Long = 0L,
+    val totalDurationMs: Long = 0L,
+    val isCompleted: Boolean = false,
+)
+
+/**
+ * Public training lifecycle callback for [MobileTransformerModel.train] (#19). Mirrors the internal
+ * `TrainingCallback` so app code never imports repository/`ORT*` types. All methods are optional.
+ */
+interface TrainCallback {
+    fun onModelLoadStart() {}
+
+    fun onModelLoadEnd() {}
+
+    fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch: Int) {}
+
+    fun onStepEnd(progress: TrainProgress) {}
+
+    fun onEpochEnd(progress: TrainProgress) {}
+
+    fun onMergeStart(progress: TrainProgress) {}
+
+    fun onMergeEnd(progress: TrainProgress) {}
+
+    fun onCompletion(progress: TrainProgress) {}
+
+    fun onError(error: Throwable) {}
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidator.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidator.kt
new file mode 100644
index 0000000..bb6d6dd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidator.kt
@@ -0,0 +1,257 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+import java.io.File
+
+/**
+ * Rejected because the model asked for something the app did not declare, or asked for it wrongly.
+ *
+ * A distinct type because rejection is the **expected** outcome for untrusted output, not a defect —
+ * callers route it to "I can't do that" rather than to error reporting.
+ */
+class RejectedCallException(message: String) : MobileTransformersException(message)
+
+/**
+ * What an app declares a model is allowed to ask for. One row per action.
+ *
+ * `allowedIntent` is the ONLY intent this action can ever produce — it comes from the app's own
+ * declaration, never from model output. That is what makes the validator a boundary rather than a
+ * formatter: a model cannot name an intent, only an action the app already permitted.
+ *
+ * @property validationRules parameter name -> rule. Two forms are supported, both deliberately small:
+ *   `"HH:mm"` (a literal time-of-day format) and `"/<regex>/"`. Anything richer belongs in the caller's
+ *   own check after validation, not in a mini-language here — an expressive rule DSL parsed from app
+ *   config is another place for a mistake to hide.
+ * @property privacyClass documentation for the app's own review (e.g. `"harmless-demo"`); it is not
+ *   interpreted here, and is present so an allowlist can be audited without reading code.
+ */
+data class ActionSpec(
+    val actionName: String,
+    val parameters: Map<String, String> = emptyMap(),
+    val allowedIntent: String,
+    val validationRules: Map<String, String> = emptyMap(),
+    val privacyClass: String = "unspecified",
+    /**
+     * Parameters that MUST be present. `null` means "all declared ones", which is what a hand-written
+     * allowlist means and what this validator enforced before optional parameters existed.
+     *
+     * Real tool schemas separate the two. In `google/mobile-actions`, `send_email` declares
+     * `subject`/`body`/`to` but requires only `to`/`subject`; `create_contact` requires 2 of 4.
+     * Treating every declared parameter as required would reject calls that corpus considers correct
+     * — the model would be trained toward targets its own validator refuses.
+     */
+    val requiredParameters: Set<String>? = null,
+    /**
+ * Android permissions the app must hold before [allowedIntent] can actually be started.
+ *
+ * Declared here, beside the intent, because the two are one fact: `SET_ALARM` requires
+ * `com.android.alarm.permission.SET_ALARM`, and an app that declares the action without the
+ * permission has an allowlist entry that always fails. That is precisely what happened — the
+ * sample app offered `set_alarm`, the model produced a valid call, the validator accepted it, and
+ * `startActivity` threw `SecurityException` at the last possible moment, which reads to a user as
+ * the feature being broken rather than as a missing manifest line.
+ *
+ * The SDK does not check or request these; it only carries them, so a caller can ask **before**
+ * firing rather than catching a failure afterwards. Whether a permission is install-time (granted
+ * automatically, like `SET_ALARM`) or runtime-dangerous (a system dialog, like `READ_CALENDAR`)
+ * is Android's business, not the allowlist's — the app resolves that when it acts.
+ */
+    val requiredPermissions: List<String> = emptyList(),
+) {
+    /** The effective required set: all declared parameters unless [requiredParameters] narrows it. */
+    val required: Set<String> get() = requiredParameters ?: parameters.keys
+}
+
+/**
+ * The raw shape parsed out of model output. Untrusted until [FunctionCallValidator] accepts it.
+ *
+ * Public because the format a model speaks is a property of the model, not of the boundary: a
+ * [ToolCallParser] produces one of these from JSON, from FunctionGemma's `call:` grammar, or from
+ * whatever a future model emits, and the validator then judges it identically. Holding one means
+ * nothing has been checked yet — [ValidatedCall] is the type that carries a decision.
+ */
+data class ToolCall(
+    val actionName: String? = null,
+    val parameters: Map<String, String>? = null,
+)
+
+/**
+ * A call that passed every check, paired with the app's own spec for it.
+ *
+ * Construction is the proof: nothing else in this package produces one, so holding a [ValidatedCall]
+ * means the allowlist and the rules were satisfied. [IntentBinder] takes only this type, which is what
+ * makes "no arbitrary model output is ever executed" a property of the types rather than of a habit.
+ */
+data class ValidatedCall(
+    val spec: ActionSpec,
+    val parameters: Map<String, String>,
+) {
+    val actionName: String get() = spec.actionName
+    val allowedIntent: String get() = spec.allowedIntent
+
+    /** Permissions the app must hold to start [allowedIntent] — see [ActionSpec.requiredPermissions]. */
+    val requiredPermissions: List<String> get() = spec.requiredPermissions
+}
+
+/**
+ * Turns raw model output into a [ValidatedCall], or refuses.
+ *
+ * #37's safety contract, stated as one rule: **the model chooses among what the app already declared;
+ * it never introduces anything.** Every field that reaches Android — the intent action above all —
+ * comes from [ActionSpec], and the only thing taken from the model is *which* action and *which*
+ * parameter values, both checked before they are handed on.
+ *
+ * Gson because it is the module's single JSON library (per the typed fail-closed parsing decision) and
+ * already a dependency.
+ */
+class FunctionCallValidator(
+    /**
+     * What the app permits — readable so the same object can be *declared to the model*.
+     *
+     * [ToolPromptBuilder] renders it into the tool declaration a prompt carries. Generating the
+     * declaration from the enforcement list, rather than writing it out beside it, is the same
+     * argument that generates the training corpus from it: three copies of the boundary would be
+     * three chances for them to disagree, and the disagreement surfaces as an unexplained refusal.
+     */
+    val allowlist: List<ActionSpec>,
+) {
+
+    companion object {
+        private val HH_MM = Regex("^([01]\\d|2[0-3]):[0-5]\\d$")
+
+        /** The filename `mobiletransformers agent-dataset` writes beside the training JSONL. */
+        const val ACTION_SCHEMA_FILENAME = "action_schema.json"
+
+        /**
+         * Build a validator from the action schema emitted next to the training set.
+         *
+         * The point of loading rather than hard-coding: the schema comes out of the SAME command that
+         * produced the training rows, so the boundary the model was trained toward and the boundary
+         * enforced here are one artifact. A hand-written allowlist beside a generated dataset is a
+         * drift waiting to happen.
+         */
+        @JvmStatic
+        fun fromSchema(file: File): FunctionCallValidator {
+            if (!file.isFile) throw RejectedCallException("no action schema at ${file.path}")
+            val specs = try {
+                Gson().fromJson(file.readText(Charsets.UTF_8), Array<ActionSpec>::class.java)
+            } catch (e: JsonSyntaxException) {
+                throw RejectedCallException("${file.path} is not a valid action schema: ${e.message}")
+            } ?: throw RejectedCallException("${file.path} parsed to null")
+            return FunctionCallValidator(specs.map { it.withGsonDefaults() })
+        }
+
+    /**
+ * Repair the Kotlin defaults Gson skipped.
+ *
+ * Gson constructs objects through `Unsafe`, bypassing the constructor entirely — so a field
+ * absent from the JSON is left as **null**, even where Kotlin declares it non-null with a
+ * default. The type system then believes a lie, and the failure surfaces far away: the first
+ * read of the field throws `NullPointerException: Parameter specified as non-null is null`
+ * somewhere that never mentions JSON.
+ *
+ * Every schema file in the tree happened to declare `parameters` and `validationRules`, which
+ * is why this went unnoticed until `requiredPermissions` was added and no existing schema had
+ * it. Normalising all four means the next optional field added here is safe by default rather
+ * than by luck.
+ */
+        private fun ActionSpec.withGsonDefaults(): ActionSpec = @Suppress("USELESS_ELVIS") copy(
+            parameters = parameters ?: emptyMap(),
+            validationRules = validationRules ?: emptyMap(),
+            requiredPermissions = requiredPermissions ?: emptyList(),
+)
+    }
+
+    private val byName: Map<String, ActionSpec> = allowlist.associateBy { it.actionName }
+
+    init {
+        // A duplicated action name means two rows disagree about what is permitted and `associateBy`
+        // silently keeps the last. Fail at construction, where the allowlist is visible.
+        require(byName.size == allowlist.size) {
+            val dupes = allowlist.map { it.actionName }.groupBy { it }.filterValues { it.size > 1 }.keys
+            "duplicate action names in the allowlist: $dupes"
+        }
+    }
+
+    /** Action names this validator will accept, for diagnostics and tests. */
+    val allowedActions: Set<String> get() = byName.keys
+
+    /**
+     * @throws RejectedCallException on anything that is not a well-formed, allowlisted, rule-satisfying
+     *   call. The message names the offending entity — an error that says only "invalid" costs an
+     *   export→push→run cycle to diagnose.
+     */
+    fun validate(raw: String): ValidatedCall {
+        val call = try {
+            Gson().fromJson(raw, ToolCall::class.java)
+        } catch (e: JsonSyntaxException) {
+            throw RejectedCallException("model output is not valid JSON: ${e.message}")
+        } ?: throw RejectedCallException("model output is empty")
+        return validate(call)
+    }
+
+    /**
+     * Judge an already-parsed [call].
+     *
+     * Every check below runs on this path, so which [ToolCallParser] produced the call cannot change
+     * what is permitted — only whether a call was recognised at all. That separation is what let
+     * FunctionGemma's non-JSON grammar be supported without touching the boundary.
+     *
+     * @throws RejectedCallException on anything that is not an allowlisted, rule-satisfying call.
+     */
+    fun validate(call: ToolCall): ValidatedCall {
+        // Names the parsed field rather than a JSON key: the same check now runs on calls that never
+        // were JSON, and telling a FunctionGemma user their output lacks an "actionName" field would
+        // point them at a field their model has no way to emit.
+        val name = call.actionName
+            ?: throw RejectedCallException("model output names no action (ToolCall.actionName is null)")
+
+        // The allowlist check comes BEFORE anything is done with the parameters, so an unknown action
+        // cannot reach any other code path.
+        val spec = byName[name]
+            ?: throw RejectedCallException(
+                "action not allowlisted: '$name' (allowed: ${byName.keys.sorted()})"
+            )
+
+        val supplied = call.parameters ?: emptyMap()
+
+        val unknown = supplied.keys - spec.parameters.keys
+        if (unknown.isNotEmpty()) {
+            throw RejectedCallException(
+                "action '$name' does not declare parameter(s) ${unknown.sorted()} " +
+                    "(declared: ${spec.parameters.keys.sorted()})"
+            )
+        }
+
+        // Against `required`, not every declared parameter — an optional one may legitimately be absent.
+        val missing = spec.required - supplied.keys
+        if (missing.isNotEmpty()) {
+            throw RejectedCallException("action '$name' is missing required parameter(s) ${missing.sorted()}")
+        }
+
+        for ((param, rule) in spec.validationRules) {
+            val value = supplied[param] ?: continue
+            if (!matches(rule, value)) {
+                throw RejectedCallException(
+                    "action '$name' parameter '$param' value '$value' does not satisfy rule '$rule'"
+                )
+            }
+        }
+
+        return ValidatedCall(spec = spec, parameters = supplied)
+    }
+
+    private fun matches(rule: String, value: String): Boolean = when {
+        rule == "HH:mm" -> HH_MM.matches(value)
+        rule.length >= 2 && rule.startsWith("/") && rule.endsWith("/") ->
+            // An unparseable regex in the APP's own allowlist is a bug in the app, not untrusted input,
+            // so it surfaces rather than silently rejecting every call.
+            Regex(rule.substring(1, rule.length - 1)).matches(value)
+        // An unrecognised rule must NOT pass by default: a typo in the allowlist would otherwise
+        // silently disable the check it was written to perform.
+        else -> false
+    }
+
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/IntentBinder.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/IntentBinder.kt
new file mode 100644
index 0000000..7b9d1df
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/IntentBinder.kt
@@ -0,0 +1,62 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import android.content.Intent
+
+/**
+ * The intent an accepted call *would* produce, and whether anything is allowed to run it.
+ *
+ * @property willExecute always `false` from [IntentBinder.dryRun]. The flag exists so a caller that
+ *   chooses to execute has to read it and act on it, rather than executing because the object happened
+ *   to contain an [Intent].
+ */
+data class IntendedAction(
+    val intent: Intent,
+    val willExecute: Boolean = false,
+    /**
+ * Permissions the caller must hold before starting [intent] — copied from the app's own
+ * [ActionSpec], never from model output.
+ *
+ * Carried on the result so a caller can check and request them *before* firing. Without it the
+ * only way to discover a missing permission was to call `startActivity` and catch
+ * `SecurityException`, which is an exception used as a question.
+ */
+    val requiredPermissions: List<String> = emptyList(),
+)
+
+/**
+ * Builds an Android [Intent] from a [ValidatedCall] **without executing it**.
+ *
+ * #37's hard requirement is "no arbitrary model output is ever executed". Two things enforce it here,
+ * neither of them a convention:
+ *
+ * 1. **The type.** `dryRun` accepts only [ValidatedCall], which nothing but [FunctionCallValidator]
+ *    can construct. Raw model text cannot reach this function at all.
+ * 2. **The action string.** It is read from `spec.allowedIntent` — the APP's declaration — never from
+ *    the model's output. A model cannot name an intent, only select an action the app already
+ *    permitted, so the reachable set of intents is fixed at allowlist-construction time.
+ *
+ * This class does not hold a `Context` and never calls `startActivity`. Executing an intent is the
+ * caller's decision, made with the caller's own `Context`, after reading [IntendedAction.willExecute]
+ * — deliberately not offered here as a convenience, because the convenience is the risk.
+ */
+object IntentBinder {
+
+    /**
+     * @return the intent this call describes, marked as not-to-be-executed.
+     *
+     * Parameters become string extras under their declared names. They are already checked against
+     * `validationRules`, and the key set is exactly what the [ActionSpec] declares — the validator
+     * rejects both unknown and missing parameters — so no model-chosen key reaches the extras bundle.
+     */
+    fun dryRun(call: ValidatedCall): IntendedAction {
+        val intent = Intent(call.allowedIntent)
+        for ((key, value) in call.parameters) {
+            intent.putExtra(key, value)
+        }
+        return IntendedAction(
+            intent = intent,
+            willExecute = false,
+            requiredPermissions = call.requiredPermissions,
+)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallParser.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallParser.kt
new file mode 100644
index 0000000..db3b5b6
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallParser.kt
@@ -0,0 +1,224 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.martinkorelic.mobiletransformers.packages.ToolCallDialect
+
+/**
+ * Turns raw model text into a candidate [ToolCall], for [FunctionCallValidator] to judge.
+ *
+ * ### Why parsing is separate from validation
+ *
+ * [FunctionCallValidator] parsed JSON itself, which quietly made "the model emits JSON" part of the
+ * safety boundary's contract. It is not — it is a property of one model family. **FunctionGemma, the
+ * model this app's tool-calling story is built around, does not emit JSON at all**: it emits
+ * `<start_function_call>call:name{key:<escape>value<escape>}<end_function_call>`. Handed to a JSON
+ * parser that is a syntax error, so a correct, well-formed call from a correctly fine-tuned model was
+ * reported as "model output is not valid JSON" — and no amount of further fine-tuning could have
+ * changed that.
+ *
+ * Splitting the two makes the format a parameter and leaves the boundary exactly where it was.
+ *
+ * ### This does not weaken the boundary
+ *
+ * A parser only decides **which candidate** to check. Every allowlist and `validationRules` check then
+ * runs on it unchanged, and the intent string still comes from the app's own [ActionSpec] — so no
+ * parser, however wrong, can produce an action the app did not declare. The worst a bad parser can do
+ * is fail to recognise a call.
+ */
+fun interface ToolCallParser {
+
+    /** The call named by [raw], or `null` when it contains none. */
+    fun parse(raw: String): ToolCall?
+
+    companion object {
+        /**
+         * `{"actionName": "...", "parameters": {...}}`, optionally wrapped in prose or a code fence.
+         *
+         * The historical default, and the right one for a model fine-tuned on this repo's
+         * `mobile_actions` corpus, whose completions are exactly this shape.
+         */
+        @JvmField
+        val Json: ToolCallParser = JsonToolCallParser
+
+        /** Google's FunctionGemma tool-call grammar. */
+        @JvmField
+        val FunctionGemma: ToolCallParser = FunctionGemmaToolCallParser
+
+        /**
+         * The parser for a dialect detected from the package itself.
+         *
+         * Prefer this over [forModel]. The dialect comes from
+         * [com.martinkorelic.mobiletransformers.packages.ToolCallSupport], which reads the model's own
+         * chat template rather than pattern-matching a name.
+         */
+        @JvmStatic
+        fun forDialect(dialect: ToolCallDialect): ToolCallParser = when (dialect) {
+            ToolCallDialect.FUNCTION_GEMMA -> FunctionGemma
+            ToolCallDialect.JSON -> Json
+        }
+
+        /**
+         * The parser suited to a package, guessed from any names known for the model.
+         *
+         * A guess, and the weaker of the two signals — [forDialect] reads the artifact. Kept because
+         * a package whose chat template did not survive export has nothing else to go on.
+         *
+         * **Takes every hint, not one.** The single-argument version was called as
+         * `forModel(task.modelType ?: repoId)`, and `modelType` is the *architecture*
+         * (`gemma3_text`) — non-null for every modern package, so the repo id that actually carries
+         * the family name was never reached. FunctionGemma got the JSON parser and every well-formed
+         * call it made was reported as "no tool call found".
+         */
+        @JvmStatic
+        fun forModel(vararg hints: String?): ToolCallParser =
+            if (hints.any { it?.contains("functiongemma", ignoreCase = true) == true }) {
+                FunctionGemma
+            } else {
+                Json
+            }
+    }
+}
+
+/** Extracts a balanced JSON object and reads `actionName` / `parameters` off it. */
+private object JsonToolCallParser : ToolCallParser {
+    override fun parse(raw: String): ToolCall? {
+        val candidate = extractFirstJsonObject(raw)
+        return try {
+            Gson().fromJson(candidate, ToolCall::class.java)?.takeIf { it.actionName != null }
+        } catch (e: JsonSyntaxException) {
+            null
+        }
+    }
+}
+
+/**
+ * Reads FunctionGemma's call grammar.
+ *
+ * ```
+ * <start_function_call>call:set_alarm{time:<escape>07:30<escape>}<end_function_call>
+ * ```
+ *
+ * Three things make this more than a regex:
+ *
+ * - **`<escape>` delimits string values**, and exists precisely so a value may contain the `,` and `}`
+ *   that would otherwise end it. A naive split on `,` mangles `location:<escape>Tokyo, Japan<escape>`
+ *   into two parameters, one of them named ` Japan`.
+ * - **The end token may be missing.** Generation stops at `maxNewTokens`, and a call truncated after
+ *   its closing brace is complete information; refusing it would report a model failure for a
+ *   configuration choice.
+ * - **Bare values are unquoted** (`temperature:15`), so the parser cannot require `<escape>`.
+ *
+ * Values are surfaced as strings because that is what [ActionSpec] declares and what
+ * `validationRules` match against; a numeric literal keeps its text form (`15`), which is what a
+ * `"/[0-9]{1,4}/"` rule expects.
+ */
+private object FunctionGemmaToolCallParser : ToolCallParser {
+
+    private const val CALL_MARKER = "call:"
+    private const val ESCAPE = "<escape>"
+
+    override fun parse(raw: String): ToolCall? {
+        val markerAt = raw.indexOf(CALL_MARKER).takeIf { it >= 0 } ?: return null
+        val braceAt = raw.indexOf('{', markerAt).takeIf { it >= 0 } ?: return null
+
+        val name = raw.substring(markerAt + CALL_MARKER.length, braceAt).trim()
+        if (name.isEmpty()) return null
+
+        val body = balancedBody(raw, braceAt) ?: return null
+        return ToolCall(actionName = name, parameters = parseFields(body))
+    }
+
+    /**
+     * The text between [openBrace] and its matching `}`, ignoring braces inside `<escape>` spans.
+     *
+     * Returns everything to the end of the input when the closing brace never arrives — a truncated
+     * generation, where what was emitted is still the model's answer.
+     */
+    private fun balancedBody(raw: String, openBrace: Int): String? {
+        var depth = 0
+        var i = openBrace
+        var inEscape = false
+        while (i < raw.length) {
+            if (raw.startsWith(ESCAPE, i)) {
+                inEscape = !inEscape
+                i += ESCAPE.length
+                continue
+            }
+            if (!inEscape) {
+                when (raw[i]) {
+                    '{' -> depth++
+                    '}' -> {
+                        depth--
+                        if (depth == 0) return raw.substring(openBrace + 1, i)
+                    }
+                }
+            }
+            i++
+        }
+        return raw.substring(openBrace + 1)
+    }
+
+    /** Split `key:value` pairs on top-level commas, then unwrap each value. */
+    private fun parseFields(body: String): Map<String, String> {
+        val out = LinkedHashMap<String, String>()
+        for (field in splitTopLevel(body)) {
+            val colon = firstTopLevelColon(field)
+            if (colon < 0) continue
+            val key = field.substring(0, colon).trim()
+            if (key.isEmpty()) continue
+            out[key] = unwrap(field.substring(colon + 1).trim())
+        }
+        return out
+    }
+
+    private fun splitTopLevel(body: String): List<String> {
+        val parts = mutableListOf<String>()
+        val current = StringBuilder()
+        var depth = 0
+        var inEscape = false
+        var i = 0
+        while (i < body.length) {
+            if (body.startsWith(ESCAPE, i)) {
+                inEscape = !inEscape
+                current.append(ESCAPE)
+                i += ESCAPE.length
+                continue
+            }
+            val c = body[i]
+            when {
+                inEscape -> current.append(c)
+                c == '{' || c == '[' -> { depth++; current.append(c) }
+                c == '}' || c == ']' -> { depth--; current.append(c) }
+                c == ',' && depth == 0 -> {
+                    parts += current.toString()
+                    current.clear()
+                }
+                else -> current.append(c)
+            }
+            i++
+        }
+        if (current.isNotBlank()) parts += current.toString()
+        return parts
+    }
+
+    /** The `:` that separates key from value — never one inside an escaped value such as `07:30`. */
+    private fun firstTopLevelColon(field: String): Int {
+        var i = 0
+        while (i < field.length) {
+            if (field.startsWith(ESCAPE, i)) return -1 // the value started before any key separator
+            if (field[i] == ':') return i
+            i++
+        }
+        return -1
+    }
+
+    private fun unwrap(value: String): String {
+        val trimmed = value.trim()
+        return if (trimmed.startsWith(ESCAPE) && trimmed.endsWith(ESCAPE) && trimmed.length >= 2 * ESCAPE.length) {
+            trimmed.substring(ESCAPE.length, trimmed.length - ESCAPE.length)
+        } else {
+            trimmed
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallResult.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallResult.kt
new file mode 100644
index 0000000..11650fd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolCallResult.kt
@@ -0,0 +1,101 @@
+package com.martinkorelic.mobiletransformers.agent
+
+/**
+ * The outcome of asking a model for a tool call (#37).
+ *
+ * Sealed, with the intent reachable **only** through [Accepted], so the safety contract is a property
+ * of the type rather than of caller discipline: there is no path from raw model output to an
+ * `IntendedAction` that does not pass through [FunctionCallValidator].
+ *
+ * [Rejected] is a first-class outcome, not an error. Refusing is the *expected* answer for untrusted
+ * output — a UI shows "I can't do that", it does not show a crash — and modelling it as a value keeps
+ * the raw text available for display and debugging instead of losing it inside an exception.
+ */
+sealed interface ToolCallResult {
+
+    /** Exactly what the model emitted, before any extraction or validation. Always available. */
+    val raw: String
+
+    /** The call passed the allowlist and every `validationRules` check. */
+    data class Accepted(
+        override val raw: String,
+        val call: ValidatedCall,
+    ) : ToolCallResult {
+
+        /**
+         * The Android intent this call describes, marked not-to-be-executed.
+         *
+         * A method rather than a field so nothing constructs an `Intent` on a JVM unit-test classpath
+         * that stubs it — the accepted/rejected logic stays testable without Robolectric, and only a
+         * caller that actually wants the intent pays for the framework.
+         */
+        fun dryRun(): IntendedAction = IntentBinder.dryRun(call)
+    }
+
+    /**
+     * The output was not a call this app permits.
+     *
+     * @property reason the validator's message, which names the offending entity (an unknown action,
+     *   an undeclared parameter, a value failing its rule) rather than saying only "invalid".
+     */
+    data class Rejected(
+        override val raw: String,
+        val reason: String,
+    ) : ToolCallResult
+
+    /**
+     * The model answered in prose. It did not attempt a call, so there was nothing to permit or refuse.
+     *
+     * ### Why this is not a [Rejected]
+     *
+     * It used to be, with `reason = "no tool call found in the model's output"`. That conflates two
+     * different events under the word a UI renders as a refusal: "you asked for something I will not
+     * do" and "I answered your question". A user reading the second as the first concludes the model
+     * or the allowlist is broken — which is exactly what happened, and it hid a real defect
+     * underneath (the JSON parser was being handed FunctionGemma's grammar, so *every* call looked
+     * like no call).
+     *
+     * It also makes conversational tool use expressible: with tools declared on every turn, most
+     * turns are legitimately prose, and a chat screen needs to render those as answers rather than as
+     * a wall of refusals.
+     */
+    data class NoCall(
+        override val raw: String,
+    ) : ToolCallResult
+}
+
+/**
+ * Pull the first balanced JSON object out of free-form model text.
+ *
+ * A fine-tuned model still commonly wraps its answer in prose or a code fence. Handing the whole
+ * string to Gson would fail as a *syntax* error and report "not valid JSON" for output that contains a
+ * perfectly good call — a diagnosis that costs a device run to see through.
+ *
+ * **This does not weaken the boundary.** Extraction only chooses which substring to validate; every
+ * allowlist and rule check then runs on it unchanged, so no text this finds can produce an action the
+ * app did not declare. It is brace-counting, not parsing: string literals are respected (so a `}` inside
+ * a value does not end the object early) along with their escapes. Returns the input untouched when
+ * there is no balanced object, letting the validator report the real problem.
+ */
+internal fun extractFirstJsonObject(text: String): String {
+    val start = text.indexOf('{')
+    if (start < 0) return text
+    var depth = 0
+    var inString = false
+    var escaped = false
+    for (i in start until text.length) {
+        val c = text[i]
+        when {
+            escaped -> escaped = false
+            c == '\\' && inString -> escaped = true
+            c == '"' -> inString = !inString
+            inString -> Unit
+            c == '{' -> depth++
+            c == '}' -> {
+                depth--
+                if (depth == 0) return text.substring(start, i + 1)
+            }
+        }
+    }
+    return text
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilder.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilder.kt
new file mode 100644
index 0000000..2e46160
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilder.kt
@@ -0,0 +1,175 @@
+package com.martinkorelic.mobiletransformers.agent
+
+/**
+ * Renders an app's [ActionSpec] allowlist into the tool declaration a model expects to be shown.
+ *
+ * ### Why this had to exist
+ *
+ * `generateToolCall` sent the user's instruction **and nothing else** — no list of available
+ * functions, no output format, no schema. A model was asked to emit a call to one of a set of actions
+ * it had never been told about. That works only for a model fine-tuned on exactly this app's
+ * allowlist, which is why the Tool calls screen's documented answer was "expect Rejected until you
+ * train"; for every off-the-shelf tool-calling model the omission alone guaranteed failure.
+ *
+ * The allowlist is already the single source of truth for what is permitted. Declaring it to the model
+ * from the same object keeps the boundary and the prompt from drifting apart — the same argument that
+ * generates the training corpus from it.
+ */
+object ToolPromptBuilder {
+
+    private const val ESCAPE = "<escape>"
+
+    /** The instruction preamble Google documents for FunctionGemma. */
+    private const val PREAMBLE = "You are a model that can do function calling with the following functions"
+
+    /**
+     * A declaration block in the dialect [parser] reads back.
+     *
+     * Prompt and parser are chosen together on purpose: declaring functions in FunctionGemma's grammar
+     * and then parsing the reply as JSON is the mismatch this whole seam exists to prevent.
+     */
+    @JvmStatic
+    fun declarations(allowlist: List<ActionSpec>, parser: ToolCallParser): String =
+        if (parser === ToolCallParser.FunctionGemma) {
+            functionGemmaDeclarations(allowlist)
+        } else {
+            jsonDeclarations(allowlist)
+        }
+
+    /**
+     * The complete prompt for one tool-calling turn: declarations, the user's message, and the
+     * marker that hands the floor to the model.
+     *
+     * ### Why the turn structure is here
+     *
+     * `generateToolCall` used to send `declarations + "\n" + instruction`, bare. FunctionGemma is
+     * trained on `<start_of_turn>developer … <end_of_turn><start_of_turn>user …
+     * <end_of_turn><start_of_turn>model`, and normally the tokenizer's chat template supplies that
+     * framing — but the exporter writes the template to a sibling `chat_template.jinja` that
+ * `ORTTokenizerNative` did not read, so on device `chatTemplate` was null and **nothing wrapped the
+     * prompt at all**. The model was being handed a naked instruction in a format it has never seen
+     * and asked to produce a grammar it only emits inside a model turn.
+ *
+ * The tokenizer reads that file now — but this builder is still the framing that runs for tool
+ * calls, and deliberately so: FunctionGemma's own template is 13 KB of `namespace`, `dictsort`
+ * and macros that Pebble cannot evaluate, so it fails the load-time probe and leaves
+ * `chatTemplate` null for precisely the family that needs this most.
+     *
+     * Framing it here is the fix that does not depend on a Jinja engine rendering a 400-line
+     * template on a phone. It is dialect-specific for the same reason the parser is: the two are
+     * chosen together, and a declaration in one grammar with a reply parsed in the other is the
+     * mismatch this whole seam exists to prevent.
+     *
+ * **The caller's session must not apply a chat template on top of this.** When
+ * `ORTTokenizerNative.chatTemplate` is non-null the generator wraps each prompt itself, and that
+ * would nest one framing inside another. This used to be merely a documented assumption, safe
+ * because no package carried a template the device read; the tokenizer now reads
+ * `chat_template.jinja`, so it is enforced instead — `generateToolCall` passes
+ * `applyChatTemplate = false` for exactly this reason, pinned by
+ * `ToolCallFramingTest.toolCallPromptsAreNotWrappedTwice`.
+ */
+    /**
+ * Whether [prompt] emits its own turn structure for [parser] — and therefore whether the caller
+ * must suppress the tokenizer's chat template to avoid nesting one framing inside the other.
+ *
+ * Only the FunctionGemma branch frames turns. The JSON branch returns `declarations + instruction`
+ * with no turn markers at all, so a package whose chat template the device can render *should*
+ * still wrap it: suppressing there would strip the framing rather than de-duplicate it.
+ *
+ * Exposed so `generateToolCall` and [prompt] cannot drift apart on the question. They did not
+ * share this predicate at first, and the blanket version silently unwrapped every JSON-dialect
+ * tool call on any package with a working template.
+     */
+    @JvmStatic
+    fun framesOwnTurns(parser: ToolCallParser): Boolean = parser === ToolCallParser.FunctionGemma
+
+    @JvmStatic
+    fun prompt(allowlist: List<ActionSpec>, parser: ToolCallParser, instruction: String): String =
+    if (framesOwnTurns(parser)) {
+            buildString {
+                append("<start_of_turn>developer\n")
+                append(functionGemmaDeclarations(allowlist).trim())
+                append("<end_of_turn>\n")
+                append("<start_of_turn>user\n").append(instruction.trim()).append("<end_of_turn>\n")
+                append("<start_of_turn>model\n")
+            }
+        } else {
+            jsonDeclarations(allowlist) + "\n" + instruction
+        }
+
+    /**
+     * `<start_function_declaration>declaration:name{…}<end_function_declaration>`, one per action.
+     *
+     * String values are wrapped in `<escape>` because the grammar requires it — the delimiter is what
+     * lets a description contain the `,` and `}` that would otherwise end the field.
+     */
+    private fun functionGemmaDeclarations(allowlist: List<ActionSpec>): String = buildString {
+        append(PREAMBLE).append('\n')
+        for (spec in allowlist) {
+            append("<start_function_declaration>declaration:").append(spec.actionName).append('{')
+            append("description:").append(ESCAPE).append(describe(spec)).append(ESCAPE)
+            if (spec.parameters.isNotEmpty()) {
+                append(",parameters:{properties:{")
+                append(
+                    spec.parameters.entries.joinToString(",") { (name, type) ->
+                        val hint = spec.validationRules[name]?.let { " (format: $it)" }.orEmpty()
+                        "$name:{description:$ESCAPE$name$hint$ESCAPE," +
+                            "type:$ESCAPE${type.uppercase()}$ESCAPE}"
+                    },
+                )
+                append("},required:[")
+                append(spec.required.joinToString(",") { "$ESCAPE$it$ESCAPE" })
+                append("],type:${ESCAPE}OBJECT$ESCAPE}")
+            }
+            append("}<end_function_declaration>\n")
+        }
+    }
+
+    /**
+     * A plain-language schema for models with no tool-call grammar of their own, naming the exact
+     * output shape [ToolCallParser.Json] reads.
+     */
+    private fun jsonDeclarations(allowlist: List<ActionSpec>): String = buildString {
+        append(PREAMBLE).append(". Reply with one JSON object and nothing else, shaped ")
+        append("{\"actionName\": <name>, \"parameters\": {<name>: <value>}}.\n")
+        for (spec in allowlist) {
+            append("- ").append(spec.actionName)
+            if (spec.parameters.isEmpty()) {
+                append(" (no parameters)")
+            } else {
+                append(": ")
+                append(
+                    spec.parameters.keys.joinToString(", ") { name ->
+                        val rule = spec.validationRules[name]
+                        val required = if (name in spec.required) "" else ", optional"
+                        if (rule != null) "$name (format $rule$required)" else "$name (string$required)"
+                    },
+                )
+            }
+            append('\n')
+        }
+    }
+
+    /**
+     * What an action does, in words.
+     *
+     * Derived from the intent it is permitted to fire, because that is the only description an
+     * [ActionSpec] carries — the type deliberately holds a *permission*, not documentation. A caller
+     * wanting better wording writes it into the action name, which is what the model selects on.
+     */
+    private fun describe(spec: ActionSpec): String =
+        "Performs '${spec.actionName}' on the device (${spec.allowedIntent})."
+
+    /**
+     * A tool result to feed back for a second turn, in FunctionGemma's response grammar.
+     *
+     * The half of the loop that makes a tool call useful: the model calls, the app answers, the model
+     * says something about the answer. Without it a call is a dead end.
+     */
+    @JvmStatic
+    fun functionResponse(actionName: String, values: Map<String, String>): String = buildString {
+        append("<start_function_response>response:").append(actionName).append('{')
+        append(values.entries.joinToString(",") { (k, v) -> "$k:$ESCAPE$v$ESCAPE" })
+        append("}<end_function_response>")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PeftConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PeftConfig.kt
new file mode 100644
index 0000000..eb72b95
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PeftConfig.kt
@@ -0,0 +1,48 @@
+package com.martinkorelic.mobiletransformers.config
+
+/**
+ * PEFT selection surface (#19), a sealed class over the Python export taxonomy.
+ *
+ * **On-device semantics:** PEFT topology is baked in at export time (`export/training_export.py`
+ * `train_method`, resolved through `config/registry/peft.py`, + `peft/mars/config.py`
+ * `MarsConfig.optimization_level`), so a package's
+ * `train/training_config.json` already fixes the method. `MobileTransformerModel.applyPeft` is therefore
+ * a *selection/validation* step (against what the installed package supports) plus rank/alpha overrides —
+ * never a graph rewrite. The mapping to the Python taxonomy lives in
+ * `internal/config/PeftSupport.kt`.
+ */
+sealed class PeftConfig {
+    abstract val rank: Int
+    abstract val alpha: Int
+    open val targetModules: List<String>? = null
+
+    /** LoRA (`train_method = "lora"`). */
+    data class Lora(
+        override val rank: Int = 16,
+        override val alpha: Int = 32,
+        override val targetModules: List<String>? = null,
+    ) : PeftConfig()
+
+    /** MARS optimization level 0 — fully trainable, no quantization (`train_method = "mars"`). */
+    data class MarsOpt0(
+        override val rank: Int = 8,
+        override val alpha: Int = 8,
+        override val targetModules: List<String>? = null,
+    ) : PeftConfig()
+
+    /** MARS optimization level 1 — partial trainable (frozen + fused down-proj), no quantization. */
+    data class MarsOpt1(
+        override val rank: Int = 8,
+        override val alpha: Int = 8,
+        override val targetModules: List<String>? = null,
+    ) : PeftConfig()
+
+    /** MARS quantized — optimization levels 2/3/4 with 8- or 4-bit weights. */
+    data class MarsQuantized(
+        override val rank: Int = 8,
+        override val alpha: Int = 8,
+        val optimizationLevel: Int = 4, // 2, 3, or 4 (MarsConfig.optimization_level)
+        val quantNBits: Int = 8, // 8 or 4 (MarsConfig.quant_n_bits)
+        override val targetModules: List<String>? = null,
+    ) : PeftConfig()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PublicConfigs.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PublicConfigs.kt
new file mode 100644
index 0000000..d751358
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/config/PublicConfigs.kt
@@ -0,0 +1,136 @@
+package com.martinkorelic.mobiletransformers.config
+
+import com.martinkorelic.mobiletransformers.constants.CoreConfigId
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.constants.IndexingMode
+import com.martinkorelic.mobiletransformers.constants.MemoryConfigId
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.constants.SearchType
+
+/**
+ * Public, HF-flavored typed configs for the SDK facade (#17). These are the single definition site of the
+ * facade config shapes; #19 EXTENDS them (adds `applyPeft`/`pushAdapter`/callbacks) and #24 refines the
+ * sampling surface — neither re-declares them. Internal mapping to the existing `ORT*Config` data classes
+ * lives in `internal/config/ConfigMappers.kt`; defaults here match the `ORT*Config()` defaults 1:1 so the
+ * round-trip is behavior-preserving.
+ */
+
+/** Device/execution-provider selection. Maps 1:1 to the internal `DeviceOptions`. */
+data class DeviceConfig(
+    val executionProvider: ExecutionProvider = ExecutionProvider.CPU,
+    val coreConfigId: CoreConfigId = CoreConfigId.OPT1,
+    val memoryConfigId: MemoryConfigId = MemoryConfigId.HIGH_PERF,
+    val enableProfiling: Boolean = false,
+)
+
+/**
+ * Sampling configuration (#24 locked the HF-aligned names + native mapping). `method` maps to the native
+ * sampler via [com.martinkorelic.mobiletransformers.constants.SamplingMethod.nativeOrdinal]; wire strings
+ * are the shared #6 enum values. Do not introduce a competing sealed `Sampling` class.
+ */
+data class SamplingConfig(
+    val method: SamplingMethod = SamplingMethod.GREEDY,
+    val temperature: Float = 1f,
+    val topK: Int = 10,
+    val topP: Float = 0.9f,
+    val seed: Int = 42,
+)
+
+/** Training configuration. The authoritative field-by-field mapping is `TrainConfig` -> `ORTTrainConfig`. */
+data class TrainConfig(
+    val epochs: Int = 1,
+    val batchSize: Int = 4,
+    val maxSteps: Int? = 10,
+    val saveSteps: Int = 100,
+    val gradientAccumulationSteps: Int = 4,
+    val scheduler: SchedulerType = SchedulerType.LINEAR,
+    val learningRate: Float = 1e-4f,
+    val minLearningRate: Float = 0f,
+    val warmupSteps: Int = 10,
+    val mergeAtEnd: Boolean = true,
+    val saveAtEnd: Boolean = true,
+    val resumeFromState: Boolean = true,
+    /**
+     * Defaults to the **low-memory** profile, unlike [GenerationConfig]'s.
+     *
+     * `MemoryConfigId.HIGH_PERF` enables ORT's memory-pattern planner and CPU arena. On a training
+     * session that means the whole backward activation plan is pre-allocated and the arena keeps its
+     * peak for the life of the run: FunctionGemma-270M measured 2.35 GB RSS + 1.02 GB swap and was
+     * killed by `lmkd` on a 5.5 GB phone, for a LoRA run whose weights are ~1.07 GB.
+     *
+     * Pass `DeviceConfig(memoryConfigId = MemoryConfigId.HIGH_PERF)` explicitly to trade it back.
+     */
+    val device: DeviceConfig = DeviceConfig(memoryConfigId = MemoryConfigId.LOW_MEM),
+)
+
+/** Generation configuration. `maxNewTokens` is the public length field (maps to internal `maxSequenceLength`). */
+data class GenerationConfig(
+    val maxNewTokens: Int = 128,
+    val sampling: SamplingConfig = SamplingConfig(),
+    val systemPrompt: String? = null,
+    val loadMerged: Boolean = false,
+    val device: DeviceConfig = DeviceConfig(),
+    /**
+ * Wrap the prompt in the package's chat template, when it ships one the device can render.
+     *
+ * Leave it true for chat. Set it false when **you have already framed the turns yourself** — the
+ * two framings would otherwise nest. `generateToolCall` does exactly that, because
+ * `ToolPromptBuilder` writes a complete turn structure of its own.
+ */
+    val applyChatTemplate: Boolean = true,
+)
+
+/**
+ * Retrieval configuration (#25/#27). Maps to the internal `ORTRagConfig`. `similarityMetric` is fixed to
+ * COSINE by the ObjectBox backing store and is exposed read-only (not a settable knob). `indexingMode`
+ * `DYNAMIC` is a fail-closed stub in v1 (F7).
+ */
+data class RagConfig(
+    val topK: Int = 10,
+    val searchType: SearchType = SearchType.SEMANTIC,
+    val minScore: Double = 0.0,
+    val indexingMode: IndexingMode = IndexingMode.PRECOMPUTE,
+    // Encoder identity: `null` (the default) means "whatever the installed package declares" — these
+    // are read from `embedding/rag_config.json`, which the exporter writes from the encoder it
+    // actually shipped. Hardcoded defaults here would silently point the retriever at a directory and
+    // a vector width that need not exist in the package, and the mismatch surfaces only at first
+    // ingest on device. Set them to deliberately override the package.
+    val embeddingRepoId: String? = null,
+    val embeddingModelFile: String? = null,
+    val embeddingDimension: Int? = null,
+    val chunkSize: Int = 512,
+    val chunkOverlap: Int = 50,
+    val maxTextLength: Int = 1024,
+    val device: DeviceConfig = DeviceConfig(),
+) {
+    /** Read-only: the on-device vector store uses cosine similarity; not configurable. */
+    val similarityMetric: String get() = "COSINE"
+}
+
+// PEFT selection now lives in config/PeftConfig.kt as a sealed class (#19 wires `applyPeft`).
+
+/** Local dataset description; mapped onto the existing `ORTDataCurator`/`DatasetOptions` loader. */
+data class DatasetConfig(
+    val trainFile: String = "arc_e",
+    /**
+     * Which on-device preprocessor parses [trainFile] (`logiqa`, `boolq`, `mini_personalqa`,
+     * `mini_recommendation`, `cola`, `cola_cls`, `mobile_actions`). `null` = whatever the installed
+     * package declares.
+     *
+     * The task belongs with the data, and the data is supplied by the caller: model packages
+     * deliberately do not ship training sets. Leaving this unset on a package that declares nothing
+     * gives `DataUtil`'s fail-closed `Unsupported task: none`, which is the honest outcome — the
+     * trainer cannot guess how to parse a file it has never seen.
+     */
+    val task: String? = null,
+    val maxSequenceLength: Int = 512,
+    val datasetBatchSize: Int = 64,
+    val maxDatasetLength: Int = 256,
+)
+
+/** Hub credentials for remote pulls (only needed by #21). */
+data class HubConfig(
+    val token: String? = null,
+    val endpoint: String? = null,
+)
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/CoreConfigId.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/CoreConfigId.kt
new file mode 100644
index 0000000..69d3566
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/CoreConfigId.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.CoreConfigId. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class CoreConfigId(val wire: String) {
+    OPT1("opt1"),
+    OPT2("opt2"),
+    OPT3("opt3");
+
+    companion object {
+        fun fromWire(value: String): CoreConfigId =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown CoreConfigId: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/ExecutionProvider.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/ExecutionProvider.kt
new file mode 100644
index 0000000..8d39f1e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/ExecutionProvider.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.ExecutionProvider. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class ExecutionProvider(val wire: String) {
+    CPU("cpu"),
+    XNNPACK("xnnpack"),
+    NNAPI("nnapi");
+
+    companion object {
+        fun fromWire(value: String): ExecutionProvider =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown ExecutionProvider: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/HandoffMode.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/HandoffMode.kt
new file mode 100644
index 0000000..7712de4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/HandoffMode.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.HandoffMode. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class HandoffMode(val wire: String) {
+    EXTERNAL_INITIALIZER("external_initializer"),
+    MODEL_INPUT("model_input"),
+    ADAPTER("adapter");
+
+    companion object {
+        fun fromWire(value: String): HandoffMode =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown HandoffMode: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/IndexingMode.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/IndexingMode.kt
new file mode 100644
index 0000000..56ce587
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/IndexingMode.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.IndexingMode (#27). Wire values are the on-disk/JSON
+ * strings; parity is CI-enforced (python -m mobiletransformers.codegen.enums --check). v1 supports
+ * [PRECOMPUTE] only; [DYNAMIC] is a fail-closed stub (F7).
+ */
+enum class IndexingMode(val wire: String) {
+    PRECOMPUTE("precompute"),
+    DYNAMIC("dynamic");
+
+    companion object {
+        fun fromWire(value: String): IndexingMode =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown IndexingMode: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MemoryConfigId.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MemoryConfigId.kt
new file mode 100644
index 0000000..a79097c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MemoryConfigId.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.MemoryConfigId. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class MemoryConfigId(val wire: String) {
+    LOW_MEM("low_mem"),
+    HIGH_PERF("high_perf");
+
+    companion object {
+        fun fromWire(value: String): MemoryConfigId =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown MemoryConfigId: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MergerVariant.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MergerVariant.kt
new file mode 100644
index 0000000..0397431
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/MergerVariant.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.MergerVariant. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class MergerVariant(val wire: String) {
+    LORA("lora"),
+    LORA_Q("lora_q"),
+    MARS_Q("mars_q");
+
+    companion object {
+        fun fromWire(value: String): MergerVariant =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown MergerVariant: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/PEFTMethod.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/PEFTMethod.kt
new file mode 100644
index 0000000..b454748
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/PEFTMethod.kt
@@ -0,0 +1,18 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.PEFTMethod. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class PEFTMethod(val wire: String) {
+    LORA("lora"),
+    LORA_XS("lora-xs"),
+    MARS("mars"),
+    ALL("all"),
+    NOLORA("nolora");
+
+    companion object {
+        fun fromWire(value: String): PEFTMethod =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown PEFTMethod: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/QuantizationType.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/QuantizationType.kt
new file mode 100644
index 0000000..668620c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/QuantizationType.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.QuantizationType. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class QuantizationType(val wire: String) {
+    QINT8("QInt8"),
+    QUINT8("QUInt8"),
+    INT4("int4");
+
+    companion object {
+        fun fromWire(value: String): QuantizationType =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown QuantizationType: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SamplingMethod.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SamplingMethod.kt
new file mode 100644
index 0000000..2116ac4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SamplingMethod.kt
@@ -0,0 +1,29 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.SamplingMethod. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class SamplingMethod(val wire: String) {
+    GREEDY("greedy"),
+    TOP_K("top_k"),
+    TOP_P("top_p");
+
+    /**
+     * #24: the integer the native sampler expects, matching the C++ `sampling.h` enum
+     * (`SamplingMethod { GREEDY=0, TOP_K=1, TOP_P=2 }`). Declared as a `when` (not an enum constructor
+     * arg) so the enum-parity regex, which scans each entry's wire literal, still sees only the 3 entries.
+     */
+    val nativeOrdinal: Int
+        get() =
+            when (this) {
+                GREEDY -> 0
+                TOP_K -> 1
+                TOP_P -> 2
+            }
+
+    companion object {
+        fun fromWire(value: String): SamplingMethod =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown SamplingMethod: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SchedulerType.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SchedulerType.kt
new file mode 100644
index 0000000..7dbf82d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SchedulerType.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.SchedulerType. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class SchedulerType(val wire: String) {
+    LINEAR("linear"),
+    COSINE("cosine");
+
+    companion object {
+        fun fromWire(value: String): SchedulerType =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown SchedulerType: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SearchType.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SearchType.kt
new file mode 100644
index 0000000..196f62b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/SearchType.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.SearchType. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class SearchType(val wire: String) {
+    SEMANTIC("semantic"),
+    TEXT("text");
+
+    companion object {
+        fun fromWire(value: String): SearchType =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown SearchType: $value")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/TaskType.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/TaskType.kt
new file mode 100644
index 0000000..d59d936
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/constants/TaskType.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.constants
+
+/**
+ * Mirror of mobiletransformers.config.constants.TaskType. Wire values are the on-disk/JSON strings.
+ * Parity with the Python source is CI-enforced (python -m mobiletransformers.codegen.enums --check).
+ */
+enum class TaskType(val wire: String) {
+    TEXT_GENERATION("text-generation"),
+    FEATURE_EXTRACTION("feature-extraction"),
+    SEQUENCE_CLASSIFICATION("text-classification");
+
+    companion object {
+        fun fromWire(value: String): TaskType =
+            entries.firstOrNull { it.wire == value } ?: error("Unknown TaskType: $value")
+    }
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/entity/VectorEntity.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/entity/VectorEntity.kt
similarity index 99%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/entity/VectorEntity.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/entity/VectorEntity.kt
index a78e2d5..6612369 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/entity/VectorEntity.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/entity/VectorEntity.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.ortmobile.entity
+package com.martinkorelic.mobiletransformers.entity
 
 import io.objectbox.annotation.Entity
 import io.objectbox.annotation.HnswIndex
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodec.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodec.kt
new file mode 100644
index 0000000..0e9a8e9
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodec.kt
@@ -0,0 +1,326 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/** A federated record that could not be read, or could not be built. Always names the offender. */
+class FederatedRecordException(message: String) : MobileTransformersException(message)
+
+/** One tensor inside a record: its checkpoint identity, description, and raw little-endian payload. */
+data class AdapterTensor(
+    val name: String,
+    val dtype: String,
+    val shape: List<Long>,
+    val role: String,
+    val payload: ByteArray,
+    val aggregation: String = AdapterTensorCodec.AGGREGATION,
+) {
+    // Data classes compare ByteArray by reference; for a wire object that is a trap, since two records
+    // carrying identical bytes would compare unequal.
+    override fun equals(other: Any?): Boolean =
+        this === other || (other is AdapterTensor &&
+            name == other.name && dtype == other.dtype && shape == other.shape &&
+            role == other.role && aggregation == other.aggregation &&
+            payload.contentEquals(other.payload))
+
+    override fun hashCode(): Int =
+        (((name.hashCode() * 31 + dtype.hashCode()) * 31 + shape.hashCode()) * 31 +
+            role.hashCode()) * 31 + payload.contentHashCode()
+}
+
+/** The decoded form of a `FederatedAdapterRecord`. */
+data class FederatedRecord(
+    val baseModelId: String,
+    val packageRevision: String,
+    val peftMethod: String,
+    val adapterFormatVersion: String,
+    val round: Int,
+    val tensors: List<AdapterTensor>,
+    val metrics: Map<String, Double> = emptyMap(),
+    val schemaVersion: String = AdapterTensorCodec.SCHEMA_VERSION,
+    val minReaderVersion: String = AdapterTensorCodec.MIN_READER_VERSION,
+)
+
+/**
+ * Kotlin **mirror** of `federated/adapter_record.py` — not an independent implementation.
+ *
+ * Wire format: `uint32` LE header length, UTF-8 JSON header, then the raw little-endian payloads
+ * concatenated in codec order. Pinned byte-for-byte by `tests/federated/fixtures/federated_record.golden.bin`,
+ * which both languages are tested against; if these bytes and Python's ever disagree, this file is
+ * wrong by definition.
+ *
+ * ## Why the JSON is hand-built
+ *
+ * Python emits the header with `json.dumps(header, sort_keys=True)`, whose defaults are **`", "` and
+ * `": "` separators — with spaces — and whose key sorting is recursive. Gson produces neither by
+ * default. Serializing through Gson and hoping would produce a record that decodes fine and fails the
+ * golden, so the writer below builds the exact string. (Reading stays permissive: any valid JSON is
+ * accepted, because a peer's whitespace is not our business.)
+ *
+ * ## Vocabulary
+ *
+ * Rank-r ADAPTER FACTORS, not merged weights — the decision recorded in #35. Merged roles stay
+ * **accepted on read** (a peer may hold an older record, and rejecting it as "unknown role" is worse
+ * than accepting it) but nothing here produces them.
+ */
+object AdapterTensorCodec {
+
+    const val SCHEMA_VERSION = "1.0"
+    const val MIN_READER_VERSION = "1.0"
+    const val READER_VERSION = "1.0"
+
+    /** The only aggregation v1 understands. Anything else is rejected on read. */
+    const val AGGREGATION = "weighted_average"
+
+    /** Write vocabulary (rank-r factors) plus the legacy merged roles, which are read-only. */
+    val SUPPORTED_ROLES = setOf(
+        "shared_A", "intermediate", "adapter_A", "adapter_B",
+        "weight", "weight_quantized", "scale", "zero_point",
+    )
+
+    /** Bytes per element. `int4` is deliberately absent — it has no byte-aligned element size. */
+    val DTYPE_SIZES = mapOf(
+        "float16" to 2, "float32" to 4, "float64" to 8,
+        "int8" to 1, "uint8" to 1, "int32" to 4,
+    )
+
+    private const val HEADER_LENGTH_BYTES = 4
+
+    /**
+     * Builds a record from the handoff map's declared factors plus the payload for each.
+     *
+     * @param payloadFor supplies the raw bytes for a tensor by its checkpoint name — on device this
+     *   reads the ORT checkpoint. Matching by NAME rather than by iteration order is deliberate: the
+     *   Python simulation had a defect where tensors were paired by checkpoint iteration order, which
+     *   would write one layer's `lora_A` over another's, and differing shapes caught it only "mostly".
+     */
+    fun build(
+        handoff: WeightHandoffMap,
+        baseModelId: String,
+        packageRevision: String,
+        peftMethod: String,
+        round: Int,
+        metrics: Map<String, Double> = emptyMap(),
+        payloadFor: (WeightHandoffMap.AdapterTensorSpec) -> ByteArray?,
+    ): FederatedRecord {
+        val tensors = handoff.adapterTensorSpecs().map { spec ->
+            val bytes = payloadFor(spec)
+                ?: throw FederatedRecordException(
+                    "no checkpoint data for adapter tensor '${spec.name}' (role ${spec.role}). The " +
+                        "package and the checkpoint disagree about which factors exist."
+                )
+            val expected = expectedByteLength(spec.dtype, spec.shape, spec.name)
+            if (bytes.size != expected) {
+                throw FederatedRecordException(
+                    "adapter tensor '${spec.name}' is ${bytes.size} bytes but its declared " +
+                        "${spec.dtype}${spec.shape} needs $expected"
+                )
+            }
+            AdapterTensor(spec.name, spec.dtype, spec.shape, spec.role, bytes)
+        }
+        return FederatedRecord(
+            baseModelId = baseModelId,
+            packageRevision = packageRevision,
+            peftMethod = peftMethod,
+            // Tracks the handoff map's schemaVersion (F1/F8), NOT this codec's.
+            adapterFormatVersion = handoff.schemaVersion,
+            round = round,
+            tensors = tensors,
+            metrics = metrics,
+        )
+    }
+
+    /** Serializes to the pinned byte layout. */
+    fun serialize(record: FederatedRecord): ByteArray {
+        var offset = 0
+        val entries = record.tensors.map { tensor ->
+            val entry = tensorHeader(tensor, offset)
+            offset += tensor.payload.size
+            entry
+        }
+
+        val header = buildString {
+            append('{')
+            // Top-level keys in the order `sort_keys=True` produces them.
+            appendField("adapterFormatVersion", jsonString(record.adapterFormatVersion))
+            append(", "); appendField("baseModelId", jsonString(record.baseModelId))
+            append(", "); appendField("metrics", jsonObject(record.metrics.toSortedMap().map {
+                jsonString(it.key) to jsonNumber(it.value)
+            }))
+            append(", "); appendField("minReaderVersion", jsonString(record.minReaderVersion))
+            append(", "); appendField("mobiletransformersPackageRevision", jsonString(record.packageRevision))
+            append(", "); appendField("peftMethod", jsonString(record.peftMethod))
+            append(", "); appendField("round", record.round.toString())
+            append(", "); appendField("schemaVersion", jsonString(record.schemaVersion))
+            append(", "); appendField("tensors", entries.joinToString(", ", "[", "]"))
+            append('}')
+        }
+
+        val headerBytes = header.toByteArray(Charsets.UTF_8)
+        val out = ByteBuffer
+            .allocate(HEADER_LENGTH_BYTES + headerBytes.size + record.tensors.sumOf { it.payload.size })
+            .order(ByteOrder.LITTLE_ENDIAN)
+        out.putInt(headerBytes.size)
+        out.put(headerBytes)
+        record.tensors.forEach { out.put(it.payload) }
+        return out.array()
+    }
+
+    /**
+     * Reads a record, failing closed on anything it cannot fully account for.
+     *
+     * Order matters: the version gate runs **before** any offset is trusted, so a record from a newer
+     * SDK is refused rather than parsed with this reader's assumptions about its layout.
+     */
+    fun deserialize(blob: ByteArray): FederatedRecord {
+        if (blob.size < HEADER_LENGTH_BYTES) {
+            throw FederatedRecordException("record is ${blob.size} bytes, too short to hold a header length")
+        }
+        val buffer = ByteBuffer.wrap(blob).order(ByteOrder.LITTLE_ENDIAN)
+        val headerLength = buffer.int
+        if (headerLength < 0 || HEADER_LENGTH_BYTES + headerLength > blob.size) {
+            throw FederatedRecordException(
+                "record declares a $headerLength-byte header but is only ${blob.size} bytes"
+            )
+        }
+        val headerJson = String(blob, HEADER_LENGTH_BYTES, headerLength, Charsets.UTF_8)
+        val header = try {
+            com.google.gson.JsonParser.parseString(headerJson).asJsonObject
+        } catch (e: Exception) {
+            throw FederatedRecordException("record header is not valid JSON: ${e.message}")
+        }
+
+        val schemaVersion = header.stringOr("schemaVersion", SCHEMA_VERSION)
+        val minReader = header.stringOr("minReaderVersion", MIN_READER_VERSION)
+        if (!PackageFormat.checkCompat(schemaVersion, minReader, READER_VERSION)) {
+            throw FederatedRecordException(
+                "federated record schemaVersion $schemaVersion (minReader $minReader) needs a newer " +
+                    "SDK; this reader is $READER_VERSION"
+            )
+        }
+
+        val payloadBase = HEADER_LENGTH_BYTES + headerLength
+        val payloadLength = blob.size - payloadBase
+        val tensors = header.getAsJsonArray("tensors").orEmpty().map { element ->
+            val obj = element.asJsonObject
+            val name = obj.stringOr("name", "")
+            val dtype = obj.stringOr("dtype", "")
+            val role = obj.stringOr("role", "")
+            val aggregation = obj.stringOr("aggregation", "")
+            val shape = obj.getAsJsonArray("shape").orEmpty().map { it.asLong }
+            val byteOffset = obj.get("byteOffset").asInt
+            val byteLength = obj.get("byteLength").asInt
+
+            if (role !in SUPPORTED_ROLES) {
+                throw FederatedRecordException("tensor '$name' has unsupported role '$role'")
+            }
+            if (aggregation != AGGREGATION) {
+                throw FederatedRecordException(
+                    "tensor '$name' has unsupported aggregation '$aggregation' (expected '$AGGREGATION')"
+                )
+            }
+            if (byteOffset < 0 || byteLength < 0 || byteOffset + byteLength > payloadLength) {
+                throw FederatedRecordException(
+                    "tensor '$name' spans [$byteOffset, ${byteOffset + byteLength}) of a " +
+                        "$payloadLength-byte payload"
+                )
+            }
+            val expected = expectedByteLength(dtype, shape, name)
+            if (byteLength != expected) {
+                throw FederatedRecordException(
+                    "tensor '$name' declares $byteLength bytes but $dtype$shape needs $expected"
+                )
+            }
+            AdapterTensor(
+                name = name,
+                dtype = dtype,
+                shape = shape,
+                role = role,
+                payload = blob.copyOfRange(payloadBase + byteOffset, payloadBase + byteOffset + byteLength),
+                aggregation = aggregation,
+            )
+        }
+
+        return FederatedRecord(
+            baseModelId = header.stringOr("baseModelId", ""),
+            packageRevision = header.stringOr("mobiletransformersPackageRevision", ""),
+            peftMethod = header.stringOr("peftMethod", ""),
+            adapterFormatVersion = header.stringOr("adapterFormatVersion", ""),
+            round = header.get("round")?.asInt ?: 0,
+            tensors = tensors,
+            schemaVersion = schemaVersion,
+            minReaderVersion = minReader,
+        )
+    }
+
+    /**
+     * Asserts the record describes the same package this device holds (F1/F8).
+     *
+     * `adapterFormatVersion` tracks the handoff map's `schemaVersion`; a mismatch means the peer's
+     * factors are described by a different schema than ours, which is not a difference to paper over.
+     */
+    fun checkFormat(record: FederatedRecord, handoff: WeightHandoffMap) {
+        if (record.adapterFormatVersion != handoff.schemaVersion) {
+            throw FederatedRecordException(
+                "record adapterFormatVersion ${record.adapterFormatVersion} does not match this " +
+                    "package's handoff-map schemaVersion ${handoff.schemaVersion}"
+            )
+        }
+    }
+
+    private fun expectedByteLength(dtype: String, shape: List<Long>, name: String): Int {
+        val size = DTYPE_SIZES[dtype]
+            ?: throw FederatedRecordException(
+                "tensor '$name' has unsupported dtype '$dtype' (supported: ${DTYPE_SIZES.keys.sorted()})"
+            )
+        return (shape.fold(1L) { acc, d -> acc * d } * size).toInt()
+    }
+
+    private fun tensorHeader(tensor: AdapterTensor, offset: Int): String = buildString {
+        // Nested keys sort too, because Python's sort_keys is recursive.
+        append('{')
+        appendField("aggregation", jsonString(tensor.aggregation))
+        append(", "); appendField("byteLength", tensor.payload.size.toString())
+        append(", "); appendField("byteOffset", offset.toString())
+        append(", "); appendField("dtype", jsonString(tensor.dtype))
+        append(", "); appendField("name", jsonString(tensor.name))
+        append(", "); appendField("role", jsonString(tensor.role))
+        append(", "); appendField("shape", tensor.shape.joinToString(", ", "[", "]"))
+        append('}')
+    }
+
+    private fun StringBuilder.appendField(key: String, rendered: String) {
+        append(jsonString(key)).append(": ").append(rendered)
+    }
+
+    private fun jsonObject(pairs: List<Pair<String, String>>): String =
+        pairs.joinToString(", ", "{", "}") { "${it.first}: ${it.second}" }
+
+    /** Python renders a whole-valued float as `1.0`, and Kotlin's `Double.toString` agrees. */
+    private fun jsonNumber(value: Double): String = value.toString()
+
+    /** Minimal JSON string escaping — the keys and values here are names and versions, not free text. */
+    private fun jsonString(value: String): String = buildString {
+        append('"')
+        for (ch in value) {
+            when (ch) {
+                '"' -> append("\\\"")
+                '\\' -> append("\\\\")
+                '\n' -> append("\\n")
+                '\r' -> append("\\r")
+                '\t' -> append("\\t")
+                else -> append(ch)
+            }
+        }
+        append('"')
+    }
+
+    private fun com.google.gson.JsonObject.stringOr(key: String, fallback: String): String =
+        if (has(key) && !get(key).isJsonNull) get(key).asString else fallback
+
+    private fun com.google.gson.JsonArray?.orEmpty(): List<com.google.gson.JsonElement> =
+        this?.toList() ?: emptyList()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedConfig.kt
new file mode 100644
index 0000000..9bb1642
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedConfig.kt
@@ -0,0 +1,123 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+
+/** A federated round was requested without a precondition that protects the user. */
+class FederatedConsentException(message: String) : MobileTransformersException(message)
+
+/**
+ * What a user actually agreed to. Absence is refusal.
+ *
+ * Modelled as a record with a timestamp and a version rather than a boolean because consent is not a
+ * flag: it is given for a stated purpose at a point in time, and a change to what is shared invalidates
+ * it. [policyVersion] is what makes that enforceable — a round declaring a newer policy than the one
+ * the user saw must stop, not proceed on the old agreement.
+ */
+data class FederatedConsent(
+    val granted: Boolean,
+    val policyVersion: String,
+    val grantedAtEpochMs: Long,
+) {
+    companion object {
+        /** The absence of consent, which is the default state of every device. */
+        val NONE = FederatedConsent(granted = false, policyVersion = "", grantedAtEpochMs = 0L)
+    }
+}
+
+/**
+ * Preconditions for participating in a federated round.
+ *
+ * These are a **precondition to any real-user run, not a follow-up**, so they
+ * are enforced at the point a round starts rather than documented and hoped for. Before this the repo
+ * had exactly one flag (`BuildConfig.ADAPTER_UPLOAD_ENABLED`) and no notion of consent at all — a grep
+ * for "consent" returned nothing.
+ *
+ * @property gatewayUrl must be `https://`. Plain HTTP would put adapter factors — which are derived
+ *   from the user's own data — on the wire in clear.
+ * @property clientAuthToken bearer credential. Without client auth a gateway cannot tell a participant
+ *   from anyone who found the URL, so "only this cohort contributes" would be unenforceable.
+ * @property clipNorm L2 bound applied to an update before it leaves the device. Federated updates leak
+ *   information about the data that produced them; clipping bounds any single example's influence and
+ *   is the precondition for meaningful local DP noise.
+ * @property dpNoiseMultiplier Gaussian noise scale relative to [clipNorm]. `0.0` means **no local DP**,
+ *   which is a legitimate configuration for a closed test cohort but must be a deliberate choice — so
+ *   it is required to be stated rather than defaulted.
+ */
+data class FederatedConfig(
+    val gatewayUrl: String,
+    val clientAuthToken: String,
+    val consent: FederatedConsent = FederatedConsent.NONE,
+    val clipNorm: Double = 1.0,
+    val dpNoiseMultiplier: Double = 0.0,
+    val policyVersion: String = "1.0",
+) {
+    /**
+     * Throws unless every precondition holds. Call before a round does anything observable.
+     *
+     * Fail-closed and specific: each message says which protection is missing, because "federated round
+     * refused" gives an integrator nothing to act on.
+     */
+    fun requireRoundIsPermitted() {
+        if (!FEDERATION_ENABLED) {
+            throw FederatedConsentException(
+                "federated participation is disabled in this build " +
+                    "(BuildConfig.FEDERATION_ENABLED=false); it is off by default and must be " +
+                    "enabled deliberately by the app that ships it"
+            )
+        }
+        if (!consent.granted) {
+            throw FederatedConsentException(
+                "no user consent on record for federated training; a round must not start without it"
+            )
+        }
+        if (consent.policyVersion != policyVersion) {
+            throw FederatedConsentException(
+                "consent was given for policy version '${consent.policyVersion}' but this round " +
+                    "declares '$policyVersion'. What is shared has changed since the user agreed — " +
+                    "ask again rather than proceeding on the old agreement."
+            )
+        }
+        if (!gatewayUrl.startsWith("https://")) {
+            throw FederatedConsentException(
+                "gateway URL '$gatewayUrl' is not https; adapter updates are derived from the user's " +
+                    "own data and must not travel in clear"
+            )
+        }
+        if (clientAuthToken.isBlank()) {
+            throw FederatedConsentException(
+                "no client auth token; an unauthenticated gateway cannot tell a participant from " +
+                    "anyone who found the URL"
+            )
+        }
+        if (clipNorm <= 0.0) {
+            throw FederatedConsentException(
+                "clipNorm must be > 0 (got $clipNorm): an unclipped update lets a single example " +
+                    "dominate what leaves the device"
+            )
+        }
+        if (dpNoiseMultiplier < 0.0) {
+            throw FederatedConsentException("dpNoiseMultiplier must be >= 0 (got $dpNoiseMultiplier)")
+        }
+    }
+
+    /** True when this configuration adds local differential-privacy noise. Recorded, not assumed. */
+    val usesLocalDp: Boolean get() = dpNoiseMultiplier > 0.0
+
+    internal companion object {
+        /**
+         * Off by default, mirroring `BuildConfig.ADAPTER_UPLOAD_ENABLED` (#22).
+         *
+         * Read reflectively so this class stays unit-testable and so the library does not fail to link
+         * in a consumer whose BuildConfig predates the field. Absent means **false** — the safe value.
+         *
+         * `internal` rather than private so the test suites can *read* the build's answer and skip
+         * accordingly (the device round-trip needs it on, the refusal tests need it off). Reading it is
+         * not a way to change it: the value comes from `BuildConfig`, i.e. from the Gradle invocation.
+         */
+        internal val FEDERATION_ENABLED: Boolean = runCatching {
+            Class.forName("com.martinkorelic.mobiletransformers.BuildConfig")
+                .getField("FEDERATION_ENABLED")
+                .getBoolean(null)
+        }.getOrDefault(false)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedRound.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedRound.kt
new file mode 100644
index 0000000..d248918
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedRound.kt
@@ -0,0 +1,151 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import kotlin.math.min
+import kotlin.math.sqrt
+
+/**
+ * Reads and writes ORT checkpoint parameters by name. Implemented over JNI on device; substitutable in
+ * tests, which is the point — the round's logic (clipping, name matching, consent) is then host-testable
+ * without a training session.
+ */
+interface CheckpointTensorStore {
+    /** Raw little-endian bytes for [name], or `null` when the checkpoint has no such parameter. */
+    fun read(name: String): ByteArray?
+
+    /** Writes [data] back to [name]. Returns false on any mismatch; never truncates or pads. */
+    fun write(name: String, data: ByteArray): Boolean
+}
+
+/**
+ * The two directions a federated round moves adapter factors in.
+ *
+ * An interface for the same reason [CheckpointTensorStore] is one: the *ordering* of a round
+ * (import → train → export) is a correctness property that must be pinned on the host, and the real
+ * implementation refuses to run at all in a build where `FEDERATION_ENABLED` is false — which is every
+ * unit-test build, deliberately. Substituting this seam tests the sequence without weakening the gate.
+ */
+interface AdapterExchange {
+    /** Builds the record this device would upload. */
+    fun exportUpdate(
+        baseModelId: String,
+        packageRevision: String,
+        peftMethod: String,
+        round: Int,
+        metrics: Map<String, Double> = emptyMap(),
+    ): ByteArray
+
+    /** Writes an aggregated record into the local checkpoint; returns the number of tensors written. */
+    fun importAggregate(blob: ByteArray): Int
+}
+
+/**
+ * One federated round's device-side half: **export** the local adapter factors, and **import** the
+ * aggregated ones.
+ *
+ * Deliberately does not perform the training itself or the HTTP — those are
+ * `repository/TrainingRepository.performTraining` and the gateway client respectively. What lives here
+ * is everything that decides *what leaves the device* and *what is allowed back in*, because that is
+ * the part where a mistake is a privacy incident rather than a bug.
+ *
+ * Ordering, naming and dtype all come from `weight_handoff_map.json` via
+ * [WeightHandoffMap.adapterTensorSpecs]; nothing here re-derives a tensor identity.
+ */
+class FederatedRound(
+    private val config: FederatedConfig,
+    private val handoff: WeightHandoffMap,
+    private val store: CheckpointTensorStore,
+) : AdapterExchange {
+
+    /**
+     * Builds the record this device would send, applying the configured clipping first.
+     *
+     * @throws FederatedConsentException before reading anything at all when a precondition fails. The
+     *   gate runs first on purpose: a round that reads the user's adapters and only then discovers it
+     *   lacks consent has already done the thing consent governs.
+     */
+    override fun exportUpdate(
+        baseModelId: String,
+        packageRevision: String,
+        peftMethod: String,
+        round: Int,
+        metrics: Map<String, Double>,
+    ): ByteArray {
+        config.requireRoundIsPermitted()
+
+        val record = AdapterTensorCodec.build(
+            handoff = handoff,
+            baseModelId = baseModelId,
+            packageRevision = packageRevision,
+            peftMethod = peftMethod,
+            round = round,
+            metrics = metrics,
+        ) { spec -> store.read(spec.name)?.let { clipToNorm(it, config.clipNorm) } }
+
+        return AdapterTensorCodec.serialize(record)
+    }
+
+    /**
+     * Writes an aggregated record back into the local checkpoint, **by name**.
+     *
+     * @return the number of tensors written.
+     * @throws FederatedRecordException if the record describes a different schema than this package,
+     *   or if any tensor cannot be written. Partial application is the dangerous outcome — half the
+     *   layers updated and half not is a model that is neither the local one nor the global one — so a
+     *   failure is reported rather than swallowed per tensor.
+     */
+    override fun importAggregate(blob: ByteArray): Int {
+        config.requireRoundIsPermitted()
+
+        val record = AdapterTensorCodec.deserialize(blob)
+        AdapterTensorCodec.checkFormat(record, handoff)
+
+        // Only names this package actually declares may be written. A record naming a tensor we do not
+        // have is a mismatch, not something to apply optimistically.
+        val declared = handoff.adapterTensorSpecs().associateBy { it.name }
+        var written = 0
+        for (tensor in record.tensors) {
+            val spec = declared[tensor.name]
+                ?: throw FederatedRecordException(
+                    "aggregated record carries '${tensor.name}', which this package does not declare"
+                )
+            if (tensor.shape != spec.shape) {
+                throw FederatedRecordException(
+                    "aggregated '${tensor.name}' has shape ${tensor.shape} but this package declares " +
+                        "${spec.shape}"
+                )
+            }
+            if (!store.write(tensor.name, tensor.payload)) {
+                throw FederatedRecordException(
+                    "failed to write aggregated tensor '${tensor.name}' into the local checkpoint"
+                )
+            }
+            written++
+        }
+        return written
+    }
+
+    /**
+     * Scales a float32 tensor so its L2 norm is at most [maxNorm], leaving it untouched when already
+     * within bound.
+     *
+     * Clipping is what bounds any single example's influence on what leaves the device, and it is the
+     * precondition for local DP noise to mean anything: without a bound on the update, there is no
+     * sensitivity to calibrate noise against.
+     */
+    internal fun clipToNorm(bytes: ByteArray, maxNorm: Double): ByteArray {
+        val buffer = java.nio.ByteBuffer.wrap(bytes).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+        val count = bytes.size / 4
+        val values = FloatArray(count) { buffer.getFloat(it * 4) }
+
+        var sumSquares = 0.0
+        for (v in values) sumSquares += v.toDouble() * v.toDouble()
+        val norm = sqrt(sumSquares)
+        if (norm <= maxNorm || norm == 0.0) return bytes
+
+        val scale = min(1.0, maxNorm / norm)
+        val out = java.nio.ByteBuffer.allocate(bytes.size).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+        for (v in values) out.putFloat((v * scale).toFloat())
+        return out.array()
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepository.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepository.kt
new file mode 100644
index 0000000..1922609
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepository.kt
@@ -0,0 +1,130 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import android.util.Log
+import com.martinkorelic.mobiletransformers.ORTTrainerNative
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+
+/**
+ * The bounded local training one federated round performs between import and export.
+ *
+ * A seam rather than a direct call into `TrainingRepository` for two reasons: the round must be
+ * host-testable without a native session, and *what* "bounded" means (steps, dataset, scheduler
+ * constraints) belongs to #34's scheduler and the caller's `ORTTrainingConfig`, not to the federated
+ * layer. This layer only guarantees that training happens **between** the import and the export.
+ */
+fun interface LocalRoundTraining {
+    /** Runs one round's worth of local training. [round] is passed for logging/telemetry only. */
+    suspend fun trainOneRound(round: Int)
+}
+
+/** What one round did, including the number that decides whether federation is affordable at all. */
+class FederatedRoundResult(
+    val round: Int,
+    /** Tensors written into the local checkpoint from the global record; 0 for the first round. */
+    val importedTensors: Int,
+    /** The serialized record this device would upload. */
+    val update: ByteArray,
+    /** True when local training ran between the import and the export. */
+    val trainedLocally: Boolean,
+) {
+    /** On-device communication size for this round's adapter payload — the #36 DoD measurement. */
+    val payloadBytes: Int get() = update.size
+
+    fun describe(): String =
+        "round $round: imported $importedTensors tensor(s), trained=$trainedLocally, " +
+            "upload payload $payloadBytes B"
+}
+
+/**
+ * One federated round on the device: **import** the global adapter, train locally under the caller's
+ * bounds, **export** the updated adapter (#36 step 2).
+ *
+ * ```
+ * global record ──import──▶ local checkpoint ──train──▶ local checkpoint ──export──▶ update record
+ * ```
+ *
+ * Everything that decides what leaves the device — consent, TLS, auth, clipping, tensor identity —
+ * lives in [FederatedRound] and [FederatedConfig]; this class owns only the **ordering**, which is
+ * itself a correctness property: exporting before training would upload the global adapter back
+ * unchanged, and a round that trains without importing first diverges from the cohort silently. Both
+ * are the "two halves each verified alone" failure this project keeps paying for, so the order is
+ * asserted here rather than left to the caller's call sequence.
+ *
+ * The transport is deliberately absent. This returns bytes and accepts bytes; whether they travel over
+ * HTTPS to `federated serve`, or over `adb` in a device test, is the caller's problem — which is what
+ * makes the round runnable end to end without a server.
+ */
+class FederatedTrainingRepository(
+    private val round: AdapterExchange,
+    private val localTraining: LocalRoundTraining,
+    private val baseModelId: String,
+    private val packageRevision: String = "",
+    private val peftMethod: String = "lora",
+) {
+
+    /**
+     * Runs one round.
+     *
+     * @param globalRecord the aggregate from the previous round, or `null` for the very first round
+     *   (there is nothing to import yet — a device must be able to join a cohort that has not published
+     *   an aggregate, and refusing would make round 0 impossible).
+     * @param roundNumber stamped on the exported record so the gateway can reject a stale submission.
+     * @param metrics local metrics to report alongside the update. Loss and example counts only —
+     *   never anything derived from the raw examples themselves.
+     */
+    suspend fun runRound(
+        globalRecord: ByteArray?,
+        roundNumber: Int,
+        metrics: Map<String, Double> = emptyMap(),
+        train: Boolean = true,
+    ): FederatedRoundResult {
+        val imported = if (globalRecord == null) {
+            Log.i(LOG_TAG, "round $roundNumber: no global record, starting from the local adapter")
+            0
+        } else {
+            val count = round.importAggregate(globalRecord)
+            Log.i(LOG_TAG, "round $roundNumber: imported $count tensor(s) from the global record")
+            count
+        }
+
+        if (train) localTraining.trainOneRound(roundNumber)
+
+        val update = round.exportUpdate(
+            baseModelId = baseModelId,
+            packageRevision = packageRevision,
+            peftMethod = peftMethod,
+            round = roundNumber,
+            metrics = metrics,
+        )
+
+        val result = FederatedRoundResult(roundNumber, imported, update, train)
+        Log.i(LOG_TAG, result.describe())
+        return result
+    }
+
+    companion object {
+        private const val LOG_TAG = "FederatedTraining"
+
+        /**
+         * Builds a repository over a live training session.
+         *
+         * The only place [NativeCheckpointTensorStore] is constructed outside a test — callers get the
+         * JNI binding by asking for a round, not by reaching for the native methods themselves.
+         */
+        internal fun forSession(
+            config: FederatedConfig,
+            handoff: WeightHandoffMap,
+            trainer: ORTTrainerNative,
+            localTraining: LocalRoundTraining,
+            baseModelId: String,
+            packageRevision: String = "",
+            peftMethod: String = "lora",
+        ): FederatedTrainingRepository = FederatedTrainingRepository(
+            round = FederatedRound(config, handoff, NativeCheckpointTensorStore(trainer)),
+            localTraining = localTraining,
+            baseModelId = baseModelId,
+            packageRevision = packageRevision,
+            peftMethod = peftMethod,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/NativeCheckpointTensorStore.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/NativeCheckpointTensorStore.kt
new file mode 100644
index 0000000..851e235
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/federated/NativeCheckpointTensorStore.kt
@@ -0,0 +1,39 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.ORTTrainerNative
+
+/**
+ * The one place [CheckpointTensorStore] is bound to a live ORT training session (#36).
+ *
+ * `nativeExportCheckpointTensor` / `nativeImportCheckpointTensor` move **bytes only** — the record
+ * format is owned by [AdapterTensorCodec], which is pinned against the cross-language golden. This
+ * class is the whole of the glue, deliberately: everything that decides *what* is read or written
+ * (order, names, dtypes, clipping, consent) lives in [FederatedRound] and the handoff map, so a second
+ * opinion about tensor identity cannot grow here.
+ *
+ * A dead session is an error rather than an empty read. Returning `null` for every name would let a
+ * round produce the codec's "the package and the checkpoint disagree about which factors exist"
+ * message, which points at the package — the wrong place to look when the truth is that no session was
+ * ever created.
+ */
+internal class NativeCheckpointTensorStore(
+    private val trainer: ORTTrainerNative,
+) : CheckpointTensorStore {
+
+    override fun read(name: String): ByteArray? =
+        trainer.nativeExportCheckpointTensor(requireSession(), name)
+
+    override fun write(name: String, data: ByteArray): Boolean =
+        trainer.nativeImportCheckpointTensor(requireSession(), name, data)
+
+    private fun requireSession(): Long {
+        val session = trainer.trainingSessionHandle()
+        if (session == 0L) {
+            throw FederatedRecordException(
+                "no live ORT training session; a federated round reads and writes the checkpoint of " +
+                    "an open session, so prepare training before starting the round"
+            )
+        }
+        return session
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/AdapterUploader.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/AdapterUploader.kt
new file mode 100644
index 0000000..e1153d8
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/AdapterUploader.kt
@@ -0,0 +1,138 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import com.google.gson.Gson
+import com.martinkorelic.mobiletransformers.BuildConfig
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+/**
+ * #22: on-device adapter push-back — the Kotlin mirror of the Python `adapter/{export,convert,model_card}`
+ * flow. **Disabled by default** ([BuildConfig.ADAPTER_UPLOAD_ENABLED] = false, privacy-gated); the product
+ * path is device → desktop sync → Python `push-adapter`. The metadata read, Mode-1/Mode-2 gate, and card
+ * (with the mandatory bold privacy warning + base-model license) are pure and JVM-tested; the actual
+ * authenticated Hub upload + ORT `CheckpointState` factor read are the device legs.
+ */
+
+/** Adapter metadata recovered from the on-device cache (`train/training_config.json` + handoff map). */
+data class AdapterMetadata(
+    val peftMethod: String,
+    val rank: Int?,
+    val alpha: Int?,
+    val peftTarget: List<String>,
+    val trainableParameterCount: Int?,
+    val tensorNames: List<String>,
+)
+
+/** Emitted layout mode (mirrors Python `convert.to_peft_layout`). */
+enum class AdapterMode { PEFT, NATIVE }
+
+private data class TrainingConfigJson(
+    val peftMethod: String? = null,
+    val peft_method: String? = null,
+    val rank: Int? = null,
+    val alpha: Int? = null,
+    val peft_target: List<String>? = null,
+    val trainable_parameter_count: Int? = null,
+)
+
+object AdapterPackageBuilder {
+    private val gson = Gson()
+
+    /** Read `train/training_config.json` + `train/weight_handoff_map.json` from the installed package. */
+    fun build(cacheDir: File, repoId: String): AdapterMetadata {
+        val sanitized = PackageFormat.sanitizeRepoId(repoId)
+        val trainDir = PackagePaths.forCache(cacheDir, sanitized).train
+        val cfgFile = File(trainDir, "training_config.json")
+        if (!cfgFile.isFile) {
+            throw MissingArtifactException("adapter export: $cfgFile not found (train the model first)")
+        }
+        val cfg = gson.fromJson(cfgFile.readText(), TrainingConfigJson::class.java) ?: TrainingConfigJson()
+        val handoffFile = File(trainDir, WeightHandoffMap.FILENAME)
+        val tensorNames =
+            if (handoffFile.isFile) {
+                WeightHandoffMap.load(handoffFile).entries.flatMap { it.inferenceInitializerNames.values }
+            } else {
+                emptyList()
+            }
+        return AdapterMetadata(
+            peftMethod = (cfg.peftMethod ?: cfg.peft_method ?: "lora").lowercase(),
+            rank = cfg.rank,
+            alpha = cfg.alpha,
+            peftTarget = cfg.peft_target ?: emptyList(),
+            trainableParameterCount = cfg.trainable_parameter_count,
+            tensorNames = tensorNames,
+        )
+    }
+}
+
+object AdapterModeGate {
+    /**
+     * Mirror of `convert.to_peft_layout`: a drop-in PEFT layout (Mode 1) is emitted only for a clean
+     * LoRA adapter; MARS and factor-less LoRA fall to the MobileTransformers-native layout (Mode 2).
+     */
+    fun decide(meta: AdapterMetadata): AdapterMode =
+        if (meta.peftMethod == "lora" && meta.rank != null && meta.alpha != null) AdapterMode.PEFT else AdapterMode.NATIVE
+}
+
+object AdapterCard {
+    const val PRIVACY_WARNING =
+        "**⚠️ Privacy warning:** this adapter was fine-tuned on-device and its weights may encode private " +
+            "information from your training data. Review before sharing."
+
+    fun render(meta: AdapterMetadata, mode: AdapterMode, baseModelLicense: String = "see upstream"): String =
+        buildString {
+            appendLine(PRIVACY_WARNING)
+            appendLine()
+            appendLine("## Adapter")
+            appendLine("- PEFT method: ${meta.peftMethod}")
+            appendLine("- Mode: $mode")
+            meta.rank?.let { appendLine("- rank: $it") }
+            meta.alpha?.let { appendLine("- alpha: $it") }
+            if (meta.peftTarget.isNotEmpty()) appendLine("- target modules: ${meta.peftTarget.joinToString(", ")}")
+            appendLine()
+            appendLine("## Licenses")
+            appendLine("- Base model weights: $baseModelLicense")
+            appendLine()
+            appendLine("## Re-apply")
+            appendLine("Load onto the same base model this adapter was trained from.")
+        }
+
+    /** Fail closed if a mandatory disclosure is missing (mirror of Python `assert_required_sections`). */
+    fun assertRequiredSections(card: String) {
+        val missing = buildList {
+            if (!card.contains("Privacy warning")) add("privacy warning")
+            if (!card.contains("## Licenses")) add("licenses section")
+        }
+        if (missing.isNotEmpty()) {
+            throw MissingArtifactException("adapter card missing required section(s): ${missing.joinToString(", ")}")
+        }
+    }
+}
+
+/** Raised when device upload is attempted while disabled by default (the privacy gate). */
+class AdapterUploadDisabledException :
+    MobileTransformersException(
+        "On-device adapter upload is disabled (BuildConfig.ADAPTER_UPLOAD_ENABLED=false). Sync the " +
+            "package to a desktop and run `mobiletransformers push-adapter` instead.",
+    )
+
+object AdapterUploader {
+    /** True only when the build flag is set (default false). Kept as a function for test overridability. */
+    fun uploadEnabled(): Boolean = BuildConfig.ADAPTER_UPLOAD_ENABLED
+
+    /**
+     * Prepare (always) and — only when [uploadEnabled] — upload the adapter. Preparation is pure
+     * (metadata → gate → card + fail-closed section check); the authenticated Hub POST is the device leg.
+     */
+    fun prepareCard(cacheDir: File, repoId: String, baseModelLicense: String = "see upstream"): String {
+        val meta = AdapterPackageBuilder.build(cacheDir, repoId)
+        val mode = AdapterModeGate.decide(meta)
+        val card = AdapterCard.render(meta, mode, baseModelLicense)
+        AdapterCard.assertRequiredSections(card)
+        return card
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadPlanner.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadPlanner.kt
new file mode 100644
index 0000000..f54d0ea
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadPlanner.kt
@@ -0,0 +1,51 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+
+/**
+ * #21: expands `manifest.downloadPlan[variant][group]` patterns into the concrete repo-relative file list
+ * to fetch (the Kotlin mirror of the Python `_allow_patterns` in `hub/pull.py`). Pure (JVM-testable):
+ * `**`/`*` suffixes are prefix-matched against `manifest.fileSizes` keys (the actual files); literals are
+ * kept iff they exist. Groups fetched: always core + checksums + inference; + train/rag when requested;
+ * + genai when the GenAI engine is requested.
+ */
+object DownloadPlanner {
+
+    fun groupsFor(features: Set<String>, genai: Boolean): Set<String> {
+        val groups = linkedSetOf("core", "checksums", "inference")
+        if ("train" in features) groups += "train"
+        if ("rag" in features) groups += "rag"
+        if (genai) groups += "genai"
+        return groups
+    }
+
+    fun planFiles(
+        manifest: MobileTransformersManifest,
+        variantId: String,
+        features: Set<String>,
+        genai: Boolean,
+    ): List<String> {
+        val plan = manifest.downloadPlan[variantId] ?: emptyMap()
+        val allFiles = manifest.fileSizes.keys
+        val out = linkedSetOf<String>()
+        for (group in groupsFor(features, genai)) {
+            for (pattern in plan[group].orEmpty()) {
+                out += expand(pattern, allFiles)
+            }
+        }
+        return out.toList().sorted()
+    }
+
+    private fun expand(pattern: String, allFiles: Set<String>): List<String> =
+        when {
+            pattern.endsWith("/**") -> {
+                val prefix = pattern.removeSuffix("**")
+                allFiles.filter { it.startsWith(prefix) }
+            }
+            pattern.endsWith("*") -> {
+                val prefix = pattern.removeSuffix("*")
+                allFiles.filter { it.startsWith(prefix) }
+            }
+            else -> if (pattern in allFiles) listOf(pattern) else emptyList()
+        }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadProgress.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadProgress.kt
new file mode 100644
index 0000000..599a19b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/DownloadProgress.kt
@@ -0,0 +1,91 @@
+package com.martinkorelic.mobiletransformers.hub
+
+/**
+ * Progress of a Hub package pull (#21), as the public facade reports it.
+ *
+ * ### Why this exists
+ *
+ * `HubDownloader.downloadAndInstall` has always taken an `onProgress` callback, but
+ * `MobileTransformers.fromPretrained` called it with the default no-op and dropped every update on
+ * the floor. So the one thing a first-run user waits on — a multi-hundred-megabyte download — was
+ * invisible to anyone using the public API, and a Models screen had no way to show it without
+ * reaching around the facade into `hub.HubDownloader` directly. Found while building the showcase
+ * app's Models/Hub screen; recorded against #17/#19.
+ *
+ * ### Why it reports BYTES, not just files
+ *
+ * The first version counted completed files, and `PackageDownloader` only called it after a whole
+ * file finished. A real package's weights are one or two files of 1–4 GB, so the honest rendering of
+ * that signal is "0 / 6 files" — unchanged, for ten minutes, with no bytes, no rate and no estimate.
+ * There is no way to tell that from a stalled connection, which is exactly the report this fixes:
+ * a pull that was working was indistinguishable from one that had hung.
+ *
+ * Byte totals are free: the manifest already declares `fileSizes` for every file in the plan, so the
+ * denominator is known before the first GET rather than discovered at the end.
+ *
+ * The raw callback's `(Int, Int, String)` triple is wrapped in a named type deliberately: at a public
+ * boundary `done`/`total` are trivially transposable, and a lambda signature does not say which is
+ * which.
+ */
+data class DownloadProgress(
+    /** Which stage of the pull this update describes. */
+    val phase: Phase = Phase.Downloading,
+    /** Files fully downloaded and verified. */
+    val filesDone: Int = 0,
+    /** Files in the resolved download plan. Zero until the plan is known. */
+    val filesTotal: Int = 0,
+    /** Repo-relative path of the file currently in flight, or the one that just completed. */
+    val path: String = "",
+    /** Bytes written so far across the whole plan, including bytes resumed from a `.partial`. */
+    val bytesDone: Long = 0L,
+    /** Bytes the plan declares in total, or `null` when the manifest does not size its files. */
+    val bytesTotal: Long? = null,
+    /** Recent throughput, exponentially smoothed. Zero until two samples exist. */
+    val bytesPerSecond: Double = 0.0,
+) {
+    /** The stages a pull moves through, so a UI can say what it is waiting on rather than guessing. */
+    enum class Phase {
+        /** Fetching the manifest and choosing a variant. No large transfer has started. */
+        Resolving,
+        Downloading,
+        /** Hashing a completed file against the manifest's sha256. */
+        Verifying,
+        /** Publishing the staged tree into the cache. */
+        Installing,
+    }
+
+    /**
+     * Completed fraction in `0.0..1.0`, or `null` when nothing is known yet.
+     *
+     * Prefers bytes over files: with a two-file plan whose second file is 99% of the package, the
+     * file count jumps 0 → 50% → 100% and spends almost the whole download at 50%.
+     */
+    val fraction: Float?
+        get() {
+            val total = bytesTotal
+            return when {
+                total != null && total > 0 -> (bytesDone.toDouble() / total).coerceIn(0.0, 1.0).toFloat()
+                filesTotal > 0 -> (filesDone.toFloat() / filesTotal).coerceIn(0f, 1f)
+                else -> null
+            }
+        }
+
+    /** Seconds remaining at the current rate, or `null` without both a total and a measured rate. */
+    val etaSeconds: Long?
+        get() {
+            val total = bytesTotal ?: return null
+            if (bytesPerSecond <= 0.0) return null
+            val remaining = (total - bytesDone).coerceAtLeast(0L)
+            return (remaining / bytesPerSecond).toLong()
+        }
+}
+
+/**
+ * Receives [DownloadProgress] updates during `MobileTransformers.fromPretrained`.
+ *
+ * A `fun interface` rather than a typealias so Java callers get a real SAM type, matching how the
+ * rest of the facade's callbacks (`GenerateCallback`, `TrainCallback`) are shaped.
+ */
+fun interface DownloadProgressListener {
+    fun onProgress(progress: DownloadProgress)
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubDownloader.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubDownloader.kt
new file mode 100644
index 0000000..efb3588
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubDownloader.kt
@@ -0,0 +1,216 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+import com.martinkorelic.mobiletransformers.packages.ModelPackageInstaller
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.VariantSelector
+import java.io.File
+import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+
+/**
+ * #21: manifest-first Hub pull → verify → atomic install, mirroring the Python `hub/pull.py`
+ * (`pull_package` + `install_package`). Downloads the manifest first, plans the file list
+ * ([DownloadPlanner]), streams + sha256-verifies each file ([PackageDownloader]), then materializes via
+ * the existing [ModelPackageInstaller] (atomic rename). Reuses the `packages/` verify/select/install half;
+ * this is only the network front-end. `client` is injectable for tests.
+ */
+object HubDownloader {
+
+    /**
+     * How often byte progress reaches the caller.
+     *
+     * The write loop emits per 64 KB chunk — thousands of times a second on a fast link. Forwarding
+     * all of it would drive a Compose recomposition per chunk for no gain, so updates are coalesced
+     * to this interval. Small enough that the rate readout stays live, large enough to be free.
+     */
+    private const val PROGRESS_INTERVAL_MS = 250L
+
+    suspend fun downloadAndInstall(
+        cacheDir: File,
+        repoId: String,
+        revision: String = "main",
+        variant: String? = null,
+        features: Set<String> = setOf("inference"),
+        genai: Boolean = false,
+        // #21: device capabilities drive variant selection. Defaults keep this callable from a plain
+        // JVM test; production callers pass Build.SUPPORTED_ABIS + ActivityManager memory.
+        abis: List<String> = emptyList(),
+        totalMemMb: Int? = null,
+        quantization: String? = null,
+        endpoint: String = HubResolver.DEFAULT_ENDPOINT,
+        token: String? = null,
+        client: OkHttpClient = PackageDownloader.defaultClient(),
+        onProgress: (DownloadProgress) -> Unit = { },
+    ): ModelPackageInstaller.Installed =
+        withContext(Dispatchers.IO) {
+            val sanitized = PackageFormat.sanitizeRepoId(repoId)
+            val staging = File(cacheDir, ".download/$sanitized").apply {
+                deleteRecursively()
+                mkdirs()
+            }
+            val headers = HubResolver.authHeaders(token)
+            val urlFor = { path: String -> HubResolver.fileUrl(endpoint, repoId, revision, path) }
+
+            // Resolving is a real, visible wait on a slow link: the manifest GET plus variant
+            // selection happens before a single weight byte moves, and reporting nothing here is what
+            // made a pull look dead from the moment it started.
+            onProgress(DownloadProgress(phase = DownloadProgress.Phase.Resolving))
+
+            // Manifest first (no large GET precedes it) — no checksum yet (it names the others' checksums).
+            PackageDownloader.download(
+                client = client,
+                files = listOf(PackageFormat.MANIFEST_FILENAME),
+                urlFor = urlFor,
+                headers = headers,
+                expectedSha = emptyMap(),
+                destRoot = staging,
+            )
+            val manifest = MobileTransformersManifest.load(File(staging, PackageFormat.MANIFEST_FILENAME))
+            // #21: an explicit `variant` still wins, but otherwise select on DEVICE CAPABILITY rather
+            // than blindly taking `manifest.defaultVariant` — that ignored abi, memory, feature and
+            // engine constraints, so an incompatible variant downloaded happily and failed at load.
+            // VariantSelector throws NoCompatibleVariantException when nothing matches.
+            val variantId = variant ?: if (abis.isEmpty()) {
+                manifest.defaultVariant
+            } else {
+                VariantSelector.select(
+                    manifest = manifest,
+                    abis = abis,
+                    quantization = quantization,
+                    totalMemMb = totalMemMb,
+                    requestedFeatures = features.toList(),
+                    requestedEngine = if (genai) "genai" else "native",
+                ).id
+            }
+
+            val files = DownloadPlanner.planFiles(manifest, variantId, features, genai)
+
+            // The denominator, known BEFORE the first GET: the manifest sizes every file it lists, so
+            // there is no reason to discover the package's size by finishing the download. Null when
+            // an older manifest omits `fileSizes` — the caller then falls back to counting files.
+            val plannedBytes = files.mapNotNull { manifest.fileSizes[it] }
+                .takeIf { it.size == files.size }
+                ?.sum()
+
+            val reporter = ProgressReporter(
+                filesTotal = files.size,
+                bytesTotal = plannedBytes,
+                emit = onProgress,
+            )
+
+            PackageDownloader.download(
+                client = client,
+                files = files,
+                urlFor = urlFor,
+                headers = headers,
+                expectedSha = manifest.sha256,
+                destRoot = staging,
+                onProgress = { done, _, path -> reporter.onFileDone(done, path) },
+                onBytes = { path, delta, _ -> reporter.onBytes(path, delta) },
+                onPhase = { path, phase -> reporter.onPhase(path, phase) },
+            )
+
+            reporter.emitNow(DownloadProgress.Phase.Installing)
+
+            // The download staging tree is a FULL SECOND COPY of the package and must not outlive the
+            // install. It used to be cleared only by the *next* pull of the same repo, so a 1.3 GB
+            // package left 1.3 GB of `.download/` sitting in app storage indefinitely, and a user who
+            // pulled two models paid for both. `finally`, not a trailing statement: a failed install
+            // is exactly when the device is most likely to be out of space.
+            try {
+                ModelPackageInstaller.install(
+                    stagedPackageDir = staging,
+                    cacheDir = cacheDir,
+                    repoId = repoId,
+                    variantId = variantId,
+                    consumeSource = true,
+                    // Recorded so the cache can report which repo id and which groups produced this
+                    // install; `sanitizeRepoId` is not invertible enough to reconstruct either.
+                    features = if (genai) features + "genai" else features,
+                )
+            } finally {
+                staging.deleteRecursively()
+            }
+        }
+
+    /**
+     * Accumulates per-chunk byte deltas into a whole-plan [DownloadProgress], throttled and rate-smoothed.
+     *
+     * Kept out of [PackageDownloader] on purpose: that object downloads a *list of files* and does not
+     * know it is assembling a package, so the plan-level totals and the throttle belong here, with the
+     * plan.
+     */
+    private class ProgressReporter(
+        private val filesTotal: Int,
+        private val bytesTotal: Long?,
+        private val emit: (DownloadProgress) -> Unit,
+    ) {
+        private val bytesDone = AtomicLong(0)
+        private var filesDone = 0
+        private var path = ""
+        private var phase = DownloadProgress.Phase.Downloading
+
+        private var lastEmitMs = 0L
+        private var lastEmitBytes = 0L
+        private var smoothedBps = 0.0
+
+        fun onBytes(path: String, delta: Long) {
+            this.path = path
+            bytesDone.addAndGet(delta)
+            maybeEmit()
+        }
+
+        fun onPhase(path: String, phase: DownloadProgress.Phase) {
+            this.path = path
+            // Verifying a 3 GB file takes long enough to look like a hang of its own, so a phase
+            // change always emits rather than waiting for the throttle window.
+            if (this.phase != phase) {
+                this.phase = phase
+                emitNow(phase)
+            }
+        }
+
+        fun onFileDone(done: Int, path: String) {
+            filesDone = done
+            this.path = path
+            emitNow(phase)
+        }
+
+        private fun maybeEmit() {
+            val now = System.currentTimeMillis()
+            if (now - lastEmitMs < PROGRESS_INTERVAL_MS) return
+            val done = bytesDone.get()
+            if (lastEmitMs > 0L) {
+                val seconds = (now - lastEmitMs) / 1000.0
+                val instant = if (seconds > 0) (done - lastEmitBytes) / seconds else 0.0
+                // Exponential smoothing: a raw per-window rate over mobile radio swings by an order
+                // of magnitude between samples, which makes the ETA unreadable.
+                smoothedBps = if (smoothedBps == 0.0) instant else 0.7 * smoothedBps + 0.3 * instant
+            }
+            lastEmitMs = now
+            lastEmitBytes = done
+            emit(snapshot(phase))
+        }
+
+        fun emitNow(phase: DownloadProgress.Phase) {
+            this.phase = phase
+            lastEmitMs = System.currentTimeMillis()
+            lastEmitBytes = bytesDone.get()
+            emit(snapshot(phase))
+        }
+
+        private fun snapshot(phase: DownloadProgress.Phase) =
+            DownloadProgress(
+                phase = phase,
+                filesDone = filesDone,
+                filesTotal = filesTotal,
+                path = path,
+                bytesDone = bytesDone.get().coerceAtLeast(0L),
+                bytesTotal = bytesTotal,
+                bytesPerSecond = smoothedBps.coerceAtLeast(0.0),
+            )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubResolver.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubResolver.kt
new file mode 100644
index 0000000..7b459da
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/HubResolver.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers.hub
+
+/**
+ * #21: builds Hugging Face Hub `resolve` URLs and the auth header. Pure (JVM-testable).
+ */
+object HubResolver {
+    const val DEFAULT_ENDPOINT = "https://huggingface.co"
+
+    /** `<endpoint>/<repoId>/resolve/<revision>/<repoRelativePath>`. */
+    fun fileUrl(endpoint: String, repoId: String, revision: String, path: String): String =
+        "${endpoint.trimEnd('/')}/$repoId/resolve/$revision/$path"
+
+    fun authHeaders(token: String?): Map<String, String> =
+        if (token.isNullOrBlank()) emptyMap() else mapOf("Authorization" to "Bearer $token")
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloadWorker.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloadWorker.kt
new file mode 100644
index 0000000..9e89970
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloadWorker.kt
@@ -0,0 +1,240 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import android.content.Context
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.Data
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import com.martinkorelic.mobiletransformers.packages.DeviceCapabilities
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import java.io.File
+import java.util.UUID
+
+/**
+ * One background pull, as the app sees it — no `androidx.work` types crossing the facade.
+         *
+ * Mirrors `scheduler.ScheduledChunk`. See [PackageDownloadWorker.observe] for why the interpretation
+ * lives in the SDK rather than in each consumer.
+ */
+data class DownloadJob(
+    val state: State,
+    /** Which stage of the pull is running (`resolve`, `download`, `verify`, `install`), when known. */
+    val phase: String? = null,
+    val filesDone: Int = 0,
+    val filesTotal: Int = 0,
+    val bytesDone: Long = 0L,
+    /** Null when the manifest does not size its files — render an indeterminate bar, not 0%. */
+    val bytesTotal: Long? = null,
+    val bytesPerSecond: Long = 0L,
+    val installedPath: String? = null,
+    val error: String? = null,
+) {
+    enum class State {
+        /** Accepted; its network/storage constraints are not met. With Wi-Fi only, this is "no Wi-Fi". */
+        WaitingForConstraints,
+        Running,
+        Finished,
+        Failed,
+        Blocked,
+        Cancelled,
+        }
+
+    val isTerminal: Boolean
+    get() = state == State.Finished || state == State.Failed || state == State.Cancelled
+
+    /** `0.0..1.0`, or null when the total is unknown — the caller must not invent a denominator. */
+    val fraction: Double?
+    get() = bytesTotal?.takeIf { it > 0 }?.let { (bytesDone.toDouble() / it).coerceIn(0.0, 1.0) }
+}
+
+/**
+ * #21: background package download as a WorkManager [CoroutineWorker] — wraps [HubDownloader] and reports
+ * per-file progress via [setProgress]. The scheduling/constraints (`unmetered`, `storage-not-low`) and the
+ * actual on-device run are the manual device leg; the download/verify/install logic itself is the
+ * MockWebServer-tested [PackageDownloader] + [HubDownloader].
+ */
+class PackageDownloadWorker(context: Context, params: WorkerParameters) :
+    CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        val repoId = inputData.getString(KEY_REPO_ID) ?: return Result.failure()
+        val cacheDir = inputData.getString(KEY_CACHE_DIR) ?: return Result.failure()
+        val revision = inputData.getString(KEY_REVISION) ?: "main"
+        val variant = inputData.getString(KEY_VARIANT)
+        val features = inputData.getStringArray(KEY_FEATURES)?.toSet() ?: setOf("inference")
+        val genai = inputData.getBoolean(KEY_GENAI, false)
+        val endpoint = inputData.getString(KEY_ENDPOINT) ?: HubResolver.DEFAULT_ENDPOINT
+        val token = inputData.getString(KEY_TOKEN)
+
+        return try {
+            HubDownloader.downloadAndInstall(
+                cacheDir = File(cacheDir),
+                repoId = repoId,
+                revision = revision,
+                variant = variant,
+                features = features,
+                genai = genai,
+                // Was omitted entirely, and the omission is silent: HubDownloader falls back to
+                // `manifest.defaultVariant` when `abis` is empty, so this path took whatever the
+                // publisher listed first regardless of what the phone can run — the exact behaviour
+                // removed from `fromPretrained`, still present here because the worker had no
+                // caller to expose it. Both paths now read the same DeviceCapabilities.
+                abis = DeviceCapabilities.abis(),
+                totalMemMb = DeviceCapabilities.totalMemoryMb(applicationContext),
+                endpoint = endpoint,
+                token = token,
+                onProgress = { p ->
+                    setProgressAsync(
+                        workDataOf(
+                            KEY_DONE to p.filesDone,
+                            KEY_TOTAL to p.filesTotal,
+                            KEY_PATH to p.path,
+                            KEY_PHASE to p.phase.name,
+                            KEY_BYTES_DONE to p.bytesDone,
+                            KEY_BYTES_TOTAL to (p.bytesTotal ?: -1L),
+                            KEY_BYTES_PER_SECOND to p.bytesPerSecond,
+                        ),
+                    )
+                },
+            )
+            Result.success()
+        } catch (e: Exception) {
+            Result.failure(Data.Builder().putString(KEY_ERROR, e.message).build())
+        }
+    }
+
+    companion object {
+        /**
+         * Schedule a background package download and return the enqueued request's id (#21).
+         *
+         * This was the missing half: the worker was fully written but nothing ever enqueued it, so
+         * `androidx.work` was a declared dependency with no caller and background download was
+         * unreachable from the SDK. Constraints match the plan — unmetered network + storage-not-low —
+         * and the work is unique per repo id so a second request for the same model does not download
+         * it twice.
+         */
+        fun enqueue(
+            context: Context,
+            repoId: String,
+            cacheDir: File,
+            revision: String = "main",
+            variant: String? = null,
+            features: Set<ModelFeature> = setOf(ModelFeature.Inference),
+            genai: Boolean = false,
+            endpoint: String = HubResolver.DEFAULT_ENDPOINT,
+            token: String? = null,
+            requireUnmetered: Boolean = true,
+        ): UUID {
+            val constraints = Constraints.Builder()
+                .setRequiredNetworkType(
+                    if (requireUnmetered) NetworkType.UNMETERED else NetworkType.CONNECTED,
+                )
+                .setRequiresStorageNotLow(true)
+                .build()
+
+            val request = OneTimeWorkRequestBuilder<PackageDownloadWorker>()
+                .setConstraints(constraints)
+                .setInputData(
+                    workDataOf(
+                        KEY_REPO_ID to repoId,
+                        KEY_CACHE_DIR to cacheDir.absolutePath,
+                        KEY_REVISION to revision,
+                        KEY_VARIANT to variant,
+                    // Converted here, once: a caller passing raw group strings is a caller that
+                    // can disagree with `fromPretrained` about what "training" downloads.
+                    KEY_FEATURES to DeviceCapabilities.downloadGroups(features).toTypedArray(),
+                        KEY_GENAI to genai,
+                        KEY_ENDPOINT to endpoint,
+                        KEY_TOKEN to token,
+                    ),
+                )
+                .build()
+
+            WorkManager.getInstance(context).enqueueUniqueWork(
+                uniqueWorkName(repoId),
+                ExistingWorkPolicy.KEEP,
+                request,
+            )
+            return request.id
+        }
+
+        /** Stable unique-work name so repeat requests for one repo coalesce. */
+        fun uniqueWorkName(repoId: String): String = "mobiletransformers-download:$repoId"
+
+        /** Stop the pull for [repoId]. The staging tree is cleaned by [HubDownloader]'s own finally. */
+        fun cancel(context: Context, repoId: String) {
+            WorkManager.getInstance(context).cancelUniqueWork(uniqueWorkName(repoId))
+        }
+
+        /**
+ * The pull for [repoId], already interpreted — the same argument as
+ * `TrainingScheduler.observeChunks`.
+         *
+ * Returning `List<WorkInfo>` would force every consumer to depend on `androidx.work` and to
+ * decode this object's own progress keys, which is exactly the coupling that left the worker
+ * with no caller: the app could not read a pull it had started without reaching past the
+ * facade. The interpretation belongs here, once.
+         *
+ * `ENQUEUED` is the state whose name explains it worst and matters most — it means "accepted,
+ * and its network/storage constraints are not met yet", which with the default
+ * `requireUnmetered = true` means "waiting for Wi-Fi", an indefinite and entirely normal wait
+ * that otherwise looks like a hang.
+ */
+        fun observe(context: Context, repoId: String): Flow<List<DownloadJob>> =
+        WorkManager.getInstance(context)
+.getWorkInfosForUniqueWorkFlow(uniqueWorkName(repoId))
+.map { infos -> infos.map { it.toDownloadJob() } }
+
+        private fun WorkInfo.toDownloadJob(): DownloadJob {
+            val bytesTotal = progress.getLong(KEY_BYTES_TOTAL, -1L).takeIf { it >= 0 }
+            return DownloadJob(
+                state = when (state) {
+                    WorkInfo.State.ENQUEUED -> DownloadJob.State.WaitingForConstraints
+                    WorkInfo.State.RUNNING -> DownloadJob.State.Running
+                    WorkInfo.State.SUCCEEDED -> DownloadJob.State.Finished
+                    WorkInfo.State.FAILED -> DownloadJob.State.Failed
+                    WorkInfo.State.BLOCKED -> DownloadJob.State.Blocked
+                    WorkInfo.State.CANCELLED -> DownloadJob.State.Cancelled
+                },
+                phase = progress.getString(KEY_PHASE),
+                filesDone = progress.getInt(KEY_DONE, 0),
+                filesTotal = progress.getInt(KEY_TOTAL, 0),
+                bytesDone = progress.getLong(KEY_BYTES_DONE, 0L),
+                // -1 is the sentinel for "the manifest does not size its files", mirroring
+                // DownloadProgress.bytesTotal == null. Reporting it as a real total would render a
+                // progress bar running backwards from 100%.
+                bytesTotal = bytesTotal,
+                bytesPerSecond = progress.getLong(KEY_BYTES_PER_SECOND, 0L),
+                // Only present once the work ends; on the failure path it is the reason.
+                installedPath = outputData.getString(KEY_PATH),
+                error = outputData.getString(KEY_ERROR),
+                    )
+        }
+
+        const val KEY_REPO_ID = "repoId"
+        const val KEY_CACHE_DIR = "cacheDir"
+        const val KEY_REVISION = "revision"
+        const val KEY_VARIANT = "variant"
+        const val KEY_FEATURES = "features"
+        const val KEY_GENAI = "genai"
+        const val KEY_ENDPOINT = "endpoint"
+        const val KEY_TOKEN = "token"
+        const val KEY_DONE = "done"
+        const val KEY_TOTAL = "total"
+        const val KEY_PATH = "path"
+        const val KEY_ERROR = "error"
+        const val KEY_PHASE = "phase"
+        const val KEY_BYTES_DONE = "bytesDone"
+        /** `-1` when the manifest does not size its files, mirroring `DownloadProgress.bytesTotal == null`. */
+        const val KEY_BYTES_TOTAL = "bytesTotal"
+        const val KEY_BYTES_PER_SECOND = "bytesPerSecond"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloader.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloader.kt
new file mode 100644
index 0000000..c3e71cc
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/hub/PackageDownloader.kt
@@ -0,0 +1,179 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.security.MessageDigest
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import kotlin.coroutines.coroutineContext
+
+/**
+ * #21: the streaming download core — extracted from the WorkManager worker so it is MockWebServer-testable
+ * on the JVM. For each repo-relative path: stream a GET (HTTP Range-resume from a sibling `.partial`) into
+ * `destRoot/<path>`, hashing while writing, verify SHA-256 against `expectedSha[path]`, delete + retry on
+ * mismatch, then publish `.partial` → final. Fails closed after `maxRetries`.
+ */
+object PackageDownloader {
+
+    /**
+     * Progress from *inside* a single file's transfer.
+     *
+     * The per-file `onProgress` below cannot describe a package whose weights are one 3 GB file: it
+     * fires once, at the end. This fires as the bytes land, which is the difference between a
+     * progress bar and a frozen screen.
+     */
+    fun interface ByteProgressListener {
+        /**
+         * @param path the repo-relative file being transferred.
+         * @param deltaBytes bytes written since the previous call (or resumed from a `.partial` on
+         *   the first call for a file, so the running total stays honest across a resume).
+         * @param fileBytesTotal the file's size when the server declares one, else `null`.
+         */
+        fun onBytes(path: String, deltaBytes: Long, fileBytesTotal: Long?)
+    }
+
+    /** Signals which stage a given file is in, so the caller can distinguish transfer from hashing. */
+    fun interface PhaseListener {
+        fun onPhase(path: String, phase: DownloadProgress.Phase)
+    }
+
+    /**
+     * An HTTP client sized for multi-gigabyte bodies.
+     *
+     * `OkHttpClient()` defaults to a **10-second read timeout**, which is a reasonable default for an
+     * API call and a wrong one for streaming model weights off a CDN: one slow window mid-transfer
+     * aborts a download that is minutes in, and the resulting `SocketTimeoutException` says nothing
+     * about which file or how far it got. The whole-call timeout must stay 0 — capping a 4 GB transfer
+     * at any wall-clock figure is a guess about the user's connection.
+     */
+    fun defaultClient(): OkHttpClient =
+        OkHttpClient.Builder()
+            .connectTimeout(30, TimeUnit.SECONDS)
+            .readTimeout(60, TimeUnit.SECONDS)
+            .writeTimeout(60, TimeUnit.SECONDS)
+            .callTimeout(0, TimeUnit.SECONDS)
+            .retryOnConnectionFailure(true)
+            .build()
+
+    suspend fun download(
+        client: OkHttpClient,
+        files: List<String>,
+        urlFor: (String) -> String,
+        headers: Map<String, String>,
+        expectedSha: Map<String, String>,
+        destRoot: File,
+        maxRetries: Int = 2,
+        onProgress: (done: Int, total: Int, path: String) -> Unit = { _, _, _ -> },
+        onBytes: ByteProgressListener = ByteProgressListener { _, _, _ -> },
+        onPhase: PhaseListener = PhaseListener { _, _ -> },
+    ): Unit =
+        withContext(Dispatchers.IO) {
+            files.forEachIndexed { index, path ->
+                coroutineContext.ensureActive()
+                val target = File(destRoot, path)
+                target.parentFile?.mkdirs()
+                val expected = expectedSha[path]
+
+                var attempt = 0
+                while (true) {
+                    onPhase.onPhase(path, DownloadProgress.Phase.Downloading)
+                    val fetched = fetchToFile(client, urlFor(path), headers, target, path, onBytes)
+                    onPhase.onPhase(path, DownloadProgress.Phase.Verifying)
+                    if (expected == null || fetched.sha256.equals(expected, ignoreCase = true)) break
+                    target.delete()
+                    if (++attempt > maxRetries) {
+                        throw IOException(
+                            "checksum mismatch for '$path' after ${attempt} attempt(s): " +
+                                "expected $expected, got ${fetched.sha256}",
+                        )
+                    }
+                    // A retry re-downloads the file from scratch, so the bytes already counted for it
+                    // are no longer done. Retract them, or the running total drifts past the plan's
+                    // size and the progress bar reports more than 100%.
+                    onBytes.onBytes(path, -fetched.bytesCounted, null)
+                }
+                onProgress(index + 1, files.size, path)
+            }
+        }
+
+    /** What one file's transfer produced: its hash, and how many bytes were reported for it. */
+    private data class Fetched(val sha256: String, val bytesCounted: Long)
+
+    private suspend fun fetchToFile(
+        client: OkHttpClient,
+        url: String,
+        headers: Map<String, String>,
+        target: File,
+        path: String,
+        onBytes: ByteProgressListener,
+    ): Fetched {
+        var counted = 0L
+        val partial = File(target.parentFile, target.name + ".partial")
+        val existing = if (partial.isFile) partial.length() else 0L
+
+        val builder = Request.Builder().url(url)
+        headers.forEach { (k, v) -> builder.header(k, v) }
+        if (existing > 0) builder.header("Range", "bytes=$existing-")
+
+        client.newCall(builder.build()).execute().use { resp ->
+            val resumed = resp.code == 206 && existing > 0
+            if (!resp.isSuccessful) throw IOException("GET $url -> HTTP ${resp.code}")
+            val body = resp.body ?: throw IOException("empty body for $url")
+
+            // `contentLength` is the length of THIS response, so on a 206 it is the remainder; the
+            // file's real size is that plus what we already hold.
+            val declared = body.contentLength().takeIf { it >= 0 }
+            val fileTotal = declared?.let { if (resumed) it + existing else it }
+
+            val digest = MessageDigest.getInstance("SHA-256")
+            if (resumed) {
+                partial.inputStream().use { feed(digest, it) }
+                // Count the resumed prefix once, so a resumed download does not appear to restart
+                // from zero and then overshoot its own total.
+                counted += existing
+                onBytes.onBytes(path, existing, fileTotal)
+            } else if (partial.exists()) {
+                partial.delete() // server ignored Range (200) -> restart cleanly
+            }
+
+            FileOutputStream(partial, resumed).use { out ->
+                body.byteStream().use { input ->
+                    val buf = ByteArray(1 shl 16)
+                    while (true) {
+                        // Per-chunk, not per-file: cancelling a 3 GB transfer used to be observed
+                        // only at the next file boundary, i.e. not at all for a single-weight
+                        // package. The `.partial` is left in place, so Range-resume picks it up.
+                        coroutineContext.ensureActive()
+                        val n = input.read(buf)
+                        if (n < 0) break
+                        out.write(buf, 0, n)
+                        digest.update(buf, 0, n)
+                        counted += n
+                        onBytes.onBytes(path, n.toLong(), fileTotal)
+                    }
+                }
+            }
+            val hex = digest.digest().joinToString("") { "%02x".format(it) }
+            if (target.exists()) target.delete()
+            if (!partial.renameTo(target)) {
+                partial.copyTo(target, overwrite = true)
+                partial.delete()
+            }
+            return Fetched(hex, counted)
+        }
+    }
+
+    private fun feed(digest: MessageDigest, input: java.io.InputStream) {
+        val buf = ByteArray(1 shl 16)
+        while (true) {
+            val n = input.read(buf)
+            if (n < 0) break
+            digest.update(buf, 0, n)
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/ConfigMappers.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/ConfigMappers.kt
new file mode 100644
index 0000000..60c1b40
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/ConfigMappers.kt
@@ -0,0 +1,141 @@
+package com.martinkorelic.mobiletransformers.internal.config
+
+import com.martinkorelic.mobiletransformers.DatasetOptions
+import com.martinkorelic.mobiletransformers.NotImplementedFeatureException
+import com.martinkorelic.mobiletransformers.DeviceOptions
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.SamplingOptions
+import com.martinkorelic.mobiletransformers.SchedulerConfig
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.SamplingConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.constants.IndexingMode
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+
+/**
+ * Maps the public HF-flavored configs (#17) onto the existing `ORT*Config` data classes verbatim. Defaults
+ * on both sides match, so `<PublicConfig>().toOrt()` equals `ORT*Config()` (round-trip unit test) — no
+ * behavior shifts. The `ORT*` types never leak into a public signature; this mapping is the only bridge.
+ */
+
+fun DeviceConfig.toOrt(): DeviceOptions =
+    DeviceOptions(
+        enableProfiling = enableProfiling,
+        coreConfigId = coreConfigId.wire,
+        memoryConfigId = memoryConfigId.wire,
+        executionProvider = executionProvider.wire,
+    )
+
+fun SamplingConfig.toOrt(): SamplingOptions =
+    SamplingOptions(
+        method = method.wire,
+        temperature = temperature,
+        topK = topK,
+        topP = topP,
+        seed = seed,
+    )
+
+/**
+ * Overlay this public config onto what the installed package declares.
+ *
+ * [base] is the package's parsed `train/training_config.json` (`LLMRepository.trainingConfig`). Model
+ * identity (`repoName`, `onnxName`) and the dataset task (`taskName`) come from the package; the
+ * training hyper-parameters come from the caller. Building a fresh `ORTTrainingConfig` here — the
+ * previous behaviour — reset all three to their library defaults, so on-device training looked for its
+ * data under `<cacheDir>/model/train/` and hit `IllegalArgumentException: Unsupported task: none`
+ * (`DataUtil.kt:71`) before doing any work. Same fix as `GenerationConfig`/`RagConfig`.
+ */
+fun TrainConfig.toOrt(base: ORTTrainingConfig = ORTTrainingConfig()): ORTTrainingConfig {
+    val schedulerConfig =
+        when (scheduler) {
+            SchedulerType.LINEAR -> SchedulerConfig.Linear(learningRate = learningRate)
+            SchedulerType.COSINE ->
+                SchedulerConfig.Cosine(
+                    learningRate = learningRate,
+                    minLearningRate = minLearningRate,
+                    warmupSteps = warmupSteps,
+                )
+        }
+    return ORTTrainingConfig(
+        repoName = base.repoName,
+        onnxName = base.onnxName,
+        taskName = base.taskName,
+        batchSize = batchSize,
+        numTrainEpochs = epochs,
+        maxSteps = maxSteps,
+        saveSteps = saveSteps,
+        gradAccumSteps = gradientAccumulationSteps,
+        mergeWeightsAtEnd = mergeAtEnd,
+        saveModelAtEnd = saveAtEnd,
+        loadFromState = resumeFromState,
+        schedulerType = scheduler.wire,
+        schedulerConfig = schedulerConfig,
+        deviceOptions = device.toOrt(),
+    )
+}
+
+fun DatasetConfig.toOrt(): DatasetOptions =
+    DatasetOptions(
+        trainFile = trainFile,
+        datasetBatchSize = datasetBatchSize,
+        maxSequenceLength = maxSequenceLength,
+        maxDatasetLength = maxDatasetLength,
+    )
+
+/**
+ * #19/#24: `engine` drives `type` (`"native"`/`"genai"`) and the runtime's post-merge state drives
+ * `loadMergedWeights`. Defaults preserve the #17 behavior so `GenerationConfig().toOrt()` still equals
+ * `ORTGenerationConfig()` (round-trip test): Native engine + the config's own `loadMerged` flag.
+ */
+fun GenerationConfig.toOrt(
+    engine: InferenceEngine = InferenceEngine.NATIVE,
+    mergedLoaded: Boolean = loadMerged,
+): ORTGenerationConfig =
+    ORTGenerationConfig(
+        type = if (engine == InferenceEngine.GENAI) "genai" else "native",
+        // #11: `engine` is what ModelRuntimeFactory.selectEngine actually reads. Leaving it null (the
+        // pre-fix behavior) pinned every session to Native regardless of `type`, so a GenAI request
+        // silently constructed nothing and generate() never completed.
+        engine = engine,
+        maxSequenceLength = maxNewTokens,
+        systemPrompt = systemPrompt,
+        loadMergedWeights = mergedLoaded,
+        sampling = sampling.toOrt(),
+        deviceOptions = device.toOrt(),
+    applyChatTemplate = applyChatTemplate,
+    )
+
+/**
+ * Overlay this public config onto what the installed package declares.
+ *
+ * [base] is the package's parsed `embedding/rag_config.json` (`LLMRepository.ragConfig`). Encoder
+ * identity — repo dir, graph filename, vector width — comes from the package unless the caller
+ * explicitly overrode it; query shaping always comes from the caller. Replacing [base] wholesale (the
+ * previous behaviour) meant a default-constructed `RagConfig` pointed the retriever at
+ * `<cacheDir>/model/embedding/` with a 256-wide store, so retrieval on a real package could not work.
+ */
+fun RagConfig.toOrt(base: ORTRagConfig = ORTRagConfig()): ORTRagConfig {
+    // #27 F7: dynamic indexing is a fail-closed stub in v1.
+    if (indexingMode == IndexingMode.DYNAMIC) {
+        throw NotImplementedFeatureException("indexingMode=dynamic (v1 supports 'precompute' only)")
+    }
+    return ORTRagConfig(
+        repoName = embeddingRepoId ?: base.repoName,
+        onnxName = embeddingModelFile ?: base.onnxName,
+        embeddingDimension = embeddingDimension ?: base.embeddingDimension,
+        topK = topK,
+        searchType = searchType.wire,
+        minScore = minScore,
+        indexingMode = indexingMode.wire,
+        maxTextLength = maxTextLength,
+        chunkSize = chunkSize,
+        chunkOverlap = chunkOverlap,
+        deviceOptions = device.toOrt(),
+    )
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/PeftSupport.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/PeftSupport.kt
new file mode 100644
index 0000000..16805aa
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/config/PeftSupport.kt
@@ -0,0 +1,54 @@
+package com.martinkorelic.mobiletransformers.internal.config
+
+import com.google.gson.JsonParser
+import com.martinkorelic.mobiletransformers.PeftMismatchException
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+
+/**
+ * Pure PEFT taxonomy mapping + validation (#19). On-device `applyPeft` reads the exported method from the
+ * package's `train/training_config.json` and validates the requested [PeftConfig] against it. This mirrors
+ * the Python export taxonomy (`export/training_export.py` `train_method`, via `config/registry/peft.py`,
+ * + `MarsConfig.optimization_level`); keep
+ * the two in sync. Everything here is pure (Gson, no Android framework) so it is JVM-unit-testable.
+ */
+data class PeftTaxonomy(val trainMethod: String, val optimizationLevel: Int?)
+
+object PeftSupport {
+
+    /** Map a requested [PeftConfig] onto the Python `(train_method, optimization_level)` taxonomy. */
+    fun taxonomy(peft: PeftConfig): PeftTaxonomy =
+        when (peft) {
+            is PeftConfig.Lora -> PeftTaxonomy("lora", null)
+            is PeftConfig.MarsOpt0 -> PeftTaxonomy("mars", 0)
+            is PeftConfig.MarsOpt1 -> PeftTaxonomy("mars", 1)
+            is PeftConfig.MarsQuantized -> PeftTaxonomy("mars", peft.optimizationLevel)
+        }
+
+    /**
+     * Parse `(train_method, optimization_level)` from a `training_config.json` string (tolerating a
+     * `train_config` wrapper). Returns null if the package declares no method — i.e. it cannot be
+     * validated and [validate] accepts.
+     */
+    fun packageTaxonomy(trainingConfigJson: String): PeftTaxonomy? {
+        val root = JsonParser.parseString(trainingConfigJson).asJsonObject
+        val cfg = if (root.has("train_config")) root.getAsJsonObject("train_config") else root
+        val method = if (cfg.has("train_method")) cfg.get("train_method").asString else return null
+        val opt = if (cfg.has("optimization_level")) cfg.get("optimization_level").asInt else null
+        return PeftTaxonomy(method, opt)
+    }
+
+    /** Fail closed with [PeftMismatchException] if [requested] doesn't match the package's export [pkg]. */
+    fun validate(requested: PeftConfig, pkg: PeftTaxonomy?) {
+        pkg ?: return // package declares no method — nothing to validate against
+        val want = taxonomy(requested)
+        val matches = want.trainMethod == pkg.trainMethod &&
+            (want.optimizationLevel == null || pkg.optimizationLevel == null ||
+                want.optimizationLevel == pkg.optimizationLevel)
+        if (!matches) {
+            throw PeftMismatchException(requested = describe(want), supported = listOf(describe(pkg)))
+        }
+    }
+
+    private fun describe(t: PeftTaxonomy): String =
+        t.trainMethod + (t.optimizationLevel?.let { " (optimization_level=$it)" } ?: "")
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierSession.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierSession.kt
new file mode 100644
index 0000000..9a863e8
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierSession.kt
@@ -0,0 +1,156 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import android.content.Context
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.ORTRetriever
+import com.martinkorelic.mobiletransformers.ORTTokenizerNative
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.packages.PackageTask
+import com.martinkorelic.mobiletransformers.runtime.ClassificationResult
+import com.martinkorelic.mobiletransformers.runtime.LabelScore
+import java.io.File
+import kotlin.math.exp
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Runs a sequence-classification graph and turns its logits into named labels.
+ *
+ * ### Why this exists
+ *
+ * Encoder fine-tuning (#33) works end to end — export, training artifacts, a train step, a metric —
+ * and there was **no way to run the resulting model**. `MobileTransformerModel` offered
+ * generate / retrieve / ingest / train and nothing else, all of which assume a decoder. So a BERT
+ * classifier could be trained on device and then never asked a question: the one thing a user would
+ * want to do with it after training was the one thing the API could not do.
+ *
+ * ### Why it borrows the embedding session
+ *
+ * The native embedding entry points are exactly what a classification forward pass needs and nothing
+ * more: `createEmbeddingSession` opens an encoder graph, and `performEmbeddingStep` feeds
+ * `input_ids`/`attention_mask`/`token_type_ids` and returns the **raw first output tensor** as floats
+ * (`inference::generateEmbedding` does no pooling of its own). For a classification head that tensor
+ * is `logits[batch, num_labels]`, so the same call yields logits when pointed at the inference stage
+ * with `embeddingDim = numLabels`. No new JNI, no C++ change.
+ *
+ * What it deliberately does **not** reuse is `ORTRetriever.createEmbeddingModel`, which resolves the
+ * *embedding* stage, opens the embedder's own tokenizer and creates an ObjectBox vector store — three
+ * things a classifier has no use for, one of which (`DimensionRegistry.requireSupported`) would reject
+ * a two-label head outright.
+ */
+internal class ClassifierSession(
+    private val context: Context,
+    private val cacheDir: String,
+    private val sanitizedRepoId: String,
+    private val task: PackageTask,
+) {
+
+    private val paths get() = PackagePaths.forCache(cacheDir, sanitizedRepoId)
+
+    /** Holds the JNI entry points; never used as a retriever. */
+    private val native = ORTRetriever(cacheDir, context, ORTRagConfig(repoName = sanitizedRepoId))
+
+    private var tokenizer: ORTTokenizerNative? = null
+    private var session: Long = 0L
+
+    suspend fun classify(text: String, device: DeviceConfig, topK: Int): ClassificationResult =
+        withContext(Dispatchers.IO) {
+            val labels = task.id2label
+            if (labels.isEmpty()) {
+                // Running the graph would still work and every prediction would come back as an
+                // index, which is a number in a costume rather than an answer.
+                throw MissingArtifactException(
+                    "package '$sanitizedRepoId' declares no id2label, so a predicted class has no " +
+                        "name. Re-export it with a newer exporter, which copies id2label into " +
+                        "inference/${PackageTask.FILENAME}.",
+                )
+            }
+
+            ensureOpen(device)
+            val tok = tokenizer ?: throw MissingArtifactException("tokenizer did not open")
+
+            // CLS/SEP the way an encoder expects them — the same framing `ORTRetriever.ingestData`
+            // uses for the embedder, because it is the same family of graph.
+            val tokens = tok.tokenize(text, prependCls = true, appendSep = true, dropZero = true)
+            val maxLen = tok.maximumTokenLength.takeIf { it > 0 } ?: 512
+            val length = minOf(tokens.size, maxLen)
+            val inputIds = LongArray(length) { tokens[it].toLong() }
+            val attentionMask = LongArray(length) { 1L }
+            val tokenTypeIds = LongArray(length) { 0L }
+
+            val logits = native.performEmbeddingStep(
+                session = session,
+                inputIds = inputIds,
+                attentionMask = attentionMask,
+                tokenTypeIds = tokenTypeIds,
+                batchSize = 1,
+                sequenceLength = length,
+                // The head's width, not an embedding width. This is the whole trick.
+                embeddingDim = labels.size,
+            ) ?: throw MissingArtifactException("the classification graph returned no output")
+
+            ClassificationResult(scores = softmaxToLabels(logits, labels), topK = topK)
+        }
+
+    private suspend fun ensureOpen(device: DeviceConfig) {
+        val inferenceDir = paths.inference
+        if (!File(inferenceDir, "model.onnx").isFile) {
+            throw MissingArtifactException(
+                "no inference/model.onnx in '$sanitizedRepoId' — nothing to classify with",
+            )
+        }
+        if (tokenizer == null) {
+            // The package's shared tokenizer, not `embedding/tokenizer`: a classifier's inputs are
+            // tokenized by the model's own tokenizer, and an embedding stage need not even exist.
+            tokenizer = ORTTokenizerNative(paths.tokenizer.absolutePath).also { it.createTokenizerModel() }
+        }
+        if (session == 0L) {
+            session = native.createEmbeddingSession(
+                inferenceDir.absolutePath,
+                "model.onnx",
+                cacheDir,
+                device.memoryConfigId.wire,
+                device.coreConfigId.wire,
+                device.executionProvider.wire,
+                device.enableProfiling,
+            )
+        }
+    }
+
+    fun close() {
+        if (session != 0L) {
+            runCatching { native.releaseEmbeddingSession(session) }
+            session = 0L
+        }
+        tokenizer = null
+    }
+
+    companion object {
+        /**
+         * Softmax over the head's logits, paired with the package's own label names.
+         *
+         * Max-subtracted, which is not a nicety: a classification head's logits routinely exceed 80,
+         * and `exp(80f)` overflows a Float to infinity, so the naive form returns NaN for exactly the
+         * confident predictions it matters most to report.
+         */
+        fun softmaxToLabels(logits: FloatArray, id2label: Map<Int, String>): List<LabelScore> {
+            val n = minOf(logits.size, id2label.size)
+            if (n == 0) return emptyList()
+            val head = logits.take(n)
+            val max = head.max()
+            val exps = head.map { exp((it - max).toDouble()) }
+            val sum = exps.sum().takeIf { it > 0.0 } ?: 1.0
+            return head.indices
+                .map { i ->
+                    LabelScore(
+                        label = id2label[i] ?: "LABEL_$i",
+                        score = exps[i] / sum,
+                        index = i,
+                    )
+                }
+                .sortedByDescending { it.score }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputs.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputs.kt
new file mode 100644
index 0000000..2678f05
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputs.kt
@@ -0,0 +1,49 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+/**
+ * The three tensors an inference step binds, planned as pure data.
+ *
+ * @property inputIds the new tokens to run through the model — only the delta, never the cached prefix.
+ * @property attentionMask one slot per token the model may attend to: `pastLength + inputIds.size`.
+ * @property positionIds the absolute position of each entry in [inputIds], continuing from the cache.
+ */
+data class GenerationInputPlan(
+    val inputIds: MutableList<Long>,
+    val attentionMask: MutableList<Long>,
+    val positionIds: MutableList<Long>,
+)
+
+/**
+ * Plans the per-step inference inputs from the new tokens plus how much KV cache already exists.
+ *
+ * Deliberately pure and free of ORT/JNI, for the same reason `cpp/training_inputs.h`,
+ * `cpp/layer_name.h` and `cpp/handoff_io.h` are: the decision is host-testable, so a JVM test can pin
+ * the turn boundary that previously only a phone could reach.
+ *
+ * **The invariant, stated once:** the attention mask covers `past + new`, and the position ids are the
+ * absolute indices of the new tokens *within that same span* — `past..past+new-1`. Both inputs must
+ * agree about where the sequence is.
+ *
+ * That invariant was violated. `ORTGeneratorNative.createModelInputs` built the mask as
+ * `pastAttentionMaskLength + k` but the positions as `0..k-1`, so the second turn of a conversation
+ * told the graph "you have N cached tokens" and "these tokens start at 0" simultaneously. transformers
+ * 4.46.2 tolerated the contradiction; 4.57.6 does not, and surfaced it as a `Gather` index out of
+ * bounds on the second prompt only. The upgrade exposed the defect rather than causing it.
+ */
+object GenerationInputs {
+
+    /**
+     * @param inputIds the new tokens for this step.
+     * @param pastLength the number of tokens already in the KV cache (0 on the first turn).
+     * @throws IllegalArgumentException if [pastLength] is negative — a caller that has lost track of
+     *   the cache length must fail here, not bind a nonsensical mask and get an opaque ORT error.
+     */
+    fun plan(inputIds: IntArray, pastLength: Int): GenerationInputPlan {
+        require(pastLength >= 0) { "pastLength must be >= 0, got $pastLength" }
+        return GenerationInputPlan(
+            inputIds = inputIds.map { it.toLong() }.toMutableList(),
+            attentionMask = MutableList(pastLength + inputIds.size) { 1L },
+            positionIds = MutableList(inputIds.size) { (pastLength + it).toLong() },
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPrecondition.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPrecondition.kt
new file mode 100644
index 0000000..94d5859
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPrecondition.kt
@@ -0,0 +1,94 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.packages.ChecksumVerifier
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.io.File
+
+/**
+ * #23: fail-closed precondition for loading merged trained weights as flat per-tensor external
+ * initializers, replacing the retired `inference/merged/` directory probe.
+ *
+ * Mirrors the on-disk contract #9 writes into `<cacheDir>/<repo>/inference/`:
+ *  - `weight_handoff_map.json` (schema-gated via [PackageFormat.checkCompat]),
+ *  - one flat `<name>.bin` per `externalDataLocation[role]`,
+ *  - a sibling `<name>.bin.sha256` (hex + newline) written atomically by the merger
+ *    (`weight_merger.cpp::write_raw_tensor_atomic`), and/or a per-role `sha256` in the map itself.
+ *
+ * **Checksum precedence: sidecar over map.** The sidecar is the *live* digest (rewritten by the device
+ * merger); the map's `sha256` is the *shipped* digest (stamped by the exporter over the pre-merge base
+ * bytes, never refreshed on device). See `docs/MODEL_FORMAT.md`.
+ *
+ * This is the PRIMARY gate: it runs BEFORE the native session is created. A missing map means there is
+ * nothing merged to load (the base graph is used — not an error). A map that is present but broken
+ * (missing `.bin`, checksum mismatch, absent checksum) throws [MissingArtifactException] naming the
+ * offending tensor rather than silently downgrading to base weights. The C++ loader
+ * (`session_cache.h`) re-derives initializer names from the map and additionally validates dtype/shape
+ * against each loaded `TensorProto` (which requires parsing the protobuf, hence C++-side).
+ */
+object HandoffPrecondition {
+
+    /**
+     * True iff [inferenceDir] carries a valid, fully-materialized merged-weight set.
+     *
+     * @param verifyChecksums when true (the load gate), every `.bin` is hashed and matched against its
+     *   declared checksum; when false (the cheap capability query), only presence + schema are checked.
+     * @throws MissingArtifactException if the map is present but any file/checksum check fails.
+     */
+    fun loadMergedWeightsReady(inferenceDir: File, verifyChecksums: Boolean = true): Boolean {
+        val mapFile = File(inferenceDir, WeightHandoffMap.FILENAME)
+        if (!mapFile.isFile) return false
+
+        val map = WeightHandoffMap.load(mapFile)
+        if (!PackageFormat.checkCompat(map.schemaVersion, map.minReaderVersion, WeightHandoffMap.READER_VERSION)) {
+            throw MissingArtifactException(
+                "weight_handoff_map.json schema ${map.schemaVersion} (minReader ${map.minReaderVersion}) " +
+                    "incompatible with reader ${WeightHandoffMap.READER_VERSION}",
+            )
+        }
+        if (map.entries.isEmpty()) return false
+
+        for (entry in map.entries) {
+            val where = entry.trainingBaseLayerName.ifEmpty { "<unnamed handoff entry>" }
+            for ((role, binName) in entry.externalDataLocation) {
+                val bin = File(inferenceDir, binName)
+                if (!bin.isFile) {
+                    throw MissingArtifactException(
+                        "$where: merged weight file '$binName' (role '$role') missing from inference/",
+                    )
+                }
+                if (!verifyChecksums) continue
+
+                val actual = ChecksumVerifier.sha256(bin)
+                // #9/#23 precedence: the SIDECAR wins. `<name>.bin.sha256` is the LIVE digest —
+                // `weight_merger.cpp::write_raw_tensor_atomic` rewrites it on every on-device merge.
+                // `entry.sha256[role]` is the SHIPPED digest, stamped once by the exporter over the
+                // pre-merge base bytes and never updated by the device (C++ only reads the map).
+                // Preferring the map made a *correct* merge throw a checksum mismatch on the next load.
+                val expected = readSidecar(File(inferenceDir, "$binName.sha256"))
+                    ?: entry.sha256[role]?.takeIf { it.isNotBlank() }
+                    ?: throw MissingArtifactException(
+                        "$where: no checksum for role '$role' (neither '$binName.sha256' nor map sha256)",
+                    )
+                if (!actual.equals(expected, ignoreCase = true)) {
+                    throw MissingArtifactException(
+                        "$where: checksum mismatch for '$binName' (role '$role'): expected $expected, got $actual",
+                    )
+                }
+            }
+        }
+        return true
+    }
+
+    /** Non-throwing capability query: presence + schema + file existence only (no hashing). */
+    fun mergedWeightsPresent(inferenceDir: File): Boolean =
+        try {
+            loadMergedWeightsReady(inferenceDir, verifyChecksums = false)
+        } catch (_: Exception) {
+            false
+        }
+
+    private fun readSidecar(f: File): String? =
+        if (f.isFile) f.readText().trim().substringBefore('\n').trim().ifBlank { null } else null
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/RepositoryBackedModelSession.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/RepositoryBackedModelSession.kt
new file mode 100644
index 0000000..a431295
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/internal/runtime/RepositoryBackedModelSession.kt
@@ -0,0 +1,409 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import com.martinkorelic.mobiletransformers.GenerateCallback
+import com.martinkorelic.mobiletransformers.GenerateProgress
+import com.martinkorelic.mobiletransformers.InferenceProgress
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.NotImplementedFeatureException
+import com.martinkorelic.mobiletransformers.RagResult
+import com.martinkorelic.mobiletransformers.RetrieveCallback
+import com.martinkorelic.mobiletransformers.Tasks
+import com.martinkorelic.mobiletransformers.TrainCallback
+import com.martinkorelic.mobiletransformers.TrainProgress
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedRoundResult
+import com.martinkorelic.mobiletransformers.federated.FederatedTrainingRepository
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.hub.AdapterUploadDisabledException
+import com.martinkorelic.mobiletransformers.hub.AdapterUploader
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import com.martinkorelic.mobiletransformers.internal.config.PeftSupport
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.PromptAssembler
+import com.martinkorelic.mobiletransformers.rag.PromptStrategy
+import com.martinkorelic.mobiletransformers.runtime.GroundedResult
+import com.martinkorelic.mobiletransformers.runtime.IngestResult
+import com.martinkorelic.mobiletransformers.repository.GenerationCallback
+import com.martinkorelic.mobiletransformers.repository.InferenceRepository
+import com.martinkorelic.mobiletransformers.repository.LLMRepository
+import com.martinkorelic.mobiletransformers.repository.RagCallback
+import com.martinkorelic.mobiletransformers.repository.RagRepository
+import com.martinkorelic.mobiletransformers.repository.TrainingCallback
+import com.martinkorelic.mobiletransformers.repository.TrainingRepository
+import com.martinkorelic.mobiletransformers.runtime.GenerationResult
+import com.martinkorelic.mobiletransformers.runtime.MergeResult
+import com.martinkorelic.mobiletransformers.runtime.ModelSession
+import com.martinkorelic.mobiletransformers.runtime.PushResult
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+import com.martinkorelic.mobiletransformers.training.TrainingJob
+import com.martinkorelic.mobiletransformers.training.TrainingJobManager
+import java.io.File
+import kotlinx.coroutines.CompletableDeferred
+
+/**
+ * The only [ModelSession] implementation (#17, extended by #19): adapts the existing `LLMRepository` +
+ * `Training/Inference/Rag` repositories to the facade contract. It maps the public configs via [toOrt],
+ * validates PEFT selection, threads public callbacks over the repository callback streams, and drives
+ * the engine-aware `ORTGenerationConfig.type` / post-merge `loadMergedWeights`. No engine logic lives
+ * here — generation is delegated through the repositories to whichever engine #11's factory selected.
+ */
+internal class RepositoryBackedModelSession(
+    private val repo: LLMRepository,
+    override val capabilities: RuntimeCapabilities,
+    private val modelDir: File,
+    private val inferencePackagePath: String? = null,
+) : ModelSession {
+
+    private val training = TrainingRepository(repo)
+    private val inference = InferenceRepository(repo)
+    private val rag = RagRepository(repo)
+
+    // #18: one lifecycle job per repo, so status/events/cancel/canResume are reachable from the facade.
+    private val trainingJobs = TrainingJobManager(repo)
+
+    private val engine = capabilities.engine
+
+    // #19: once merge()/mergeAtEnd has run, generation loads the merged external initializers (#23).
+    private var mergedWeightsLoaded = false
+
+    // #19: the validated PEFT selection to apply on the next train() (rank/alpha overrides).
+    private var appliedPeft: PeftConfig? = null
+
+    /** #33: opened on the first `classify`, because most packages never call it. */
+    private var classifier: ClassifierSession? = null
+
+    override suspend fun applyPeft(peft: PeftConfig) {
+        if (!repo.isTrainingAvailable) {
+            throw MissingArtifactException(
+                ModelFeature.Training,
+                File(modelDir, "train/training_config.json").absolutePath,
+            )
+        }
+        val cfgFile = File(modelDir, "train/training_config.json")
+        val pkg = if (cfgFile.isFile) PeftSupport.packageTaxonomy(cfgFile.readText()) else null
+        PeftSupport.validate(peft, pkg) // throws PeftMismatchException on a mismatch
+        appliedPeft = peft
+    }
+
+    override suspend fun train(
+        dataset: DatasetConfig,
+        config: TrainConfig,
+        callback: TrainCallback?,
+    ): TrainingResult {
+        var last: TrainingProgress? = null
+        val adapter =
+            object : TrainingCallback {
+                override fun onModelLoadStart() = callback?.onModelLoadStart() ?: Unit
+
+                override fun onModelLoadEnd() = callback?.onModelLoadEnd() ?: Unit
+
+                override fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch: Int) =
+                    callback?.onDataLoadEnd(totalSteps, stepsPerEpoch) ?: Unit
+
+                override fun onStepEnd(trainingProgress: TrainingProgress) {
+                    last = trainingProgress
+                    callback?.onStepEnd(trainingProgress.toPublic())
+                }
+
+                override fun onEpochEnd(trainingProgress: TrainingProgress) {
+                    last = trainingProgress
+                    callback?.onEpochEnd(trainingProgress.toPublic())
+                }
+
+                override fun onMergeStart(trainingProgress: TrainingProgress) =
+                    callback?.onMergeStart(trainingProgress.toPublic()) ?: Unit
+
+                override fun onMergeEnd(trainingProgress: TrainingProgress) {
+                    mergedWeightsLoaded = true
+                    callback?.onMergeEnd(trainingProgress.toPublic())
+                }
+
+                override fun onCompletion(trainingProgress: TrainingProgress) {
+                    last = trainingProgress
+                    callback?.onCompletion(trainingProgress.toPublic())
+                }
+
+                override fun onError(error: Throwable) = callback?.onError(error) ?: Unit
+            }
+
+        val ortConfig = config.toOrt(repo.trainingConfig).copy(
+            datasetOptions = dataset.toOrt(),
+            // The caller supplies the data, so the caller names its preprocessor; fall back to
+            // whatever the package declared.
+            // Resolved (and rejected) here rather than in the trainer's constructor, which runs on
+            // LLMRepository's scope where a throw kills the process instead of reaching the caller.
+            taskName = Tasks.resolve(dataset.task, repo.trainingConfig.taskName),
+        )
+        training.performTraining(ortConfig, adapter)
+        if (config.mergeAtEnd) mergedWeightsLoaded = true
+
+        val p = last
+        return TrainingResult(
+            finalStep = p?.currentStep ?: 0,
+            finalEpoch = p?.currentEpoch ?: 0,
+            finalLoss = p?.totalLoss ?: 0f,
+            totalDurationMs = p?.totalDurationMs ?: 0L,
+            merged = config.mergeAtEnd,
+            // #18: these two were declared on TrainingResult and never populated — the checkpoint
+            // projection is exactly what TrainingJob already reads from training_state.json.
+            checkpoint = trainingJob().checkpoint(),
+            // Null unless trainingConfig.profileMetrics was on — see ORTTrainerNative.lastSummary.
+            summary = repo.ortTrainerNative?.lastSummary?.toPublic(),
+        )
+    }
+
+    /** #18 [ModelSession.trainingJob]. */
+    override fun trainingJob(): TrainingJob = trainingJobs.getOrCreate(modelDir.name)
+
+    override suspend fun merge(): MergeResult {
+        training.endTraining(saveModel = true)
+        mergedWeightsLoaded = true
+        return MergeResult(merged = true, inferencePackagePath = inferencePackagePath)
+    }
+
+    override suspend fun generate(
+        prompt: String,
+        config: GenerationConfig,
+        callback: GenerateCallback?,
+    ): GenerationResult {
+        val done = CompletableDeferred<InferenceProgress?>()
+        val text = StringBuilder()
+        var tokens = 0
+        val adapter =
+            object : GenerationCallback {
+                override fun onStartGeneration(inferenceProgress: InferenceProgress) {
+                    callback?.onStartGeneration(inferenceProgress.toPublic())
+                }
+
+                override fun onPartialResult(inferenceProgress: InferenceProgress) {
+                    text.append(inferenceProgress.token)
+                    tokens = inferenceProgress.totalDecodedTokens
+                    callback?.onPartialResult(inferenceProgress.toPublic())
+                }
+
+                override fun onCompletion(inferenceProgress: InferenceProgress) {
+                    callback?.onCompletion(inferenceProgress.toPublic())
+                    if (!done.isCompleted) done.complete(inferenceProgress)
+                }
+
+                override fun onError(error: Throwable) {
+                    callback?.onError(error)
+                    if (!done.isCompleted) done.completeExceptionally(error)
+                }
+            }
+        inference.generate(prompt, config.toOrt(engine, mergedWeightsLoaded), adapter)
+        val finalProgress = done.await()
+        return GenerationResult(
+            text = text.toString(),
+            tokenCount = finalProgress?.totalDecodedTokens ?: tokens,
+            generationTimeMs = finalProgress?.generationTimeMs ?: 0L,
+            avgTokensPerSecond = finalProgress?.avgTokensPerSecond ?: 0.0,
+            promptTokenCount = finalProgress?.promptTokenCount ?: 0,
+            contextLimit = finalProgress?.contextLimit ?: 0,
+        )
+    }
+
+    override suspend fun retrieve(
+        query: String,
+        config: RagConfig,
+        callback: RetrieveCallback?,
+    ): RetrievalResult {
+        var result: RagResult? = null
+        val adapter =
+            object : RagCallback {
+                override fun onQueryResults(queryResult: RagResult) {
+                    result = queryResult
+                    callback?.onQueryResults(queryResult.toPublic())
+                }
+
+                override fun onQueryEnd() = callback?.onQueryEnd() ?: Unit
+
+                override fun onError(error: Throwable) = callback?.onError(error) ?: Unit
+            }
+        rag.initialize(config.toOrt(repo.ragConfig), adapter)
+        rag.query(query, ragCallback = adapter)
+        return result?.toPublic() ?: RetrievalResult()
+    }
+
+    override suspend fun ingest(
+        path: String,
+        config: RagConfig,
+        progress: IngestionProgress?,
+    ): IngestResult = IngestResult(chunkCount = rag.ingest(path, config.toOrt(repo.ragConfig), progress))
+
+    /**
+     * #33: run the classification head.
+     *
+     * Guarded on [RuntimeCapabilities.supportsClassification] rather than attempted and allowed to
+     * fail somewhere in the runtime: a decoder asked to classify would run its graph and hand back
+     * `vocabSize` floats read as labels, which is not an error anywhere — just a confident nonsense
+     * answer. Fail at the door instead.
+     */
+    override suspend fun classify(
+        text: String,
+        device: com.martinkorelic.mobiletransformers.config.DeviceConfig,
+        topK: Int,
+    ): com.martinkorelic.mobiletransformers.runtime.ClassificationResult {
+        if (!capabilities.isClassifier) {
+            throw NotImplementedFeatureException(
+                "this package's task is '${capabilities.task.declaredTask ?: "undeclared"}', not " +
+                    "text-classification — classify() would read generation logits as class scores",
+            )
+        }
+        val session = classifier ?: ClassifierSession(
+            context = repo.applicationContext,
+            cacheDir = modelDir.parent ?: modelDir.absolutePath,
+            sanitizedRepoId = modelDir.name,
+            task = capabilities.task,
+        ).also { classifier = it }
+        return session.classify(text, device, topK)
+    }
+
+    override suspend fun generateWithRag(
+        query: String,
+        rag: RagConfig,
+        generation: GenerationConfig,
+        promptStrategy: PromptStrategy,
+        callback: GenerateCallback?,
+        retrieveCallback: RetrieveCallback?,
+    ): GroundedResult {
+        // #27: reuse the existing retrieve + generate legs — retrieve → assemble → generate.
+        // The retrieve callback is forwarded for the same reason the generate one is: the matches
+        // exist here, long before the answer does, and a caller that only learns them from the return
+        // value cannot show what it retrieved until the generation it is waiting on has finished.
+        val retrieval = retrieve(query, rag, retrieveCallback)
+        val prompt = PromptAssembler.assemble(query, retrieval.matches, promptStrategy)
+        // Forwarded, so the grounded answer streams exactly like an ungrounded one. It was hardcoded
+        // to `null` here, which is the whole reason a grounded turn showed nothing while it ran.
+        val generated = generate(prompt, generation, callback)
+        return GroundedResult(
+            text = generated.text,
+            matches = retrieval.matches,
+            prompt = prompt,
+            generation = generated,
+        )
+    }
+
+    override suspend fun pushAdapter(hubConfig: HubConfig, repoId: String): PushResult {
+        // #22: default-off, privacy-gated. When disabled (default), fail closed pointing at the desktop
+        // path. When enabled, prepare + validate the card (pure); the authenticated Hub POST is the device
+        // leg (still NotImplemented here). Product path is device -> desktop -> Python `push-adapter`.
+        if (!AdapterUploader.uploadEnabled()) throw AdapterUploadDisabledException()
+        val cacheDir = modelDir.parentFile
+            ?: throw NotImplementedFeatureException("pushAdapter (no cache dir)")
+        AdapterUploader.prepareCard(cacheDir, repoId) // builds metadata + gate + card; fails closed
+        throw NotImplementedFeatureException("pushAdapter upload (device leg)")
+    }
+
+    override suspend fun federatedRound(
+        config: FederatedConfig,
+        globalRecord: ByteArray?,
+        roundNumber: Int,
+        localTraining: LocalRoundTraining,
+        metrics: Map<String, Double>,
+        train: Boolean,
+    ): FederatedRoundResult {
+        // Fail closed, and say which precondition is missing: consent, TLS, auth and the default-off
+        // BuildConfig.FEDERATION_ENABLED flag are all checked here, BEFORE a native handle is touched
+        // or a single tensor is read.
+        config.requireRoundIsPermitted()
+
+        val trainer = repo.ortTrainerNative
+            ?: throw MissingArtifactException(
+                "a federated round needs a live training session; this package has no train/ stage " +
+                    "(installed features: ${capabilities.availableFeatures})",
+            )
+        val inferenceDir = inferencePackagePath
+            ?: PackagePaths.forCache(modelDir.parentFile, modelDir.name).inference.absolutePath
+        val handoffFile = File(inferenceDir, WeightHandoffMap.FILENAME)
+        if (!handoffFile.isFile) {
+            throw MissingArtifactException(
+                "federated rounds are keyed by ${WeightHandoffMap.FILENAME}, which is absent from " +
+                    "$inferenceDir — it is the authority on adapter tensor names and shapes for both " +
+                    "the device and the gateway, so a round without it would upload tensors neither " +
+                    "side can identify",
+            )
+        }
+        val handoff = WeightHandoffMap.load(handoffFile)
+
+        return FederatedTrainingRepository.forSession(
+            config = config,
+            handoff = handoff,
+            trainer = trainer,
+            localTraining = localTraining,
+            baseModelId = modelDir.name,
+            packageRevision = handoff.schemaVersion,
+        ).runRound(
+            globalRecord = globalRecord,
+            roundNumber = roundNumber,
+            metrics = metrics,
+            train = train,
+        )
+    }
+
+    override fun close() {
+        repo.resetInference()
+        repo.resetTraining()
+        // A classification session is a second native ORT session over the same package; leaking it
+        // would hold the graph's memory for the whole process, which on a phone is the difference
+        // between unloading a model and appearing to.
+        classifier?.close()
+        classifier = null
+    }
+}
+
+private fun TrainingProgress.toPublic(): TrainProgress =
+    TrainProgress(
+        currentStep = currentStep,
+        currentEpoch = currentEpoch,
+        totalLoss = totalLoss,
+        epochLoss = epochLoss,
+        stepLoss = stepLoss,
+        learningRate = learningRate,
+        stepDurationMs = stepDurationMs,
+        epochDurationMs = epochDurationMs,
+        totalDurationMs = totalDurationMs,
+        isCompleted = isCompleted,
+    )
+
+private fun InferenceProgress.toPublic(): GenerateProgress =
+    GenerateProgress(
+        token = token,
+        tokenId = tokenId,
+        totalDecodedTokens = totalDecodedTokens,
+        prefillTimeMs = prefillTimeMs,
+        timeToLoadModelMs = timeToLoadModelMs,
+        generationTimeMs = generationTimeMs,
+        avgTokensPerSecond = avgTokensPerSecond,
+        isCompleted = isCompleted,
+        promptTokenCount = promptTokenCount,
+        contextLimit = contextLimit,
+    )
+
+private fun RagResult.toPublic(): RetrievalResult =
+    RetrievalResult(
+        // Title and id carried across, not dropped: the store has held both since ingestion, and
+        // without them a caller can show a passage but not say which file it came from.
+        matches = documents?.map {
+            RetrievalMatch(
+                text = it.document.text,
+                score = it.score,
+                title = it.document.title,
+                chunkId = it.document.id,
+            )
+        } ?: emptyList(),
+        queryTimeMs = queryTimeMs,
+    )
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/CacheIndex.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/CacheIndex.kt
new file mode 100644
index 0000000..11225ef
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/CacheIndex.kt
@@ -0,0 +1,67 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+
+/** Enumerates installed model packages in the cache dir, tolerating legacy (manifest-less) dirs (#13). */
+object CacheIndex {
+    data class InstalledPackage(
+        val sanitizedRepoId: String,
+        val dir: File,
+        /**
+         * The repo id this package was installed from — **the value to pass to `fromPretrained`**.
+         *
+         * Distinct from [baseModelId], which names the upstream model the package was exported from.
+         * The two are routinely different (`mobiletransformers/functiongemma-270m-it` is built from
+         * `google/functiongemma-270m-it`), and loading by the wrong one resolves to a cache directory
+         * that does not exist. Comes from [InstallRecord]; for a legacy or hand-pushed package with no
+         * record, from un-sanitizing the directory name.
+         */
+        val repoId: String,
+        /** The upstream model this package was exported from, per the manifest. Never a load key. */
+        val baseModelId: String?,
+        val variantIds: List<String>,
+        val sizeBytes: Long,
+        val hasManifest: Boolean,
+        /** The variant materialized here, when an [InstallRecord] says so. */
+        val installedVariantId: String? = null,
+        /** Feature groups requested when this package was pulled, when recorded. */
+        val requestedFeatures: List<String> = emptyList(),
+        /** When this package was installed, or `0` when unrecorded. */
+        val installedAtEpochMs: Long = 0L,
+    )
+
+    fun list(cacheDir: File): List<InstalledPackage> {
+        val out = mutableListOf<InstalledPackage>()
+        val children = cacheDir.listFiles() ?: return out
+        for (dir in children.sortedBy { it.name }) {
+            if (!dir.isDirectory || dir.name.startsWith(".")) continue
+            val record = InstallRecord.read(dir)
+            val manifestFile = File(dir, PackageFormat.MANIFEST_FILENAME)
+            val manifest =
+                if (manifestFile.isFile) {
+                    runCatching { MobileTransformersManifest.load(manifestFile) }.getOrNull()
+                } else {
+                    null
+                }
+            out.add(
+                InstalledPackage(
+                    sanitizedRepoId = dir.name,
+                    dir = dir,
+                    repoId = record?.repoId ?: InstallRecord.unsanitize(dir.name),
+                    baseModelId = manifest?.baseModelId,
+                    variantIds = manifest?.variants?.map { it.id } ?: emptyList(),
+                    sizeBytes = dirSize(dir),
+                    // Legacy layout: no manifest, but still a discoverable model dir.
+                    hasManifest = manifestFile.isFile,
+                    installedVariantId = record?.variantId?.takeIf { it.isNotBlank() },
+                    requestedFeatures = record?.features ?: emptyList(),
+                    installedAtEpochMs = record?.installedAtEpochMs ?: 0L,
+                ),
+            )
+        }
+        return out
+    }
+
+    private fun dirSize(dir: File): Long =
+        dir.walkTopDown().filter { it.isFile }.sumOf { it.length() }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ChecksumVerifier.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ChecksumVerifier.kt
new file mode 100644
index 0000000..d25ca51
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ChecksumVerifier.kt
@@ -0,0 +1,39 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+import java.security.MessageDigest
+
+/** SHA-256 integrity verification of package files against a `{relativePath: sha256hex}` map (#13). */
+object ChecksumVerifier {
+    fun sha256(file: File): String {
+        val md = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buf = ByteArray(1 shl 20)
+            while (true) {
+                val n = input.read(buf)
+                if (n < 0) break
+                md.update(buf, 0, n)
+            }
+        }
+        return md.digest().joinToString("") { "%02x".format(it) }
+    }
+
+    /** True iff every entry in [checksums] exists under [baseDir] and hashes to the expected digest. */
+    fun verify(baseDir: File, checksums: Map<String, String>): Boolean {
+        for ((rel, expected) in checksums) {
+            val f = File(baseDir, rel)
+            if (!f.isFile || sha256(f) != expected) return false
+        }
+        return true
+    }
+
+    /** Verify the [requiredFiles] subset of a manifest's `sha256` map; returns the first bad path or null. */
+    fun firstMismatch(baseDir: File, manifest: MobileTransformersManifest): String? {
+        for (rel in manifest.requiredFiles) {
+            val expected = manifest.sha256[rel] ?: continue
+            val f = File(baseDir, rel)
+            if (!f.isFile || sha256(f) != expected) return rel
+        }
+        return null
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/DeviceCapabilities.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/DeviceCapabilities.kt
new file mode 100644
index 0000000..48a9ed6
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/DeviceCapabilities.kt
@@ -0,0 +1,50 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Build
+
+/**
+ * What this device can run, for `VariantSelector` to select against before a byte is downloaded.
+ *
+ * Shared rather than duplicated because omitting it is silent and expensive. `HubDownloader` falls
+ * back to `manifest.defaultVariant` when `abis` is empty — "select on device capability" degrades to
+ * "take whatever the publisher listed first" — so an incompatible variant downloads happily and only
+ * fails at load, after the user has waited for a multi-gigabyte transfer.
+ *
+ * That is exactly what `PackageDownloadWorker` did: `MobileTransformers.fromPretrained` passed both
+ * values and the worker passed neither, so the two download paths disagreed about which variant this
+ * phone can run. One copy, called by both.
+ */
+internal object DeviceCapabilities {
+
+    /** ABIs this device supports, most-preferred first. Empty only on a device that reports none. */
+    fun abis(): List<String> = Build.SUPPORTED_ABIS?.toList() ?: emptyList()
+
+    /**
+     * Total physical RAM in MB, or null when it cannot be read.
+     *
+     * Null is a real answer and must stay distinguishable from zero: `VariantSelector` treats null as
+     * "unknown, do not filter on memory", whereas 0 would reject every variant that declares a
+     * minimum.
+     */
+    fun totalMemoryMb(context: Context): Int? =
+        runCatching {
+            val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+            val info = ActivityManager.MemoryInfo().also { am.getMemoryInfo(it) }
+            (info.totalMem / (1024L * 1024L)).toInt()
+        }.getOrNull()
+
+    /**
+     * The download groups a feature set implies — the wire names `HubDownloader` plans files from.
+     *
+     * `inference` is unconditional: every package has one, and a pull that omitted it would install a
+     * training stage with nothing to train against. `GenAI`/`ManualInference` select an engine over
+     * the shared package rather than adding a group, which is why they appear nowhere here.
+     */
+    fun downloadGroups(features: Set<ModelFeature>): Set<String> = buildSet {
+        add("inference")
+        if (ModelFeature.Training in features) add("train")
+        if (ModelFeature.Rag in features || ModelFeature.Embedding in features) add("rag")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/InstallRecord.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/InstallRecord.kt
new file mode 100644
index 0000000..31f4c96
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/InstallRecord.kt
@@ -0,0 +1,67 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
+import java.io.File
+
+/**
+ * What the cache knows about *how* an installed package got there.
+ *
+ * ### Why this exists
+ *
+ * The cache directory name is `sanitizeRepoId(repoId)`, and nothing recorded the `repoId` that
+ * produced it. [CacheIndex] therefore had only two candidates to offer a caller that wanted to load an
+ * installed package: the directory name, or the manifest's [MobileTransformersManifest.baseModelId] —
+ * and **`baseModelId` is a different thing**. It names the upstream model the package was exported
+ * *from* (`google/functiongemma-270m-it`), not the repo it was pulled *from*
+ * (`mobiletransformers/functiongemma-270m-it`).
+ *
+ * The showcase app's Models screen picked `baseModelId`, so tapping Load on a package that was
+ * visibly installed sanitized to a *different* directory, found nothing there, tried to pull the base
+ * model from the Hub, and reported `ModelNotInstalledException` — "not installed at
+ * /data/user/0/…/google__functiongemma-270m-it" for a package sitting one directory over. There was no
+ * way to get the right answer from what the cache stored, which is what this file changes.
+ *
+ * Written **inside the staging tree before publish**, so it lands atomically with the package it
+ * describes: there is no window in which an installed tree has no record, and a rolled-back install
+ * takes its record with it.
+ */
+data class InstallRecord(
+    /** The repo id the package was installed from — the argument to `fromPretrained`. */
+    @SerializedName("repoId") val repoId: String = "",
+    /** The variant materialized into the flat cache layout. */
+    @SerializedName("variantId") val variantId: String = "",
+    /** Feature groups requested at download time (`inference`, `train`, `rag`, `genai`). */
+    @SerializedName("features") val features: List<String> = emptyList(),
+    @SerializedName("installedAtEpochMs") val installedAtEpochMs: Long = 0L,
+) {
+    companion object {
+        const val FILENAME = "install_record.json"
+
+        private val gson = Gson()
+
+        fun write(dir: File, record: InstallRecord) {
+            File(dir, FILENAME).writeText(gson.toJson(record), Charsets.UTF_8)
+        }
+
+        /** The record in [dir], or `null` for a legacy or hand-pushed package that has none. */
+        fun read(dir: File): InstallRecord? {
+            val file = File(dir, FILENAME)
+            if (!file.isFile) return null
+            return runCatching { gson.fromJson(file.readText(Charsets.UTF_8), InstallRecord::class.java) }
+                .getOrNull()
+                ?.takeIf { it.repoId.isNotBlank() }
+        }
+
+        /**
+         * Best-effort inverse of [PackageFormat.sanitizeRepoId], for a package installed before this
+         * record existed or pushed by hand with `scripts/device_package.sh`.
+         *
+         * Only `'/' -> "__"` is reversible: every other unsafe character collapses to a single `'_'`,
+         * which is lossy by design. That is enough for a Hub id, whose owner and name are both drawn
+         * from `[A-Za-z0-9._-]`. It is a fallback, not the source of truth — [read] is, and a package
+         * installed by this SDK always has one.
+         */
+        fun unsanitize(sanitizedRepoId: String): String = sanitizedRepoId.replace("__", "/")
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ManifestValidator.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ManifestValidator.kt
new file mode 100644
index 0000000..c36206d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ManifestValidator.kt
@@ -0,0 +1,46 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+
+/**
+ * Validates a [MobileTransformersManifest] against a materialized package directory (#13). Fails closed
+ * with [ManifestException]. Mirrors the Python `artifacts.manifest.MobileTransformersManifest.validate`.
+ */
+object ManifestValidator {
+    fun validate(manifest: MobileTransformersManifest, packageDir: File) {
+        if (!PackageFormat.checkCompat(
+                manifest.schemaVersion,
+                manifest.minReaderVersion,
+                PackageFormat.MANIFEST_READER_VERSION,
+            )
+        ) {
+            throw ManifestException(
+                "manifest schema ${manifest.schemaVersion} (minReader ${manifest.minReaderVersion}) " +
+                    "incompatible with reader ${PackageFormat.MANIFEST_READER_VERSION}",
+            )
+        }
+        if (manifest.variants.isEmpty()) throw ManifestException("manifest declares no variants")
+        if (manifest.variant(manifest.defaultVariant) == null) {
+            throw ManifestException("defaultVariant '${manifest.defaultVariant}' not among variants")
+        }
+        for (v in manifest.variants) {
+            val features = v.features.toSet()
+            for ((feature, path) in listOf("train" to "train", "inference" to "inference", "rag" to "embedding")) {
+                if (feature in features && !v.paths.containsKey(path)) {
+                    throw ManifestException("variant '${v.id}' claims feature '$feature' but has no '$path' path")
+                }
+            }
+            if (v.weightHandoff.isEmpty()) {
+                throw ManifestException("variant '${v.id}' has no weightHandoff pointer")
+            }
+            if (!File(packageDir, v.weightHandoff).isFile) {
+                throw ManifestException("variant '${v.id}' weightHandoff does not resolve: ${v.weightHandoff}")
+            }
+        }
+        for (rel in manifest.requiredFiles) {
+            if (!File(packageDir, rel).exists()) {
+                throw ManifestException("requiredFile missing on disk: $rel")
+            }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/MobileTransformersManifest.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/MobileTransformersManifest.kt
new file mode 100644
index 0000000..63e7a75
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/MobileTransformersManifest.kt
@@ -0,0 +1,97 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
+import java.io.File
+
+/**
+ * Kotlin mirror of `mobiletransformers_manifest.json` (#14 schema, #13 consumer).
+ *
+ * Gson ignores unknown fields, so additive minor schema bumps are non-breaking (F1). The schema/field
+ * list is owned by the Python side (`hub/package_format.py`); this is the read model the cache bridge
+ * (validator / selector / installer) consumes.
+ */
+data class MobileTransformersManifest(
+    @SerializedName("schemaVersion") val schemaVersion: String = "",
+    @SerializedName("minReaderVersion") val minReaderVersion: String = "",
+    @SerializedName("baseModelId") val baseModelId: String = "",
+    @SerializedName("defaultVariant") val defaultVariant: String = "",
+    @SerializedName("variants") val variants: List<Variant> = emptyList(),
+    @SerializedName("requiredFiles") val requiredFiles: List<String> = emptyList(),
+    @SerializedName("sha256") val sha256: Map<String, String> = emptyMap(),
+    @SerializedName("fileSizes") val fileSizes: Map<String, Long> = emptyMap(),
+    /**
+     * Every parameter the training graph materialises — not the trainable subset.
+     *
+     * The exporter has written both since the training stage existed and the device read neither.
+     * It is what [com.martinkorelic.mobiletransformers.runtime.MemoryHeadroom] estimates from: for a
+     * LoRA export the two differ by three orders of magnitude (268,098,176 against 368,640), and
+     * sizing memory from the trainable count would under-estimate by the whole model.
+     */
+    @SerializedName("trainingParameterCount") val trainingParameterCount: Long = 0L,
+    @SerializedName("trainableParameterCount") val trainableParameterCount: Long = 0L,
+    /**
+ * The PEFT method(s) this package was exported for — `lora`, `lora-xs`, `mars`, …
+ *
+ * Written by the exporter since the training stage existed and read by nothing on the device, so
+ * an app could not tell a MARS package from a LoRA one. That matters most for MARS, which is this
+ * project's own contribution: a user running the fine-tuning demo had no way to see *which*
+ * technique they were watching.
+ */
+    @SerializedName("peftMethods") val peftMethods: List<String> = emptyList(),
+    @SerializedName("downloadPlan") val downloadPlan: Map<String, Map<String, List<String>>> = emptyMap(),
+    @SerializedName("weightHandoff") val weightHandoff: String = "",
+) {
+    data class Variant(
+        @SerializedName("id") val id: String = "",
+        @SerializedName("executionProvider") val executionProvider: String = "",
+        @SerializedName("quantization") val quantization: String = "",
+        @SerializedName("supportedEngines") val supportedEngines: List<String> = emptyList(),
+        @SerializedName("abi") val abi: List<String>? = null,
+        @SerializedName("features") val features: List<String> = emptyList(),
+        @SerializedName("minimumAndroidApi") val minimumAndroidApi: Int? = null,
+        @SerializedName("recommendedDeviceMemoryMb") val recommendedDeviceMemoryMb: Int? = null,
+        @SerializedName("weightHandoff") val weightHandoff: String = "",
+        @SerializedName("paths") val paths: Map<String, String> = emptyMap(),
+    )
+
+    fun variant(id: String): Variant? = variants.firstOrNull { it.id == id }
+
+    /**
+     * The engines the installed variant declares, for [ModelRuntimeFactory.create]'s selection.
+     *
+     * `ModelRuntimeFactory.create` used to be called with a hard-coded `setOf("native","genai")` and a
+     * comment saying the set "would come from the manifest variant" — so a native-only variant
+     * was still offered to GenAI, and the manifest field this class has always parsed was never read.
+     *
+     * A package that declares no engines at all (an older export) yields `null`, and the caller keeps
+     * the permissive default: an unknown declaration must not become a *narrower* one, or upgrading the
+     * SDK would break packages that work today.
+     */
+    fun supportedEnginesFor(variantId: String? = null): Set<String>? {
+        val chosen = variantId?.let { variant(it) }
+            ?: variants.singleOrNull()
+            ?: variant(defaultVariant)
+            ?: return null
+        return chosen.supportedEngines.takeIf { it.isNotEmpty() }?.toSet()
+    }
+
+    companion object {
+        private val gson = Gson()
+
+        fun parse(json: String): MobileTransformersManifest =
+            gson.fromJson(json, MobileTransformersManifest::class.java)
+                ?: throw ManifestException("manifest JSON parsed to null")
+
+        fun load(file: File): MobileTransformersManifest {
+            if (!file.isFile) throw ManifestException("manifest not found: ${file.path}")
+            return parse(file.readText(Charsets.UTF_8))
+        }
+    }
+}
+
+/** Parallel to the Python `ManifestError`. */
+class ManifestException(message: String) : Exception(message)
+
+/** Parallel to the Python `NoCompatibleVariant`. */
+class NoCompatibleVariantException(message: String) : Exception(message)
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelFeature.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelFeature.kt
new file mode 100644
index 0000000..8fa7486
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelFeature.kt
@@ -0,0 +1,26 @@
+package com.martinkorelic.mobiletransformers.packages
+
+/**
+ * Feature groups a caller can request from a package (#17).
+ *
+ * Critical semantics: [GenAI] and [ManualInference] are
+ * **engine selectors over the same shared package**, not separate downloadable feature groups. The package
+ * on disk (`train/`, `inference/`, `embedding/`) is consumable by both the Native ORT engine and the GenAI
+ * engine — requesting [GenAI]/[ManualInference] sets/validates the [com.martinkorelic.mobiletransformers.runtime.InferenceEngine],
+ * it does not trigger a different download. [Inference], [Training], [Rag], [Embedding], [Adapter] are the
+ * genuine feature groups.
+ */
+enum class ModelFeature {
+    Inference,
+    Training,
+    Rag,
+    Embedding,
+    GenAI,
+    ManualInference,
+    Adapter,
+    ;
+
+    /** True when this value only selects an engine over the shared package (no separate download). */
+    val isEngineSelector: Boolean
+        get() = this == GenAI || this == ManualInference
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelPackageInstaller.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelPackageInstaller.kt
new file mode 100644
index 0000000..7b0b14b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ModelPackageInstaller.kt
@@ -0,0 +1,122 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import java.io.File
+
+/**
+ * Materializes a downloaded/staged package into the conventional cache layout `LLMRepository` already
+ * probes — `<cacheDir>/<sanitizedRepoId>/{train,inference,embedding,tokenizer}` + manifest + checksums —
+ * then publishes via a rename-aside → rename-in → delete-old sequence so a failed or interrupted
+ * install never destroys the package already on disk (#13 "cache bridge" / #21). Does not change
+ * `LLMRepository`.
+ */
+object ModelPackageInstaller {
+    data class Installed(val repoDir: File, val sanitizedRepoId: String)
+
+    /**
+     * @param stagedPackageDir a verified package tree in #14 Hub layout (variants/, shared/, manifest).
+     * @param cacheDir the app cache root.
+     * @param repoId the HF repo id (sanitized internally).
+     * @param variantId the selected variant to materialize.
+     * @param consumeSource move the staged files instead of copying them, destroying
+     *   [stagedPackageDir] in the process. Only pass `true` when the caller OWNS a throwaway staging
+     *   tree — [com.martinkorelic.mobiletransformers.hub.HubDownloader] does, and for a real package
+     *   the copy it avoids is over a gigabyte. Defaults to `false` because the staged tree is not
+     *   generally the installer's to destroy: the JVM suite installs the same checked-in
+     *   `tiny_package` fixture twice, and a hand-provisioned directory is a legitimate source.
+     * @param features the feature groups this install was pulled with, recorded for display. Purely
+     *   descriptive — what a package can actually do is detected from the artifacts on disk.
+     */
+    @JvmOverloads
+    fun install(
+        stagedPackageDir: File,
+        cacheDir: File,
+        repoId: String,
+        variantId: String,
+        consumeSource: Boolean = false,
+        features: Set<String> = emptySet(),
+    ): Installed {
+        val sanitized = PackageFormat.sanitizeRepoId(repoId)
+        val stagingRoot = File(cacheDir, ".staging/$sanitized").apply { deleteRecursively(); mkdirs() }
+        val variantRoot = File(stagedPackageDir, "variants/$variantId")
+
+        for (stage in PackageFormat.VARIANT_SUBDIRS) {
+            val src = File(variantRoot, stage)
+            if (src.isDirectory) materialize(src, File(stagingRoot, stage), consumeSource)
+        }
+        val tokenizer = File(stagedPackageDir, "shared/tokenizer")
+        if (tokenizer.isDirectory) materialize(tokenizer, File(stagingRoot, "tokenizer"), consumeSource)
+
+        for (name in listOf(PackageFormat.MANIFEST_FILENAME, "variants/$variantId/checksums.json")) {
+            val src = File(stagedPackageDir, name)
+            if (src.isFile) src.copyTo(File(stagingRoot, File(name).name), overwrite = true)
+        }
+
+        // Written into the staging tree, so the record is published by the same rename that publishes
+        // the package: an installed tree is never missing its record, and a rolled-back install does
+        // not leave one behind describing a package that is not there. Without it the cache cannot
+        // answer "which repo id installed this?" — see [InstallRecord] for what that broke.
+        InstallRecord.write(
+            stagingRoot,
+            InstallRecord(
+                repoId = repoId,
+                variantId = variantId,
+                features = features.sorted(),
+                installedAtEpochMs = System.currentTimeMillis(),
+            ),
+        )
+
+        // #21 crash safety: rename the OLD install aside first, put the new one in place, and only
+        // then delete the old. The previous order deleted the live package before the new tree
+        // existed, so a kill / disk-full / failed rename between the two left the user with no model
+        // at all — including any locally trained train/checkpoint + training_state.json.
+        val target = File(cacheDir, sanitized)
+        val retired = File(cacheDir, ".retired-$sanitized-${System.nanoTime()}")
+        val hadPrevious = target.exists() && target.renameTo(retired)
+        if (target.exists() && !hadPrevious) {
+            // Could not move the old tree aside; do not destroy it — fail with it still intact.
+            stagingRoot.deleteRecursively()
+            throw MissingArtifactException(
+                "cannot install $repoId: the existing package at ${target.path} could not be moved aside",
+            )
+        }
+
+        val published =
+            stagingRoot.renameTo(target) ||
+                runCatching {
+                    // Fallback for cross-mount rename failure: copy + clean.
+                    stagingRoot.copyRecursively(target, overwrite = true)
+                    stagingRoot.deleteRecursively()
+                    true
+                }.getOrDefault(false)
+
+        if (!published) {
+            // Roll the previous install back so a failed update is a no-op, not data loss.
+            target.deleteRecursively()
+            if (hadPrevious) retired.renameTo(target)
+            throw MissingArtifactException("failed to publish the package for $repoId at ${target.path}")
+        }
+
+        if (hadPrevious) retired.deleteRecursively()
+        return Installed(target, sanitized)
+    }
+
+    /**
+     * Put [src]'s contents at [dest], moving when [consume] allows it and copying otherwise.
+     *
+     * When the caller owns the staged tree this is a directory-entry update rather than bytes copied.
+     * The unconditional `copyRecursively` it replaces wrote a real package a second time, which put
+     * peak usage at roughly **three** simultaneous copies of a 1.3 GB model on a phone (download
+     * staging + install staging + the published tree) and made install time scale with model size for
+     * no reason.
+     *
+     * The copy stays as the fallback even when [consume] is set: a rename genuinely can fail when the
+     * staged tree is on a different mount, and the caller — not this function — chooses where staging
+     * lives.
+     */
+    private fun materialize(src: File, dest: File, consume: Boolean) {
+        dest.parentFile?.mkdirs()
+        if (consume && src.renameTo(dest)) return
+        src.copyRecursively(dest, overwrite = true)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageFormat.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageFormat.kt
new file mode 100644
index 0000000..e68d873
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageFormat.kt
@@ -0,0 +1,57 @@
+package com.martinkorelic.mobiletransformers.packages
+
+/**
+ * Cross-language package-format constants + primitives (#14/#13). [sanitizeRepoId] and [checkCompat]
+ * are mirrored byte-for-byte with the Python side (`hub/package_format.py`, `artifacts/versioning.py`);
+ * shared JSON oracles (`sanitize_repo_id_cases.json`, `check_compat_cases.json`) pin the parity.
+ */
+object PackageFormat {
+    const val SCHEMA_VERSION = "1.0"
+    const val MANIFEST_READER_VERSION = "1.0"
+    const val MANIFEST_FILENAME = "mobiletransformers_manifest.json"
+
+    val FEATURE_GROUPS = listOf("core", "inference", "train", "rag", "genai", "checksums")
+    val VARIANT_SUBDIRS = listOf("train", "inference", "embedding")
+
+    private val SAFE = ('a'..'z') + ('A'..'Z') + ('0'..'9') + listOf('.', '_', '-')
+
+    /** '/' -> "__"; any other char not in [A-Za-z0-9._-] -> single '_'; no trim/case-fold/length-cap. */
+    fun sanitizeRepoId(repoId: String): String {
+        val sb = StringBuilder(repoId.length + 4)
+        for (ch in repoId) {
+            when {
+                ch == '/' -> sb.append("__")
+                ch in SAFE -> sb.append(ch)
+                else -> sb.append('_')
+            }
+        }
+        return sb.toString()
+    }
+
+    /** (major, minor) parsed from "MAJOR.MINOR"; null if malformed (fail closed). */
+    fun parseVersion(version: String): Pair<Int, Int>? {
+        val dot = version.indexOf('.')
+        if (dot < 0) return null
+        return try {
+            val major = version.substring(0, dot).toInt()
+            val minor = version.substring(dot + 1).toInt()
+            if (major < 0 || minor < 0) null else Pair(major, minor)
+        } catch (e: NumberFormatException) {
+            null
+        }
+    }
+
+    /**
+     * Mirror of `artifacts/versioning.py::check_compat`. Returns true iff a reader at [readerSchema]
+     * may read a doc at [docSchema] whose [docMinReader] floor is satisfied: reject when the doc needs
+     * a newer major SDK, or when the reader is below the doc's minReaderVersion.
+     */
+    fun checkCompat(docSchema: String, docMinReader: String, readerSchema: String): Boolean {
+        val doc = parseVersion(docSchema) ?: return false
+        val req = parseVersion(docMinReader) ?: return false
+        val rdr = parseVersion(readerSchema) ?: return false
+        if (doc.first > rdr.first) return false
+        if (rdr.first < req.first || (rdr.first == req.first && rdr.second < req.second)) return false
+        return true
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackagePaths.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackagePaths.kt
new file mode 100644
index 0000000..560bf54
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackagePaths.kt
@@ -0,0 +1,127 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+
+/**
+ * One resolver for every stage directory. **No consumer builds a stage path by appending a string.**
+ *
+ * Kotlin mirror of `artifacts/package_paths.py`; `cpp/package_paths.h` is the third. All three read the
+ * same package, so all three must agree.
+ *
+ * Two layouts exist and they are NOT the same shape:
+ *
+ * | layout        | shape                                                              |
+ * |---------------|--------------------------------------------------------------------|
+ * | hub package   | `variants/<variantId>/{train,inference,embedding}` + `shared/tokenizer` |
+ * | device cache  | `<cacheDir>/<repoId>/{train,inference,embedding,tokenizer}` (FLAT)  |
+ *
+ * The manifest has always declared the hub layout in `variant.paths`, and on the Kotlin side **nothing
+ * read those values** — `ManifestValidator` only checked that the keys were present, while nine call
+ * sites spelled `"$cacheDir/$repoId/inference"` by hand. `TrainingWorker` carried a comment marking
+ * itself as "one place that knows the cache layout"; this is now that place, for everyone.
+ *
+ * This is the layer-identity problem in a second namespace, and it gets the same structural answer
+ * `layer_name.h` gave the first: one spelling, one owner, a guard to keep it.
+ */
+class PackagePaths private constructor(
+    val root: File,
+    private val stages: Map<String, File>,
+    private val layout: String,
+) {
+
+    companion object {
+        const val STAGE_INFERENCE = "inference"
+        const val STAGE_TRAIN = "train"
+        const val STAGE_EMBEDDING = "embedding"
+        const val STAGE_TOKENIZER = "tokenizer"
+
+        val STAGES = listOf(STAGE_INFERENCE, STAGE_TRAIN, STAGE_EMBEDDING, STAGE_TOKENIZER)
+
+        const val WEIGHT_HANDOFF_FILENAME = "weight_handoff_map.json"
+
+        /** The ObjectBox store's directory name, inside the embedding stage. */
+        const val EMBEDDING_DATABASE_DIRNAME = "database"
+
+        /**
+         * Resolve against a hub package using the variant's DECLARED paths.
+         *
+         * The manifest decides. A variant may legitimately place a stage somewhere this class would not
+         * guess — `tokenizer` already lives at `shared/tokenizer` rather than under `variants/<id>/` —
+         * so re-deriving the convention would quietly ignore the declaration.
+         */
+        @JvmStatic
+        fun forHub(packageDir: File, variant: MobileTransformersManifest.Variant): PackagePaths {
+            val declared = variant.paths
+            require(declared.isNotEmpty()) {
+                "variant '${variant.id}' declares no `paths`; a package built before the manifest " +
+                    "carried per-variant paths cannot be resolved — re-export it."
+            }
+            val stages = declared
+                .filterValues { it.isNotBlank() }
+                .mapValues { (_, rel) -> File(packageDir, rel) }
+            return PackagePaths(packageDir, stages, layout = "hub")
+        }
+
+        /**
+         * Resolve against the FLAT on-device cache layout.
+         *
+         * [repoId] must already be sanitized — that mapping belongs to [PackageFormat.sanitizeRepoId]
+         * and is deliberately not repeated here.
+         */
+        @JvmStatic
+        fun forCache(cacheDir: File, repoId: String): PackagePaths {
+            val base = File(cacheDir, repoId)
+            return PackagePaths(
+                root = base,
+                stages = STAGES.associateWith { File(base, it) },
+                layout = "cache",
+            )
+        }
+
+        /** Convenience for the many call sites that hold the cache dir as a string. */
+        @JvmStatic
+        fun forCache(cacheDir: String, repoId: String): PackagePaths = forCache(File(cacheDir), repoId)
+    }
+
+    /**
+     * The directory for [name], or [IllegalArgumentException] naming what this layout does declare.
+     *
+     * Fails closed rather than handing back a plausible path that does not exist: a silently-wrong
+     * stage surfaces much later as an unrelated-looking IO error — the #35 client's
+     * `INVALID_ARGUMENT : Invalid fd was supplied: -1`, which named no file at all.
+     */
+    fun stage(name: String): File {
+        require(name in STAGES) { "unknown stage '$name'; known stages are $STAGES" }
+        return stages[name] ?: throw IllegalArgumentException(
+            "this $layout package does not declare a '$name' stage (declared: ${stages.keys.sorted()})"
+        )
+    }
+
+    val inference: File get() = stage(STAGE_INFERENCE)
+    val train: File get() = stage(STAGE_TRAIN)
+    val embedding: File get() = stage(STAGE_EMBEDDING)
+    val tokenizer: File get() = stage(STAGE_TOKENIZER)
+
+    /** The handoff map, which lives inside the inference stage in both layouts. */
+    val weightHandoff: File get() = File(inference, WEIGHT_HANDOFF_FILENAME)
+
+    /**
+     * The RAG vector store, INSIDE the embedding stage.
+     *
+     * Not shipped — ingestion creates it — which is why the two RAG sites that used to spell
+     * `"$cacheDir/$repoId/embedding/database"` were carried as guard debt rather than exempted. A
+     * sub-path of a stage still has to start from a resolved stage, or it drifts the same way a stage
+     * does: the retriever's own comment claimed `cacheDir/modelName/database/` while the code wrote
+     * `embedding/database/`.
+     */
+    val embeddingDatabase: File get() = File(embedding, EMBEDDING_DATABASE_DIRNAME)
+
+    /**
+     * The EMBEDDER's tokenizer, inside the embedding stage — a different tokenizer from
+     * [tokenizer], which belongs to the generation model.
+     */
+    val embeddingTokenizer: File get() = File(embedding, STAGE_TOKENIZER)
+
+    /** Whether the layout declares [name] at all (says nothing about what is on disk). */
+    fun has(name: String): Boolean = stages.containsKey(name)
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageTask.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageTask.kt
new file mode 100644
index 0000000..251b47e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/PackageTask.kt
@@ -0,0 +1,98 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
+import com.martinkorelic.mobiletransformers.constants.TaskType
+import java.io.File
+
+/**
+ * What objective a package's inference graph was exported for, read from the side-car the exporter
+ * already writes beside that graph (`inference/optimum_config.json`).
+ *
+ * ### Why the device needs this
+ *
+ * Everything the SDK reported about a package answered "can it train / retrieve / run GenAI" — never
+ * "what *kind* of model is it". So a sequence-classification encoder and a chat decoder were
+ * indistinguishable to any caller, and the showcase app offered a chat box for a BERT classifier that
+ * has no generative head at all. The user could type, press Send, and get a failure from deep inside
+ * the runtime for a thing the package could never have done.
+ *
+ * The exporter has recorded `task` since the inference stage was written; nothing on the device ever
+ * read it.
+ *
+ * ### Why the raw string is kept
+ *
+ * Optimum's task ids are finer-grained than [TaskType]: a decoder exports as
+ * `text-generation-with-past`, which no [TaskType] entry spells. Narrowing that to the enum at read
+ * time would either lose the `-with-past` distinction or fail closed on a perfectly good package, so
+ * the declared string is preserved and [taskType] is offered as the best-effort mapping beside it.
+ */
+data class PackageTask(
+    /** Exactly what the exporter declared, e.g. `text-generation-with-past`. */
+    val declaredTask: String?,
+    /** Model architecture family, e.g. `llama`, `bert`. */
+    val modelType: String?,
+    /** Label names by class index, for a classification head. Empty for every other task. */
+    val id2label: Map<Int, String> = emptyMap(),
+        /**
+ * The precision **measured** in the graph that actually shipped, e.g. `fp32`.
+ *
+ * Distinct from the variant id's claim, and the two genuinely disagree: `cpu-int4` ships an fp32
+ * inference graph on every package published so far, because the inference export does not
+ * quantize. The variant id is a wire contract and deliberately not renamed, so this is the only
+ * honest answer available to a UI — and showing it beats letting a user infer "int4" from a
+ * directory name.
+ */
+    val inferenceGraphPrecision: String? = null,
+) {
+    /** The shared enum entry this task corresponds to, or `null` when it names something finer. */
+    val taskType: TaskType?
+        get() = declaredTask?.let { declared ->
+            TaskType.entries.firstOrNull { declared == it.wire || declared.startsWith("${it.wire}-") }
+        }
+
+    /** A sequence-classification package: it emits logits over labels, never tokens. */
+    val isClassifier: Boolean get() = taskType == TaskType.SEQUENCE_CLASSIFICATION
+
+    /** How many classes the head predicts, when the package names them. */
+    val labelCount: Int get() = id2label.size
+
+    private data class Wire(
+        @SerializedName("task") val task: String? = null,
+        @SerializedName("modelType") val modelType: String? = null,
+        @SerializedName("id2label") val id2label: Map<String, String>? = null,
+        @SerializedName("inferenceGraphPrecision") val inferenceGraphPrecision: String? = null,
+    )
+
+    companion object {
+        const val FILENAME = "optimum_config.json"
+
+        private val gson = Gson()
+
+        /** The empty answer: an older package that declares nothing is not a failure, just unknown. */
+        val UNKNOWN = PackageTask(declaredTask = null, modelType = null)
+
+        /**
+         * Read the side-car from an installed package's `inference/` stage.
+         *
+         * Never throws. A package whose side-car is absent, truncated or from a future schema still
+         * loads and still generates — the task declaration only decides which screens are *offered*,
+         * and refusing to load a working model over a missing hint would be a worse trade.
+         */
+        fun read(inferenceDir: File): PackageTask {
+            val file = File(inferenceDir, FILENAME)
+            if (!file.isFile) return UNKNOWN
+            val wire = runCatching { gson.fromJson(file.readText(Charsets.UTF_8), Wire::class.java) }
+                .getOrNull() ?: return UNKNOWN
+            return PackageTask(
+                declaredTask = wire.task?.takeIf { it.isNotBlank() },
+                modelType = wire.modelType?.takeIf { it.isNotBlank() },
+                // HF writes id2label keyed by stringified index, which is what the exporter copies.
+                id2label = wire.id2label.orEmpty()
+                    .mapNotNull { (k, v) -> k.toIntOrNull()?.let { it to v } }
+                    .toMap(),
+                inferenceGraphPrecision = wire.inferenceGraphPrecision?.takeIf { it.isNotBlank() },
+            )
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupport.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupport.kt
new file mode 100644
index 0000000..082f26a
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupport.kt
@@ -0,0 +1,112 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+
+/**
+ * Which tool-call grammar a package speaks, read from the package rather than guessed from its name.
+ *
+ * ### Why this exists
+ *
+ * `ToolCallParser.forModel` took a single string and looked for `"functiongemma"` in it, and
+ * `generateToolCall` called it as `forModel(capabilities.task.modelType ?: repoId)`. For a
+ * FunctionGemma package `task.modelType` is `"gemma3_text"` — non-null, so `repoId` was never
+ * consulted, and the *architecture family* was searched for a *model name* that is never in it. The
+ * JSON parser was therefore selected for the one model family that provably does not emit JSON, and
+ * every well-formed call it made came back as
+ *
+ *     no tool call found in the model's output
+ *
+ * which reads as a model failure and is not one. Two correct fixes were shipped in sequence — the
+ * FunctionGemma parser, then the tool declarations — and neither could take effect, because the
+ * selector in front of them never chose the parser they were written for.
+ *
+ * ### Why the chat template is the signal
+ *
+ * A name match is a guess that a rename breaks. The chat template is what the model was trained
+ * against: a model that can be *asked* for a tool call has the grammar for one written into its
+ * template, and the template ships in the package. FunctionGemma's contains
+ * `<start_function_call>`; Qwen's, Llama-3.1's and Mistral's contain `tool_call`/`tools`. That is a
+ * property of the artifact, checkable on device, and it answers both questions at once: whether to
+ * offer tool calling at all, and which dialect to parse.
+ *
+ * The name hints remain as a fallback for packages whose template did not survive the export.
+ */
+enum class ToolCallDialect {
+    /** `<start_function_call>call:name{key:<escape>value<escape>}<end_function_call>`. */
+    FUNCTION_GEMMA,
+
+    /** `{"actionName": …, "parameters": {…}}` — the shape this repo's `mobile_actions` corpus teaches. */
+    JSON,
+}
+
+/**
+ * What a package can do with tools.
+ *
+ * @property supported the model was trained with a tool-call grammar, so asking it for one is
+ *   reasonable. False does **not** forbid tool calls — a model fine-tuned on this repo's corpus
+ *   learns the JSON shape without its template ever mentioning tools — it only means the app should
+ *   not advertise the capability.
+ * @property dialect which parser reads this model's output. Always meaningful: [ToolCallDialect.JSON]
+ *   is the fallback, and it is the right one for anything fine-tuned here.
+ */
+data class ToolCallSupport(
+    val supported: Boolean,
+    val dialect: ToolCallDialect,
+) {
+    companion object {
+        /** The default for a package that says nothing: parse JSON, advertise nothing. */
+        @JvmField
+        val NONE = ToolCallSupport(supported = false, dialect = ToolCallDialect.JSON)
+
+        // FunctionGemma's grammar tokens, which appear in its template and nowhere else.
+        private val FUNCTION_GEMMA_MARKERS = listOf("<start_function_call>", "<start_function_declaration>")
+
+        // The generic signal: a template that renders a `tools` argument at all.
+        private val GENERIC_MARKERS = listOf("tool_call", "tool_calls", "<tools>", "available_tools")
+
+        /**
+         * Pure detection over a chat template and whatever names are known for the model.
+         *
+         * @param chatTemplate the package's Jinja chat template, or null when it ships none.
+         * @param hints repo id, base model id, architecture — anything that might name the family.
+         *   Checked only after the template, because a name is the weaker evidence.
+         */
+        @JvmStatic
+        fun detect(chatTemplate: String?, hints: List<String?> = emptyList()): ToolCallSupport {
+            val template = chatTemplate.orEmpty()
+            if (FUNCTION_GEMMA_MARKERS.any { template.contains(it, ignoreCase = true) }) {
+                return ToolCallSupport(supported = true, dialect = ToolCallDialect.FUNCTION_GEMMA)
+            }
+            val named = hints.filterNotNull()
+            if (named.any { it.contains("functiongemma", ignoreCase = true) }) {
+                return ToolCallSupport(supported = true, dialect = ToolCallDialect.FUNCTION_GEMMA)
+            }
+            if (GENERIC_MARKERS.any { template.contains(it, ignoreCase = true) }) {
+                return ToolCallSupport(supported = true, dialect = ToolCallDialect.JSON)
+            }
+            return NONE
+        }
+
+        /** The tokenizer stage's chat template, from either place the exporter may have put it. */
+        @JvmStatic
+        fun readChatTemplate(tokenizerDir: File): String? {
+            // #15 writes it standalone; older packages keep it inside tokenizer_config.json.
+            val jinja = File(tokenizerDir, "chat_template.jinja")
+            if (jinja.isFile) return runCatching { jinja.readText(Charsets.UTF_8) }.getOrNull()
+            val config = File(tokenizerDir, "tokenizer_config.json")
+            if (!config.isFile) return null
+            return runCatching {
+                val text = config.readText(Charsets.UTF_8)
+                // Deliberately a substring check, not a parse: this file is over a megabyte for a
+                // large-vocabulary tokenizer (FunctionGemma's is 1.1 MB of added_tokens_decoder), and
+                // all we need to know is whether the grammar appears in it.
+                text.takeIf { it.contains("chat_template") }
+            }.getOrNull()
+        }
+
+        /** [detect] against an installed package's tokenizer stage. Never throws. */
+        @JvmStatic
+        fun read(tokenizerDir: File, hints: List<String?> = emptyList()): ToolCallSupport =
+            detect(readChatTemplate(tokenizerDir), hints)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/VariantSelector.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/VariantSelector.kt
new file mode 100644
index 0000000..5bc385d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/VariantSelector.kt
@@ -0,0 +1,41 @@
+package com.martinkorelic.mobiletransformers.packages
+
+/**
+ * Device-capability variant selection (#13) — mirror of the Python
+ * `artifacts.manifest.MobileTransformersManifest.select_variant`. Pure (device caps are parameters, so
+ * this is JVM-unit-testable; the caller passes `Build.SUPPORTED_ABIS` / `ActivityManager` memory).
+ */
+object VariantSelector {
+    fun select(
+        manifest: MobileTransformersManifest,
+        abis: List<String>,
+        quantization: String? = null,
+        totalMemMb: Int? = null,
+        requestedFeatures: List<String> = emptyList(),
+        requestedEngine: String = "native",
+    ): MobileTransformersManifest.Variant {
+        val abiSet = abis.toSet()
+        val reqFeatures = requestedFeatures.toSet()
+        val candidates = manifest.variants.filter { v ->
+            (v.abi == null || v.abi.any { it in abiSet }) &&
+                (quantization == null || v.quantization == quantization) &&
+                (totalMemMb == null || v.recommendedDeviceMemoryMb == null || v.recommendedDeviceMemoryMb <= totalMemMb) &&
+                reqFeatures.all { it in v.features } &&
+                requestedEngine in v.supportedEngines
+        }
+        if (candidates.isEmpty()) {
+            throw NoCompatibleVariantException(
+                "no variant matches abis=$abis quant=$quantization mem=$totalMemMb " +
+                    "features=$requestedFeatures engine='$requestedEngine'",
+            )
+        }
+        // Tie-break: smallest recommended memory, then the defaultVariant, then id order.
+        return candidates.minWith(
+            compareBy(
+                { it.recommendedDeviceMemoryMb ?: Int.MAX_VALUE },
+                { if (it.id == manifest.defaultVariant) 0 else 1 },
+                { it.id },
+            ),
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/WeightHandoffMap.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/WeightHandoffMap.kt
new file mode 100644
index 0000000..fdcdac1
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/packages/WeightHandoffMap.kt
@@ -0,0 +1,164 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import java.io.File
+
+/**
+ * Kotlin read model of `weight_handoff_map.json` (#8 schema / #23 load-side consumer).
+ *
+ * The schema is owned by the Python side (`artifacts/handoff_map.py`); Gson ignores unknown fields so
+ * additive minor bumps stay non-breaking (F1). Only the fields the native LOAD path needs are modeled:
+ * per-role external `.bin` filenames ([Entry.externalDataLocation]), the canonical initializer names
+ * ([Entry.inferenceInitializerNames]), dtype/shape, and the optional per-role `sha256` the exporter
+ * stamps. The C++ merger owns the WRITE side (`weight_merger.cpp`), which also writes a sibling
+ * `<name>.bin.sha256` next to each `.bin`.
+ */
+data class WeightHandoffMap(
+    val schemaVersion: String = "1.0",
+    val minReaderVersion: String = "1.0",
+    val handoffMode: String = "external_initializer",
+    val externalDataLayout: String = "one_file_per_tensor",
+    val entries: List<Entry> = emptyList(),
+) {
+    data class Entry(
+        val trainingBaseLayerName: String = "",
+        /** Entry-level dtype/shape: the weight-like role's, and the fallback for [dtypeFor]/[shapeFor]. */
+        val dtype: String = "",
+        val shape: List<Long> = emptyList(),
+        /**
+         * Per-role on-disk dtype/shape. Each `<name>.bin` holds RAW external-data bytes with no header,
+         * so this is the native loader's only description of a packed `weight_quantized`/`scale`/
+         * `zero_point`, whose layout differs from the entry-level weight's. Empty on maps written before
+         * the field existed.
+         */
+        val tensorDtypes: Map<String, String> = emptyMap(),
+        val tensorShapes: Map<String, List<Long>> = emptyMap(),
+        val inferenceInitializerNames: Map<String, String> = emptyMap(),
+        val externalDataLocation: Map<String, String> = emptyMap(),
+        /** Per-role digest of the SHIPPED bytes. The live digest is `<name>.bin.sha256` and wins. */
+        val sha256: Map<String, String> = emptyMap(),
+        /**
+         * ORT **checkpoint parameter** names per role — `backbone.model…lora_A.lora.weight`, not the
+         * PEFT module path. This is the identity a federated client looks a tensor up by (#36).
+         */
+        val checkpointNames: Map<String, String> = emptyMap(),
+        /**
+         * Schema **1.1**: dtype/shape of the rank-r ADAPTER FACTORS, per adapter role.
+         *
+         * `tensorDtypes`/`tensorShapes` above describe the MERGED inference initializers — a different
+         * set of objects (60 merged weights vs 120 rank-r factors on SmolLM2). Without these the map
+         * could not describe the tensors federation actually exchanges, and a client would have to
+         * infer shapes from the rank — the re-derivation that causes layer-identity defects.
+         *
+         * Additive: `minReaderVersion` stays 1.0 and a 1.0 map simply lacks them, which
+         * [adapterTensorSpecs] reports as a fail-closed error naming the re-export, never a silent
+         * fallback to merged weights.
+         */
+        val adapterDtypes: Map<String, String> = emptyMap(),
+        val adapterShapes: Map<String, List<Long>> = emptyMap(),
+    ) {
+        fun dtypeFor(role: String): String = tensorDtypes[role] ?: dtype
+
+        fun shapeFor(role: String): List<Long> = tensorShapes[role] ?: shape
+
+        /**
+         * This entry's adapter factors in codec order, or an empty list when it declares none.
+         *
+         * Mirrors `HandoffEntry.adapter_tensor_specs`, including its rule that a role missing from
+         * EITHER map is skipped here — the fail-closed decision is made one level up, in
+         * [WeightHandoffMap.adapterTensorSpecs], so the message can name the whole package.
+         */
+        fun adapterTensorSpecs(): List<AdapterTensorSpec> = ADAPTER_ROLE_ORDER.mapNotNull { role ->
+            val dtype = adapterDtypes[role] ?: return@mapNotNull null
+            val shape = adapterShapes[role] ?: return@mapNotNull null
+            val checkpoint = checkpointNames[role] ?: return@mapNotNull null
+            AdapterTensorSpec(
+                name = "${toCheckpointName(checkpoint)}.weight",
+                dtype = dtype,
+                shape = shape,
+                role = role,
+            )
+        }
+    }
+
+    /** One tensor a federated record carries: the checkpoint identity plus its on-wire description. */
+    data class AdapterTensorSpec(
+        val name: String,
+        val dtype: String,
+        val shape: List<Long>,
+        val role: String,
+        val aggregationRole: String = "adapter_only",
+    ) {
+        val elementCount: Long get() = shape.fold(1L) { acc, d -> acc * d }
+    }
+
+    /**
+     * Every adapter factor in the package, in **codec order**: entries sorted by canonical weight name,
+     * each expanded by [ADAPTER_ROLE_ORDER].
+     *
+     * Mirrors `federated/adapter_record.py::codec_tensor_specs`, including the fail-closed behaviour: a
+     * package exported before schema 1.1 cannot describe its factors, and that is an error naming the
+     * re-export rather than a silent fallback to merged weights.
+     */
+    fun adapterTensorSpecs(): List<AdapterTensorSpec> {
+        val specs = sortedEntries().flatMap { it.adapterTensorSpecs() }
+        if (specs.isEmpty()) {
+            throw MissingArtifactException(
+                "weight_handoff_map.json (schemaVersion $schemaVersion) describes no adapter factors: " +
+                    "it carries no adapterDtypes/adapterShapes, so this package predates schema 1.1. " +
+                    "Re-export it with a current exporter — a federated round cannot infer factor " +
+                    "shapes from the rank."
+            )
+        }
+        return specs
+    }
+
+    /** Entry order: by the merged weight's inference initializer name, falling back to the base layer. */
+    fun sortedEntries(): List<Entry> = entries.sortedBy {
+        it.inferenceInitializerNames["weight"] ?: it.trainingBaseLayerName
+    }
+
+    companion object {
+        const val READER_VERSION = "1.1"
+        const val FILENAME = "weight_handoff_map.json"
+
+        /**
+         * Adapter roles in codec order. A HARD CONSTANT, mirroring `HandoffEntry.ADAPTER_ROLE_ORDER`.
+         * The wire format is (entries by canonical weight name) x this order; changing it changes the
+         * bytes, which the cross-language golden exists to prevent.
+         */
+        val ADAPTER_ROLE_ORDER = listOf("shared_A", "intermediate", "adapter_A", "adapter_B")
+
+        /**
+         * Kotlin twin of `artifacts/checkpoint_names.py::to_checkpoint_name` (and `layer_name.h`'s
+         * `to_checkpoint`): `base_model.model.` -> `backbone.`.
+         *
+         * The two WRAPPERS, not a model's own module path. Spelling it
+         * `base_model.model.model.` -> `backbone.model.` bakes in a decoder's first module: identical
+         * output for every decoder, and no match at all for an encoder (`bert.encoder.layer…`).
+         */
+        fun toCheckpointName(name: String): String =
+            if (name.startsWith("base_model.model.")) {
+                "backbone." + name.removePrefix("base_model.model.")
+            } else {
+                name
+            }
+
+        private val gson = Gson()
+
+        fun parse(json: String): WeightHandoffMap =
+            try {
+                gson.fromJson(json, WeightHandoffMap::class.java)
+                    ?: throw MissingArtifactException("weight_handoff_map.json parsed to null")
+            } catch (e: JsonSyntaxException) {
+                throw MissingArtifactException("weight_handoff_map.json is invalid JSON: ${e.message}")
+            }
+
+        fun load(file: File): WeightHandoffMap {
+            if (!file.isFile) throw MissingArtifactException("weight_handoff_map.json not found: ${file.path}")
+            return parse(file.readText(Charsets.UTF_8))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentChunker.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentChunker.kt
new file mode 100644
index 0000000..203467b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentChunker.kt
@@ -0,0 +1,29 @@
+package com.martinkorelic.mobiletransformers.rag
+
+/**
+ * #26: pure, deterministic **character-based** text chunker (no Android/JNI deps → JVM-testable).
+ *
+ * Windows of [chunkSize] characters advance by `chunkSize - chunkOverlap`. The last window is clamped to
+ * the end of the text (no gap, no out-of-range). `chunkOverlap` counts characters, not tokens.
+ */
+object DocumentChunker {
+    fun split(text: String, chunkSize: Int, chunkOverlap: Int): List<String> {
+        require(chunkSize > 0) { "chunkSize must be > 0, got $chunkSize" }
+        require(chunkOverlap in 0 until chunkSize) {
+            "chunkOverlap must be in 0 until chunkSize ($chunkSize), got $chunkOverlap"
+        }
+        if (text.isEmpty()) return emptyList()
+        if (text.length <= chunkSize) return listOf(text)
+
+        val stride = chunkSize - chunkOverlap
+        val chunks = ArrayList<String>()
+        var start = 0
+        while (start < text.length) {
+            val end = minOf(start + chunkSize, text.length)
+            chunks.add(text.substring(start, end))
+            if (end == text.length) break
+            start += stride
+        }
+        return chunks
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentSource.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentSource.kt
new file mode 100644
index 0000000..c0bafb8
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/DocumentSource.kt
@@ -0,0 +1,55 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.google.gson.Gson
+import java.io.File
+
+/**
+ * #26: document loaders behind a data-driven registry (F3). v1 supports plain text, Markdown, and JSONL;
+ * a new format is one [DOCUMENT_LOADER_REGISTRY] row — no pipeline edit. PDF/Word/HTML are explicitly out
+ * of v1 scope and rejected fail-closed.
+ */
+fun interface DocumentLoader {
+    fun load(file: File): List<RagDocument>
+}
+
+private val gson = Gson()
+
+private fun textRecord(file: File): List<RagDocument> =
+    listOf(RagDocument(id = file.nameWithoutExtension, title = file.name, text = file.readText()))
+
+private data class JsonlRecord(
+    val id: String? = null,
+    val title: String? = null,
+    val text: String? = null,
+    val metadata: Map<String, String>? = null,
+)
+
+private fun jsonlRecords(file: File): List<RagDocument> =
+    file.readLines().filter { it.isNotBlank() }.mapIndexed { i, line ->
+        val o = gson.fromJson(line, JsonlRecord::class.java) ?: JsonlRecord()
+        RagDocument(
+            id = o.id ?: "${file.nameWithoutExtension}#$i",
+            title = o.title ?: file.name,
+            text = o.text ?: "",
+            metadata = o.metadata ?: emptyMap(),
+        )
+    }
+
+/** Extension (lowercase) -> loader. New formats slot in here (F3). */
+val DOCUMENT_LOADER_REGISTRY: Map<String, DocumentLoader> =
+    mapOf(
+        "txt" to DocumentLoader { textRecord(it) },
+        "md" to DocumentLoader { textRecord(it) },
+        "jsonl" to DocumentLoader { jsonlRecords(it) },
+    )
+
+/** Load [path] into records via the registry; fail closed on an unsupported extension. */
+fun loadDocuments(path: String): List<RagDocument> {
+    val file = File(path)
+    require(file.isFile) { "not a file: $path" }
+    val ext = file.extension.lowercase()
+    val loader =
+        DOCUMENT_LOADER_REGISTRY[ext]
+            ?: throw IllegalArgumentException("v1 supports text/Markdown/JSONL only, got '.$ext' ($path)")
+    return loader.load(file)
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionPipeline.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionPipeline.kt
new file mode 100644
index 0000000..74ddf22
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionPipeline.kt
@@ -0,0 +1,48 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import kotlin.coroutines.coroutineContext
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.ensureActive
+
+/**
+ * #26: the pure ingestion loop — chunk → embed → insert — with an **injectable embedder** so it is
+ * JVM-unit-testable with a fake embedder + `InMemoryVectorStore` (the real path is JNI-bound). Cooperative
+ * cancellation between chunks/documents; a per-document failure is reported via [IngestionProgress.onError]
+ * and skipped (cancellation always propagates). Returns the number of chunks inserted.
+ */
+object IngestionPipeline {
+    suspend fun ingest(
+        documents: List<RagDocument>,
+        chunkSize: Int,
+        chunkOverlap: Int,
+        embed: (String) -> FloatArray?,
+        store: VectorStore,
+        progress: IngestionProgress? = null,
+    ): Int {
+        var inserted = 0
+        for (record in documents) {
+            coroutineContext.ensureActive()
+            progress?.onDocumentStart(record.id, documents.size)
+            try {
+                val chunks = DocumentChunker.split(record.text, chunkSize, chunkOverlap)
+                chunks.forEachIndexed { i, chunk ->
+                    coroutineContext.ensureActive()
+                    val embedding =
+                        embed(chunk) ?: throw IllegalStateException("embedding failed for ${record.id} chunk $i")
+                    store.insert(
+                        RagDocument("${record.id}#$i", record.title, chunk, record.metadata),
+                        embedding,
+                    )
+                    inserted++
+                    progress?.onChunkEmbedded(record.id, i, chunks.size)
+                }
+                progress?.onDocumentComplete(record.id)
+            } catch (ce: CancellationException) {
+                throw ce
+            } catch (e: Throwable) {
+                progress?.onError(record.id, e)
+            }
+        }
+        return inserted
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionProgress.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionProgress.kt
new file mode 100644
index 0000000..7fb833f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/IngestionProgress.kt
@@ -0,0 +1,15 @@
+package com.martinkorelic.mobiletransformers.rag
+
+/**
+ * #26: progress callback for document ingestion (chunk → embed → store). All methods optional; carries
+ * only neutral types so it is safe on the public facade surface.
+ */
+interface IngestionProgress {
+    fun onDocumentStart(id: String, totalDocs: Int) {}
+
+    fun onChunkEmbedded(docId: String, chunkIndex: Int, totalChunks: Int) {}
+
+    fun onDocumentComplete(id: String) {}
+
+    fun onError(id: String?, error: Throwable) {}
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/ObjectBoxVectorStore.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/ObjectBoxVectorStore.kt
new file mode 100644
index 0000000..d57cd06
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/ObjectBoxVectorStore.kt
@@ -0,0 +1,51 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.ORTVectorDatabase
+import com.martinkorelic.mobiletransformers.entity.VectorEntityInterface
+
+/**
+ * The default on-device [VectorStore] — a thin wrapper over [ORTVectorDatabase] that preserves its
+ * exact semantics: COSINE distance, `1 - distance` similarity (already applied by `queryDocuments`),
+ * `minScore` filtering, embedding vectors stripped from results, and the separate text-search path.
+ * It only reshapes the store's `Pair<VectorEntityInterface, Double>` results into [RagMatch].
+ */
+class ObjectBoxVectorStore(private val db: ORTVectorDatabase) : VectorStore {
+
+    init {
+        DimensionRegistry.requireSupported(db.ortRagConfig.embeddingDimension)
+    }
+
+    override fun insert(document: RagDocument, embedding: FloatArray): Long =
+        db.insertVector(
+            name = document.title,
+            embedding = embedding,
+            content = document.text,
+            document = document.id,
+            metadata = encodeMetadata(document.metadata),
+        )
+
+    override fun search(queryEmbedding: FloatArray, topK: Int, minScore: Double): List<RagMatch> =
+        // queryDocuments already returns similarity (1 - distance) and applies minScore.
+        db.queryDocuments(queryEmbedding, topK, minScore).map { (entity, similarity) ->
+            RagMatch(entity.toRagDocument(), similarity)
+        }
+
+    override fun textSearch(query: String, topK: Int): List<RagMatch> =
+        db.queryByContent(query, topK.toLong()).map { RagMatch(it.toRagDocument(), TEXT_SEARCH_SCORE) }
+
+    override fun count(): Long = db.getVectorCount()
+
+    override fun close() = db.close()
+}
+
+/** Results carry document + similarity only; the embedding vector is already stripped by the store. */
+private fun VectorEntityInterface.toRagDocument(): RagDocument =
+    RagDocument(
+        id = document,
+        title = name,
+        text = content,
+        metadata = if (metadata.isBlank()) emptyMap() else mapOf("metadata" to metadata),
+    )
+
+private fun encodeMetadata(metadata: Map<String, String>): String =
+    metadata["metadata"] ?: metadata.entries.joinToString(";") { "${it.key}=${it.value}" }
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/PromptAssembler.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/PromptAssembler.kt
new file mode 100644
index 0000000..7d134d8
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/PromptAssembler.kt
@@ -0,0 +1,33 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+
+/**
+ * #27: assembles the grounded prompt from a query + retrieved matches. Pure (JVM-testable). The default
+ * template is overridable per call via a [PromptStrategy]; the assembled prompt is always surfaced on
+ * `GroundedResult.prompt` so the grounded flow is inspectable.
+ */
+fun interface PromptStrategy {
+    fun assemble(query: String, matches: List<RetrievalMatch>): String
+}
+
+object PromptAssembler {
+    val DEFAULT: PromptStrategy =
+        PromptStrategy { query, matches ->
+            buildString {
+                appendLine("Use the following context to answer the question.")
+                appendLine()
+                appendLine("Context:")
+                matches.forEach { appendLine("- ${it.text}") }
+                appendLine()
+                appendLine("Question: $query")
+                append("Answer:")
+            }
+        }
+
+    fun assemble(
+        query: String,
+        matches: List<RetrievalMatch>,
+        strategy: PromptStrategy = DEFAULT,
+    ): String = strategy.assemble(query, matches)
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStore.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStore.kt
new file mode 100644
index 0000000..838a3e2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStore.kt
@@ -0,0 +1,46 @@
+package com.martinkorelic.mobiletransformers.rag
+
+/**
+ * A small, testable boundary around on-device vector search.
+ *
+ * ObjectBox is the default backing store on-device ([ObjectBoxVectorStore]); [VectorStore] lets
+ * chunking / ingestion / retrieval be unit-tested on the JVM with no Android/ObjectBox via a pure
+ * `InMemoryVectorStore` (test source set). Callers depend on this interface, not on ObjectBox.
+ *
+ * Score semantics (preserved from `ORTVectorDatabase`): ObjectBox HNSW uses COSINE **distance**, and
+ * similarity = `1 - distance` (`ORTVectorDatabase.kt:262`). [RagMatch.score] always carries the
+ * **similarity** (post-conversion, higher = closer), so callers never re-convert. `minScore` filters
+ * on that similarity. Text search is a separate, non-ranked path (see [TEXT_SEARCH_SCORE]).
+ */
+
+/** A stored document. `text` is the searchable/embeddable body; `id` identifies the source. */
+data class RagDocument(
+    val id: String,
+    val title: String,
+    val text: String,
+    val metadata: Map<String, String> = emptyMap(),
+)
+
+/** A retrieval hit. `score` is the similarity (already `1 - distance`), higher = closer. */
+data class RagMatch(val document: RagDocument, val score: Double)
+
+/**
+ * Fixed similarity assigned to text-search hits. Text matches are a substring/VALUE-index lookup
+ * (`ORTVectorDatabase.queryByContent`) and are **not** similarity-ranked — they all carry this score.
+ */
+const val TEXT_SEARCH_SCORE: Double = 1.0
+
+interface VectorStore {
+    /** Insert `document` with its `embedding`; returns the assigned row id (or a negative id on failure). */
+    fun insert(document: RagDocument, embedding: FloatArray): Long
+
+    /** Top-`topK` nearest documents by cosine similarity, keeping only hits with similarity >= `minScore`. */
+    fun search(queryEmbedding: FloatArray, topK: Int, minScore: Double = 0.0): List<RagMatch>
+
+    /** Non-ranked substring/content lookup; every hit carries [TEXT_SEARCH_SCORE]. */
+    fun textSearch(query: String, topK: Int): List<RagMatch>
+
+    fun count(): Long
+
+    fun close()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStoreRegistry.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStoreRegistry.kt
new file mode 100644
index 0000000..4ddb071
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/rag/VectorStoreRegistry.kt
@@ -0,0 +1,74 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.ORTVectorDatabase
+
+/**
+ * The single declared set of supported embedding dimensions (#25, F4). Replaces the scattered
+ * `when (dimension)` literals and the `VectorEntity.kt:164` "could add other popular dimensions" TODO
+ * with one place to declare support. An unsupported dimension fails closed with a clear message — the
+ * store never silently picks a box.
+ *
+ * ObjectBox additionally needs a declared `@HnswIndex VectorEntity<dim>` entity per dimension (a
+ * platform constraint), so "add a dimension" = one [register] call + its entity class. In-memory /
+ * future backends only need the registry entry.
+ */
+object DimensionRegistry {
+    private val supported: MutableSet<Int> = mutableSetOf(64, 128, 256, 384, 512, 768, 1024, 1536)
+
+    /** The supported dimensions, sorted (snapshot). */
+    val SUPPORTED_DIMENSIONS: Set<Int>
+        get() = supported.toSortedSet()
+
+    fun isSupported(dimension: Int): Boolean = dimension in supported
+
+    /** Declare support for a new dimension (backend must still provide the entity/box). */
+    fun register(dimension: Int) {
+        require(dimension > 0) { "embedding dimension must be positive, got $dimension" }
+        supported.add(dimension)
+    }
+
+    /** Fail closed unless `dimension` is registered; returns it for chaining. */
+    fun requireSupported(dimension: Int): Int {
+        require(dimension in supported) {
+            "Unsupported embedding dimension $dimension; supported: ${SUPPORTED_DIMENSIONS}. " +
+                "Add it via DimensionRegistry.register(dim) plus a declared @HnswIndex VectorEntity$dimension."
+        }
+        return dimension
+    }
+}
+
+/** Construction context passed to a [VectorStore] factory. ObjectBox needs a live DB; others need only the dimension. */
+data class VectorStoreContext(
+    val embeddingDimension: Int,
+    val objectBox: ORTVectorDatabase? = null,
+)
+
+/**
+ * Pluggable [VectorStore] backends keyed by name (F4). ObjectBox is the default key; a new backend
+ * (remote / NPU-accelerated / the test-only in-memory store) is one [register] row, not an edit to the
+ * retrieval / ingestion call sites. The in-memory backend lives in the test source set and registers
+ * itself there, so this default registry stays Android-only.
+ */
+object VectorStoreRegistry {
+    const val DEFAULT_KEY: String = "objectbox"
+
+    private val factories: MutableMap<String, (VectorStoreContext) -> VectorStore> = mutableMapOf(
+        DEFAULT_KEY to { ctx ->
+            val db = ctx.objectBox
+                ?: throw IllegalArgumentException("VectorStore backend '$DEFAULT_KEY' requires a live ORTVectorDatabase")
+            ObjectBoxVectorStore(db)
+        },
+    )
+
+    fun register(key: String, factory: (VectorStoreContext) -> VectorStore) {
+        factories[key] = factory
+    }
+
+    fun keys(): Set<String> = factories.keys.toSet()
+
+    fun create(key: String, context: VectorStoreContext): VectorStore {
+        val factory = factories[key]
+            ?: throw IllegalArgumentException("Unknown VectorStore backend '$key'; registered: ${factories.keys}")
+        return factory(context)
+    }
+}
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/InferenceRepository.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/InferenceRepository.kt
similarity index 84%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/InferenceRepository.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/InferenceRepository.kt
index beb87d4..9394f5b 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/InferenceRepository.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/InferenceRepository.kt
@@ -1,6 +1,6 @@
-package com.martinkorelic.ortmobile.repository
+package com.martinkorelic.mobiletransformers.repository
 
-import com.martinkorelic.ortmobile.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
 
 class InferenceRepository(private val llmRepository: LLMRepository) {
 
@@ -12,7 +12,7 @@ class InferenceRepository(private val llmRepository: LLMRepository) {
 
         if (callback != null) llmRepository.generationCallback = callback
 
-        if (llmRepository.ortNativeInference == null) {
+        if (llmRepository.modelRuntime == null) {
             llmRepository.generationCallback?.onModelLoadStart()
             val job = llmRepository.prepareGeneration(generationConfig)
             job.join()
@@ -30,7 +30,7 @@ class InferenceRepository(private val llmRepository: LLMRepository) {
             llmRepository.resetInference()
         }
 
-        if (llmRepository.ortNativeInference == null) {
+        if (llmRepository.modelRuntime == null) {
             llmRepository.generationCallback?.onModelLoadStart()
             val job = llmRepository.prepareGeneration(generationConfig)
             job.join()
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/LLMRepository.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/LLMRepository.kt
new file mode 100644
index 0000000..b7be0d0
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/LLMRepository.kt
@@ -0,0 +1,755 @@
+package com.martinkorelic.mobiletransformers.repository
+
+import android.content.Context
+import android.util.Log
+import com.martinkorelic.mobiletransformers.InferenceProgress
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.ORTRagArguments
+import com.martinkorelic.mobiletransformers.runtime.MemoryHeadroom
+import com.martinkorelic.mobiletransformers.runtime.MemoryProbe
+import com.martinkorelic.mobiletransformers.runtime.ModelRuntime
+import com.martinkorelic.mobiletransformers.runtime.ModelRuntimeFactory
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.ORTRetriever
+import com.martinkorelic.mobiletransformers.ORTTokenizerNative
+import com.martinkorelic.mobiletransformers.ORTTrainerNative
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.RagResult
+import com.martinkorelic.mobiletransformers.TaskPreprocessor
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import com.martinkorelic.mobiletransformers.parseGenerationArguments
+import com.martinkorelic.mobiletransformers.parseRagArguments
+import com.martinkorelic.mobiletransformers.parseTrainingArguments
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+enum class LLMState {
+    NotInitialized,
+    ReadyTrain,
+    Training,
+    ReadyGenerate,
+    Generating,
+    Querying,
+    SavingModel
+}
+
+interface GenerationCallback {
+    fun onModelLoadStart() {}
+    fun onModelLoadEnd() {}
+    fun onStartGeneration(inferenceProgress: InferenceProgress) {}
+    fun onPartialResult(inferenceProgress: InferenceProgress) {}
+    fun onCompletion(inferenceProgress: InferenceProgress) {}
+    fun onError(error: Throwable) {}
+}
+
+interface TrainingCallback {
+    fun onModelLoadStart() {}
+    fun onModelLoadEnd() {}
+    fun onDataLoadStart() {}
+    fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch : Int) {}
+    fun onSaveModelStart(trainingProgress: TrainingProgress) {}
+    fun onSaveModelEnd(trainingProgress: TrainingProgress) {}
+    fun onOptimizerStep(trainingProgress: TrainingProgress) {}
+    fun onStepStart(trainingProgress: TrainingProgress) {}
+    fun onStepEnd(trainingProgress: TrainingProgress) {}
+    fun onEpochStart(trainingProgress: TrainingProgress) {}
+    fun onEpochEnd(trainingProgress: TrainingProgress) {}
+    fun onMergeStart(trainingProgress: TrainingProgress) {}
+    fun onMergeEnd(trainingProgress: TrainingProgress) {}
+    fun onCompletion(trainingProgress: TrainingProgress) {}
+    fun onError(error: Throwable) {}
+}
+
+interface RagCallback {
+    fun onModelLoadStart() {}
+    fun onModelLoadEnd() {}
+    fun onQueryStart() {}
+    fun onQueryResults(queryResult: RagResult) {}
+    fun onQueryEnd() {}
+    fun onError(error: Throwable) {}
+}
+
+class LLMRepository(val applicationContext: Context, private val cacheDir : String, initialModel : String? = null) {
+
+    private val LOG_TAG = "LLMRepository"
+
+    // TODO: Should rename into something else as it doesn't refer to only just one model, but rather a set of different models for training/inference/embedding
+    private var _modelName: String = ""
+
+    var modelName: String
+        get() = _modelName
+        set(value) {
+            if (value in availableModels) {
+                _modelName = value
+                updatePaths()
+            } else {
+                Log.w(LOG_TAG, "Model '$value' not found in available models: $availableModels. Keeping modelName as '$_modelName'.")
+            }
+        }
+
+    /**
+     * Returns all LLM models that are present on device
+     */
+    val availableModels: List<String>
+        get() {
+            val dir = File(cacheDir)
+            return dir.listFiles { file -> file.isDirectory }?.map { it.name } ?: emptyList()
+        }
+
+    // Configuration paths
+    private var tokenizerConfigPath : String = PackagePaths.forCache(cacheDir, _modelName).tokenizer.absolutePath
+    private var trainingConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).train, "training_config.json").absolutePath
+    private var generationConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).inference, "generation_config.json").absolutePath
+    private var embeddingConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).inference, "rag_config.json").absolutePath
+
+    // Training, generation and RAG config
+    private var _trainingConfig = ORTTrainingConfig()
+    private var _generationConfig = ORTGenerationConfig()
+    private var _ragConfig = ORTRagConfig()
+
+    var trainingConfig: ORTTrainingConfig
+        get() = _trainingConfig
+        set(value) {
+            _trainingConfig = value
+        }
+
+    var generationConfig: ORTGenerationConfig
+        get() = _generationConfig
+        set(value) {
+            _generationConfig = value
+        }
+
+    var ragConfig: ORTRagConfig
+        get() = _ragConfig
+        set(value) {
+            _ragConfig = value
+            ortRetriever?.ragConfig = _ragConfig
+        }
+
+    // Availability
+    var isTrainingAvailable : Boolean = false
+    var isGenerationAvailable : Boolean = false
+    var isRagAvailable : Boolean = false
+
+    /**
+     * A runnable inference graph is present, whether or not this package can *generate*.
+     *
+     * Distinct from [isGenerationAvailable] on purpose, and the distinction is a bug: that flag is
+     * set from `inference/generation_config.json`, which is the model's own HF **generation** config
+     * and exists only for models with a generative head. An encoder — a sequence classifier like
+     * DistilBERT SST-2, or the MiniLM embedder — ships a complete, runnable `inference/` stage with
+     * no such file, so it read as "inference not installed" and `fromPretrained` refused it with
+     * "Feature 'Inference' is not installed for this package" while the graph sat right there.
+     *
+     * `classify()` runs off exactly this stage, so this is the flag that answers "can the inference
+     * group do anything at all" for every task, not only for decoders.
+     */
+    var isInferenceAvailable : Boolean = false
+
+    // Callback properties
+    var generationCallback: GenerationCallback? = null
+    var trainingCallback: TrainingCallback? = null
+    var ragCallback : RagCallback? = null
+
+    // Training capabilities
+    var ortTrainerNative : ORTTrainerNative? = null
+
+    // Tokenizer capabilities
+    var ortTokenizerNative : ORTTokenizerNative? = null
+
+    // Inference capabilities (#11): the selected engine (Native floor or GenAI) behind ModelRuntime.
+    var modelRuntime : ModelRuntime? = null
+
+    /**
+     * Why the last [prepareGeneration] failed, so the failure survives to the caller.
+     *
+     * `prepareGeneration` runs inside a `launch` and cannot throw at its caller, so it used to catch,
+     * log, and then set `llmState = ReadyGenerate` with [modelRuntime] still null. `runGenerationStream`
+     * would log "Model has not been initialized" and return — a generate() that produces nothing and
+     * reports no error. The real reason (a rejected genai_config, a missing artifact) only existed in
+     * logcat.
+     *
+     * Retained here and re-raised when work is actually requested, so the cause reaches the caller.
+     */
+    @Volatile
+    var lastGenerationSessionFailure : Throwable? = null
+        private set
+
+    /**
+     * Why the last training-session setup failed, or null.
+     *
+     * The generation path has had this since #11; the training path had not, and the difference was
+     * a crash. `prepareTraining` builds the trainer inside `coroutineScope.launch`, and a `launch`
+     * that throws does **not** deliver the exception to whoever `join()`s it — it goes to the scope's
+     * parent job, and this scope's parent is a bare `Job()` with no handler, i.e. the thread's
+     * default handler, i.e. process death. A mistyped `DatasetConfig.task` therefore killed the app:
+     *
+     *     FATAL EXCEPTION: main
+     *     java.lang.IllegalArgumentException: Unsupported task: none.
+     *         at ORTTrainerNative.<init>(ORTTrainerNative.kt:42)
+     *         at LLMRepository$prepareTraining$3$1$1.invokeSuspend(LLMRepository.kt:546)
+     *
+     * `Tasks.resolve` now rejects that particular input before the launch, but the shape of the
+     * hazard is not specific to it — any failure opening the training session (a missing checkpoint,
+     * an unreadable graph, an OOM) had the same fate. Captured here and re-raised by
+     * [TrainingRepository.performTraining], it becomes an error the caller can show.
+     */
+    @Volatile
+    var lastTrainingSessionFailure : Throwable? = null
+        private set
+
+    /** Take the recorded training-setup failure, clearing it. */
+    fun consumeTrainingSessionFailure(): Throwable? {
+        val failure = lastTrainingSessionFailure
+        lastTrainingSessionFailure = null
+        return failure
+    }
+
+    // Retriever capabilities
+    var ortRetriever : ORTRetriever? = null
+
+    // LLM state. @Volatile because the prepare*/run* paths mutate it from Dispatchers.Default while
+    // callers observe it from other threads.
+    @Volatile
+    var llmState : LLMState = LLMState.NotInitialized
+
+    /**
+     * #18/#34 session lock: ONE native session at a time.
+     *
+     * `prepareTraining`/`prepareGeneration`/`prepareRetriever` each destroy and create native handles
+     * and reassign [llmState]. Nothing serialized them, so two concurrent calls (a train kicked off
+     * while a generate was still loading, say) could race on the same handles — a use-after-free in
+     * native code, not a Kotlin exception. This lock was once recorded as done and
+     * #34's scheduler is specified against it, but no lock existed anywhere in the library.
+     *
+     * Held only across session *setup/teardown*, never across a full training run or generation loop,
+     * so a long job does not block a subsequent `release`.
+     */
+    private val sessionLock = Mutex()
+
+    /** Run [block] with exclusive access to the native sessions. */
+    suspend fun <T> withSessionLock(block: suspend () -> T): T = sessionLock.withLock { block() }
+
+    private val coroutineScope = CoroutineScope(Dispatchers.Main + Job())
+
+    init {
+        llmState = LLMState.NotInitialized
+
+        if (initialModel != null) {
+            _modelName = initialModel
+            updatePaths()
+            Log.i(LOG_TAG, "Model set to '$_modelName'.")
+        }
+
+        if (_modelName.isEmpty()) {
+            val firstAvailable = availableModels.firstOrNull()
+            if (firstAvailable != null) {
+                _modelName = firstAvailable
+                updatePaths()
+                Log.i(LOG_TAG, "Default model set to first available: $_modelName")
+            }
+        }
+    }
+
+    /**
+     * The inference graph filename actually present in [inferenceDir].
+     *
+     * `model.onnx` is what the exporter's normalization step always writes (and what the manifest
+     * records), so it is preferred; a single other `.onnx` is accepted for hand-assembled packages.
+     * Falls back to `model.onnx` so the failure, if any, names a real file rather than `.onnx`.
+     */
+    private fun resolveInferenceGraphName(inferenceDir: String): String {
+        val dir = File(inferenceDir)
+        val canonical = File(dir, "model.onnx")
+        if (canonical.isFile) return canonical.name
+        val candidates = dir.listFiles { f: File -> f.isFile && f.name.endsWith(".onnx") }.orEmpty()
+        return candidates.singleOrNull()?.name ?: "model.onnx"
+    }
+
+    private fun updatePaths() {
+        tokenizerConfigPath = PackagePaths.forCache(cacheDir, _modelName).tokenizer.absolutePath
+        trainingConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).train, "training_config.json").absolutePath
+        generationConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).inference, "generation_config.json").absolutePath
+        embeddingConfigPath = File(PackagePaths.forCache(cacheDir, _modelName).embedding, "rag_config.json").absolutePath
+
+        // Check if training config exists before parsing
+        if (File(trainingConfigPath).exists()) {
+            // Installed directory name is authoritative, as for the generation/RAG configs: the
+            // trainer resolves its dataset under `<cacheDir>/<repoName>/train/`.
+            trainingConfig = parseTrainingArguments(trainingConfigPath).copy(repoName = _modelName)
+            Log.d(LOG_TAG, "Training config loaded from: $trainingConfigPath")
+            isTrainingAvailable = true
+        } else {
+            Log.w(LOG_TAG, "Training config not found at: $trainingConfigPath")
+            isTrainingAvailable = false
+        }
+
+        // Check if generation config exists before parsing
+        if (File(generationConfigPath).exists()) {
+            // The installed package is authoritative for model *identity*. `generation_config.json` is
+            // the model's own HF generation config and carries no `repoName`/`onnxName`, so the parser
+            // fell back to "model" and ".onnx" — the session then tried to open
+            // `<cacheDir>/model/inference/.onnx`, which cannot exist. Pin both to what is on disk.
+            generationConfig = parseGenerationArguments(generationConfigPath).copy(
+                repoName = _modelName,
+                onnxName = resolveInferenceGraphName(PackagePaths.forCache(cacheDir, _modelName).inference.absolutePath),
+            )
+            Log.d(LOG_TAG, "Generation config loaded from: $generationConfigPath")
+            isGenerationAvailable = true
+        } else {
+            Log.w(LOG_TAG, "Generation config not found at: $generationConfigPath")
+            isGenerationAvailable = false
+        }
+
+        // Independent of the generation config above: an encoder has a graph and no way to generate.
+        val inferenceDir = PackagePaths.forCache(cacheDir, _modelName).inference
+        isInferenceAvailable = File(inferenceDir, resolveInferenceGraphName(inferenceDir.absolutePath)).isFile
+        if (!isInferenceAvailable) {
+            Log.w(LOG_TAG, "No inference graph found under: ${inferenceDir.absolutePath}")
+        }
+
+        // Check if embedding config exists before parsing
+        if (File(embeddingConfigPath).exists()) {
+            // The installed directory name is authoritative for `repoName` — the retriever resolves
+            // `<cacheDir>/<repoName>/embedding/`, so a config carrying a differently-sanitized id
+            // (exporter vs installer) would send it to a path that does not exist.
+            ragConfig = parseRagArguments(embeddingConfigPath).copy(repoName = _modelName)
+            Log.d(LOG_TAG, "RAG config loaded from: $embeddingConfigPath")
+            isRagAvailable = true
+        } else {
+            Log.w(LOG_TAG, "RAG config not found at: $embeddingConfigPath")
+            isRagAvailable = false
+        }
+    }
+
+    fun resetInference() {
+        // Destroy previous tokenizer session
+        ortTokenizerNative?.destroySession()
+        // Destroy previous inference session
+        modelRuntime?.release()
+
+        ortTokenizerNative = null
+        modelRuntime = null
+
+        llmState = LLMState.NotInitialized
+    }
+
+    /**
+     * Drop the inference session if one is open. Idempotent, and **not conditional on [llmState]**.
+     *
+     * ### Why this is a resource check and not a state check
+     *
+     * `prepareTraining` used to release only `if (llmState == LLMState.ReadyGenerate)` — a *state*
+     * standing in for a *resource*. Whether a native session is open is knowable directly
+     * (`modelRuntime != null`), and the state enum has seven values of which four can hold a live
+     * inference session: `Generating` and `Querying` (work in flight), `NotInitialized` (set by
+     * `prepareGeneration`'s own catch path, which leaves a partially-built runtime behind), and
+     * `ReadyTrain`. Any of those and the training session was opened **on top of** the inference one.
+     *
+     * That is not a leak of a handle, it is a leak of a graph: this package's `inference/` stage is
+     * 3.5 GB of fp32 (`model.onnx_data` 1.74 GB + `frozen_base.onnx.data` 1.68 GB). Holding it while
+     * ORT builds the training graph is what took the app to 2.1 GB RSS + 1.1 GB swap on a 5.5 GB
+     * device and got it SIGKILLed by `lmkd` mid-run, after the killer had already reclaimed five
+     * other processes:
+     *
+     *     lmkd: Reclaim 'com.martinkorelic.mobiletransformers.app' (31489), oom_score_adj 0,
+     *           to free 2175440kB rss, 1091904kB swap; reason: min2x watermark is breached
+     *     Zygote: Process 31489 exited due to signal 9 (Killed)
+     *
+     * There is no Java exception for that and nothing to catch — the only defence is not holding both.
+     *
+     * The log line is deliberate. The previous code left no trace either way, so "was the inference
+     * session still resident during training?" could not be answered from a logcat capture; it had to
+     * be re-derived from the source. Now the answer is in the log next to the RSS it freed.
+     */
+    private fun releaseInferenceRuntime(reason: String) {
+        val runtime = modelRuntime ?: return
+        val before = MemoryProbe.currentRssKb()
+        // #11: release whichever engine is loaded. The old `when (type)` released only Native, so a
+        // GenAI session leaked its native handle across a train switch.
+        runtime.release()
+        modelRuntime = null
+        val after = MemoryProbe.currentRssKb()
+        Log.i(
+            LOG_TAG,
+            "Released the inference session ($reason): RSS ${before} kB -> ${after} kB",
+        )
+        if (llmState == LLMState.ReadyGenerate || llmState == LLMState.Generating || llmState == LLMState.Querying) {
+            llmState = LLMState.NotInitialized
+        }
+    }
+
+    /**
+     * Drop the training session if one is open. The mirror of [releaseInferenceRuntime].
+     *
+     * `destroySession` is already idempotent (it no-ops on a zero handle), but the reference was left
+     * dangling and nothing recorded that the swap had happened — the same blind spot in the other
+     * direction.
+     */
+    private fun releaseTrainingSessionForSwap(reason: String, saveCheckpoint: Boolean = false) {
+        val trainer = ortTrainerNative ?: return
+        val before = MemoryProbe.currentRssKb()
+        trainer.destroySession(saveCheckpoint)
+        ortTrainerNative = null
+        val after = MemoryProbe.currentRssKb()
+        Log.i(
+            LOG_TAG,
+            "Released the training session ($reason, saveCheckpoint=$saveCheckpoint): " +
+                "RSS ${before} kB -> ${after} kB",
+        )
+        if (llmState == LLMState.ReadyTrain || llmState == LLMState.Training) {
+            llmState = LLMState.NotInitialized
+        }
+    }
+
+    fun resetTraining() {
+        ortTokenizerNative?.destroySession()
+        ortTrainerNative?.destroySession(false)
+        ortTokenizerNative = null
+        ortTrainerNative = null
+
+        llmState = LLMState.NotInitialized
+    }
+
+    suspend private fun makeOrtTrainer(trainingArguments: ORTTrainingConfig? = null, dataPreprocessFunction: TaskPreprocessor? = null) : ORTTrainerNative {
+        if (ortTokenizerNative == null) {
+            Log.d(LOG_TAG, "Could not find the tokenizer. Initializing tokenizer...")
+            ortTokenizerNative = ORTTokenizerNative(tokenizerConfigPath)
+            ortTokenizerNative?.createTokenizerModel()
+        }
+
+        val trainArgs = trainingConfig.overrideConfig(trainingArguments)
+
+        val finalConfig = if (dataPreprocessFunction != null)
+            trainArgs.copy(customPreprocess = dataPreprocessFunction)
+        else
+            trainArgs
+
+        return ORTTrainerNative(
+            applicationContext,
+            cacheDir,
+            ortTokenizerNative!!,
+            finalConfig
+        )
+    }
+
+    // #11: select + load the inference engine (Native floor, or GenAI when requested & available) over the
+    // one shared inference/ package via ModelRuntimeFactory, with transparent fallback to Native.
+    private suspend fun makeModelRuntime(generationArgs : ORTGenerationConfig) : ModelRuntime {
+        if (ortTokenizerNative == null) {
+            Log.e(LOG_TAG, "Could not find the tokenizer. Initializing tokenizer...")
+            ortTokenizerNative = ORTTokenizerNative(tokenizerConfigPath)
+            ortTokenizerNative?.createTokenizerModel()
+        }
+
+        // Drop the training session before opening a generation one. Symmetric with
+        // prepareTraining's release, and for the same memory reason — the two graphs must never be
+        // resident together. `saveCheckpoint = false` is unchanged: the training path is responsible
+        // for persisting its own checkpoint before handing over.
+        releaseTrainingSessionForSwap("a generation session is being opened")
+
+        // #13: supportedEngines comes from the installed variant's manifest declaration. A package that
+        // declares none (an older export, or a manifest-less legacy dir) keeps the permissive default —
+        // narrowing an unknown declaration would break packages that work today.
+        val declaredEngines = installedSupportedEngines()
+        return if (declaredEngines != null) {
+            ModelRuntimeFactory.create(cacheDir, ortTokenizerNative!!, generationArgs, declaredEngines)
+        } else {
+            ModelRuntimeFactory.create(cacheDir, ortTokenizerNative!!, generationArgs)
+        }
+    }
+
+    /**
+     * What the last [prepareTraining] concluded about memory headroom, or null when it was fine.
+     *
+     * Surfaced so an app can warn the user; it never blocks the run.
+     */
+    @Volatile
+    var lastTrainingHeadroomWarning : String? = null
+        private set
+
+    /** The full parameter count the installed package's training graph materialises, or 0. */
+    private fun installedTrainingParameterCount(): Long {
+        val manifestFile = File(
+            PackagePaths.forCache(cacheDir, _modelName).root,
+            PackageFormat.MANIFEST_FILENAME,
+        )
+        if (!manifestFile.isFile) return 0L
+        return runCatching { MobileTransformersManifest.load(manifestFile).trainingParameterCount }
+            .getOrDefault(0L)
+    }
+
+    /** The installed package's declared engines, or null when it declares none (see [makeModelRuntime]). */
+    private fun installedSupportedEngines(): Set<String>? {
+        val manifestFile = File(
+            PackagePaths.forCache(cacheDir, _modelName).root,
+            PackageFormat.MANIFEST_FILENAME,
+        )
+        if (!manifestFile.isFile) return null
+        return runCatching { MobileTransformersManifest.load(manifestFile).supportedEnginesFor() }
+            .onFailure { Log.w(LOG_TAG, "unreadable manifest at ${manifestFile.path}: ${it.message}") }
+            .getOrNull()
+    }
+
+    private suspend fun makeOrtRag(ortArgs : ORTRagConfig) : ORTRetriever {
+
+        // Same swap rule as the generation path: retrieval opens an embedding session, and the
+        // training graph must not still be resident behind it.
+        releaseTrainingSessionForSwap("a retrieval session is being opened")
+
+        // #27: honor the override config actually passed in (was previously ignoring ortArgs).
+        val retriever = ORTRetriever(cacheDir, applicationContext, ortArgs)
+        retriever.createEmbeddingModel()
+
+        return retriever
+    }
+
+    /* Inference methods */
+
+    suspend fun prepareRetriever(ragArgs : ORTRagConfig? = null): Job {
+        // Clean up the tokenizer and destroy session if there was previous training
+        // Takes less memory if we initialize the training session again with the checkpoint state
+
+        if (llmState == LLMState.ReadyTrain) {
+            ortTokenizerNative = null
+        }
+
+        // #27: apply the caller's RAG config override (falls back to the loaded field config).
+        val finalRagConfig = ragArgs ?: ragConfig
+        ragConfig = finalRagConfig
+
+        // If the model was in training state
+        if (llmState == LLMState.Training) {
+
+            coroutineScope.launch {
+                withContext(Dispatchers.Default) {
+
+                    // Release training session if there was any (no saving)
+                    releaseTrainingSessionForSwap("switching to generation")
+
+                    llmState = LLMState.ReadyGenerate
+                }
+            }.join()
+        }
+
+        return coroutineScope.launch {
+            // #18/#34 session lock: serialize native session creation/teardown (see `sessionLock`).
+            sessionLock.withLock {
+                try {
+                    withContext(Dispatchers.Default) {
+                        ortRetriever = makeOrtRag(finalRagConfig)
+                    }
+                } catch (e: Exception) {
+                    Log.e(LOG_TAG, "Retriever session failed to create: ${e.message}")
+                }
+            }
+        }
+    }
+
+    suspend fun prepareGeneration(generationArgs : ORTGenerationConfig? = null): Job {
+        // Clean up the tokenizer and destroy session if there was previous training
+        // Takes less memory if we initialize the training session again with the checkpoint state
+
+        if (llmState == LLMState.ReadyTrain) {
+            ortTokenizerNative = null
+        }
+
+        val finalGenConfig = generationConfig.overrideConfig(generationArgs)
+
+        // If the model was in training state
+        if (llmState == LLMState.Training) {
+
+            coroutineScope.launch {
+                withContext(Dispatchers.Default) {
+
+                    // Release training session if there was any (no saving)
+                    releaseTrainingSessionForSwap("switching to generation")
+
+                    llmState = LLMState.ReadyGenerate
+                }
+            }.join()
+        }
+
+        return coroutineScope.launch {
+            // #18/#34 session lock: serialize native session creation/teardown (see `sessionLock`).
+            sessionLock.withLock {
+                try {
+                    withContext(Dispatchers.Default) {
+                        // #11: engine selection belongs to ModelRuntimeFactory (which owns the GenAI
+                        // availability probe and the transparent fallback to Native), not to a string
+                        // `when` here. The old `when (type) { "native" -> …; else -> Log.e }` dropped
+                        // every GenAI config on the floor, leaving the runtime null and generate() hanging.
+                        modelRuntime = makeModelRuntime(finalGenConfig)
+                        lastGenerationSessionFailure = null
+                    }
+                } catch (e: Exception) {
+                    // Keep the cause: this coroutine cannot throw at prepareGeneration's caller, and
+                    // a log line is not an error report. runGenerationStream re-raises it.
+                    lastGenerationSessionFailure = e
+                    Log.e(LOG_TAG, "Generation session failed to create: ${e.message}", e)
+                } finally {
+                    llmState = LLMState.ReadyGenerate
+                }
+            }
+        }
+    }
+
+    suspend fun runGenerationStream(prompt: String, generationArgs: ORTGenerationConfig? = null) {
+        if (modelRuntime == null) {
+            // Surface why. Returning quietly here is what let a rejected genai_config.json read as
+            // "generation produced nothing" instead of "the engine you asked for never loaded".
+            lastGenerationSessionFailure?.let { cause ->
+                throw MobileTransformersException(
+                    "Generation session was never created: ${cause.message}",
+                    cause,
+                )
+            }
+            throw MobileTransformersException(
+                "Model has not been initialized: call prepareGeneration() before runGenerationStream().",
+            )
+        }
+
+        val finalGenConfig = generationConfig.overrideConfig(generationArgs)
+
+        llmState = LLMState.Generating
+
+        coroutineScope.launch {
+            try {
+                withContext(Dispatchers.Default) {
+                    // #11: the loaded ModelRuntime already *is* the selected engine — dispatching on
+                    // `type` again here would re-open the GenAI hole closed in prepareGeneration.
+                    modelRuntime!!.generate(prompt, finalGenConfig, generationCallback)
+                }
+            } catch (e : Exception) {
+                Log.e(LOG_TAG, "Generation failed: ${e.message}")
+                // Told to the caller, not only to logcat. A `generate()` is awaited on a deferred that
+                // only `onCompletion`/`onError` can complete, so swallowing the failure here does not
+                // produce a failed generation — it produces one that NEVER RETURNS, and a UI that sits
+                // on its progress indicator forever with the reason visible only over adb.
+                generationCallback?.onError(e)
+            } finally {
+                llmState = LLMState.ReadyGenerate
+            }
+        }
+    }
+
+    suspend fun runRetriever(prompt: String, ragArgs: ORTRagArguments? = null): Job {
+
+        val finalRagConfig = ragConfig.overwriteWith(ragArgs)
+
+        llmState = LLMState.Querying
+
+        return coroutineScope.launch {
+            try {
+                withContext(Dispatchers.Default) {
+                    ortRetriever?.query(prompt, finalRagConfig, ragCallback)
+                }
+            } catch (e : Exception) {
+                Log.e(LOG_TAG, "Query failed: ${e.message}")
+            } finally {
+                llmState = LLMState.ReadyGenerate
+            }
+        }
+    }
+
+    /* Training methods */
+
+    suspend fun prepareTraining(trainingArguments: ORTTrainingConfig? = null,  dataPreprocessFunction: TaskPreprocessor? = null) : Job {
+
+        // #18/#34 session lock: the inference teardown must not interleave with another prepare*
+        // creating a session on the same handles.
+        coroutineScope.launch {
+            sessionLock.withLock {
+                withContext(Dispatchers.Default) {
+                    releaseInferenceRuntime("a training session is being opened")
+                }
+            }
+        }.join()
+
+        val finalTrainConfig = trainingConfig.overrideConfig(trainingArguments);
+
+        // Advisory only — see MemoryHeadroom for why this warns instead of refusing. Logged before
+        // the session opens because if the estimate is right there will be no `after`: the process
+        // is SIGKILLed and this line is the last thing in the capture that explains why.
+        lastTrainingHeadroomWarning = when (
+            val verdict = MemoryHeadroom.verdict(
+                trainingParameterCount = installedTrainingParameterCount(),
+                availableKb = MemoryHeadroom.availableKb(),
+            )
+        ) {
+            is MemoryHeadroom.Verdict.Tight -> {
+                Log.w(LOG_TAG, "Memory headroom: ${verdict.message}")
+                verdict.message
+            }
+            else -> null
+        }
+        Log.i(LOG_TAG, "Opening a training session at RSS ${MemoryProbe.currentRssKb()} kB")
+
+        lastTrainingSessionFailure = null
+
+        return coroutineScope.launch {
+            // #18/#34 session lock: serialize native session creation/teardown (see `sessionLock`).
+            sessionLock.withLock {
+                try {
+                    withContext(Dispatchers.Default) {
+                        ortTrainerNative = makeOrtTrainer(
+                            finalTrainConfig,
+                            dataPreprocessFunction
+                        )
+                        llmState = LLMState.ReadyTrain
+                    }
+                } catch (e: Throwable) {
+                    // Must not escape: this coroutine's parent has no handler, so an escaping throw
+                    // is a FATAL EXCEPTION rather than a failed call. See lastTrainingSessionFailure.
+                    lastTrainingSessionFailure = e
+                    llmState = LLMState.NotInitialized
+                    Log.e(LOG_TAG, "Training session failed to create: ${e.message}", e)
+                }
+            }
+        }
+    }
+
+    suspend fun runTraining() : Job? {
+        if (llmState != LLMState.ReadyTrain && llmState != LLMState.Training) {
+            Log.e(LOG_TAG, "Model is not ready to train.")
+            return null
+        }
+
+        llmState = LLMState.Training
+
+        // Here we mark that there was training done on this model
+        return coroutineScope.launch {
+            withContext(Dispatchers.IO) {
+                ortTrainerNative?.startTraining(trainingCallback)
+            }
+            llmState = LLMState.ReadyTrain
+        }
+    }
+
+    suspend fun saveTraining(saveModel : Boolean) : Job? {
+        if (llmState != LLMState.ReadyTrain && llmState != LLMState.Training) {
+            Log.e(LOG_TAG, "Model is not ready to save.")
+            return null
+        }
+
+        llmState = LLMState.SavingModel
+
+        return coroutineScope.launch {
+            withContext(Dispatchers.IO) {
+                ortTrainerNative?.destroySession(saveModel)
+            }
+            llmState = LLMState.NotInitialized
+        }
+    }
+}
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/RagRepository.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/RagRepository.kt
new file mode 100644
index 0000000..6cec6ba
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/RagRepository.kt
@@ -0,0 +1,93 @@
+package com.martinkorelic.mobiletransformers.repository
+
+import android.util.Log
+import com.martinkorelic.mobiletransformers.ORTRagArguments
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.loadDocuments
+
+class RagRepository(private val llmRepository: LLMRepository) {
+
+    private val LOG_TAG = "RagRepository"
+
+    /**
+     * #26: ingest a `.txt`/`.md`/`.jsonl` file into the vector store (chunk → embed → insert). Owner of
+     * ingestion; [loadDocuments] resolves the loader (F3). Returns the number of chunks inserted.
+     */
+    suspend fun ingest(
+        path: String,
+        ragConfig: ORTRagConfig? = null,
+        progress: IngestionProgress? = null,
+    ): Int {
+        initialize(ragConfig)
+        val retriever = llmRepository.ortRetriever
+        if (retriever == null) {
+            Log.e(LOG_TAG, "ORTRetriever is not set; cannot ingest.")
+            return 0
+        }
+        return retriever.ingestData(loadDocuments(path), progress)
+    }
+
+    /**
+     * Ensure a retriever exists AND that it is running [ragConfig].
+     *
+     * #27 fix: this used to short-circuit entirely once a retriever existed, so only the FIRST
+     * config of a session ever took effect — a later `retrieve`/`generateWithRag` with a changed
+     * `topK`/`minScore`/`searchType` was silently ignored. A changed config now always applies:
+     * query-shaping fields are pushed onto the live retriever, while a change to the embedding
+     * model's identity ([requiresReload]) rebuilds it, since assigning those alone would leave a
+     * stale embedding session loaded.
+     */
+    suspend fun initialize(
+        ragConfig: ORTRagConfig? = null,
+        ragCallback: RagCallback? = null
+    ) {
+        if (ragCallback != null) llmRepository.ragCallback = ragCallback
+
+        val existing = llmRepository.ortRetriever
+        if (existing == null || (ragConfig != null && requiresReload(existing.ragConfig, ragConfig))) {
+            llmRepository.ragCallback?.onModelLoadStart()
+            val job = llmRepository.prepareRetriever(ragConfig)
+            job.join()
+            llmRepository.ragCallback?.onModelLoadEnd()
+            return
+        }
+
+        // Same embedding model, possibly different query shaping — the LLMRepository setter fans the
+        // new config out to the live retriever.
+        if (ragConfig != null && ragConfig != existing.ragConfig) {
+            llmRepository.ragConfig = ragConfig
+        }
+    }
+
+    /**
+     * True when [next] selects a different embedding model (or device placement) than [current], and
+     * the retriever must therefore be rebuilt rather than reconfigured in place. Query-shaping fields
+     * (`topK`, `minScore`, `searchType`, `indexingMode`, chunking) deliberately do NOT appear here.
+     */
+    private fun requiresReload(current: ORTRagConfig, next: ORTRagConfig): Boolean =
+        current.repoName != next.repoName ||
+            // ORTRetriever.createEmbeddingModel appends ".onnx" in place, so a loaded config's
+            // onnxName has the suffix while a freshly-mapped one does not. Compare normalized, or
+            // every single retrieve would look like a model change and rebuild the session.
+            normalizeOnnxName(current.onnxName) != normalizeOnnxName(next.onnxName) ||
+            current.embeddingDimension != next.embeddingDimension ||
+            current.deviceOptions != next.deviceOptions
+
+    private fun normalizeOnnxName(name: String): String = name.removeSuffix(".onnx")
+
+    suspend fun query(prompt : String, ragConfig: ORTRagArguments? = null, ragCallback: RagCallback? = null) {
+
+        if (llmRepository.ortRetriever == null) {
+            Log.e(LOG_TAG, "ORTRetriever is not currently set or does not exist.")
+            return
+        }
+
+        // Update RAG callback
+        if (ragCallback != null) llmRepository.ragCallback = ragCallback
+
+        // Run the retriever
+        val job = llmRepository.runRetriever(prompt, ragConfig)
+        job.join()
+    }
+}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/TrainingRepository.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/TrainingRepository.kt
similarity index 72%
rename from android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/TrainingRepository.kt
rename to android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/TrainingRepository.kt
index c75f913..853a028 100644
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/TrainingRepository.kt
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/repository/TrainingRepository.kt
@@ -1,7 +1,7 @@
-package com.martinkorelic.ortmobile.repository
+package com.martinkorelic.mobiletransformers.repository
 
-import com.martinkorelic.ortmobile.ORTTrainingConfig
-import com.martinkorelic.ortmobile.TaskPreprocessor
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.TaskPreprocessor
 import org.json.JSONObject
 
 class TrainingRepository(private val llmRepository: LLMRepository) {
@@ -14,6 +14,11 @@ class TrainingRepository(private val llmRepository: LLMRepository) {
             llmRepository.trainingCallback?.onModelLoadStart()
             val job = llmRepository.prepareTraining(trainingConfig, dataPreprocessFunction)
             job.join()
+            // `join()` never rethrows, and `prepareTraining` deliberately swallows so the failure
+            // cannot reach an uncaught handler. Re-raise it here, on the caller's own coroutine,
+            // which is the first frame that can both see it and report it. Without this a setup
+            // failure read as "runTraining says the model is not ready" — a symptom, on a later line.
+            llmRepository.consumeTrainingSessionFailure()?.let { throw it }
             llmRepository.trainingCallback?.onModelLoadEnd()
         }
 
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/InferenceEngine.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/InferenceEngine.kt
new file mode 100644
index 0000000..d15ca69
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/InferenceEngine.kt
@@ -0,0 +1,16 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+/**
+ * The single inference-engine selector over one shared package: Native (guaranteed default) vs the
+ * opt-in ONNX Runtime GenAI engine (#11). This is the canonical declaration; #17/#19/#24 reuse it verbatim.
+ * The engine is a *selection over one `inference/` package*, never a separate package or build. GenAI runs
+ * on a genai-paired stock ORT shipped as `libort_gen.so` (see spikes/genai_external_swap/README.md — ORT
+ * separation); Native runs on the source-built ORT-training `libonnxruntime.so`.
+ */
+enum class InferenceEngine {
+    /** Always available; consumes the shared `inference/` package via the native ORT runtime. */
+    NATIVE,
+
+    /** Opt-in; consumes the SAME package via the GenAI engine. Availability is gated by #11 (Gate 0.1). */
+    GENAI,
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroom.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroom.kt
new file mode 100644
index 0000000..3cf7087
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroom.kt
@@ -0,0 +1,106 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import java.io.File
+
+/**
+ * Is there plausibly enough memory to open a training session, and if not, say so **before** it opens.
+ *
+ * ### Why this exists: there is no exception to catch
+ *
+ * When a phone runs out of memory the app does not get an error. `lmkd` sends **SIGKILL** — no
+ * exception, no `finally`, no chance to checkpoint or explain. Training FunctionGemma on the S21 FE
+ * ended exactly there, after the killer had already reclaimed five other processes trying to avoid it:
+ *
+ *     lmkd: Reclaim 'com.martinkorelic.mobiletransformers.app' (31489), oom_score_adj 0, state 2
+ *           to free 2175440kB rss, 1091904kB swap; reason: min2x watermark is breached even after kill
+ *     Zygote: Process 31489 exited due to signal 9 (Killed)
+ *
+ * To the user that is indistinguishable from a crash. A warning naming the numbers is the only
+ * honest alternative.
+ *
+ * ### Why it estimates from parameter count, not from the package size on disk
+ *
+ * The first version of this compared the stage's bytes-on-disk against `MemAvailable`. That is
+ * unsound, and the device proves it: this package's `inference/` stage is **3.5 GB** and chat runs
+ * fine with **2.4 GB** available, because ONNX external initializers are memory-mapped — file-backed,
+ * reclaimable, and never all resident. A disk-size rule would have refused a session that works.
+ *
+ * Training is the opposite case. ORT training materialises parameters, gradients and optimizer state
+ * as **anonymous** memory, which is neither reclaimable nor free — and anonymous is exactly what the
+ * kill reported (1.09 GB of it in swap). So the estimate is built from
+ * `manifest.trainingParameterCount`, which is the number that actually drives it.
+ *
+ * ### Why it warns rather than refuses
+ *
+ * The true peak depends on batch size, sequence length and ORT's arena behaviour, none of which is
+ * knowable here, and a false refusal breaks a feature that would have worked. The measured evidence
+ * is one data point. Until there are more, this reports and lets the caller proceed — see the open
+ * item in the handoff for calibrating it into a hard gate.
+ */
+object MemoryHeadroom {
+
+    /** fp32. Every parameter is four bytes in the training graph regardless of the export precision. */
+    private const val BYTES_PER_PARAM = 4L
+
+    /**
+     * Multiplier over raw parameter bytes covering activations, the optimizer's moments for the
+     * trainable subset, and ORT's arena. A floor, not a prediction.
+     */
+    private const val TRAINING_OVERHEAD = 1.6
+
+    /** Left for the rest of the system. Below this the killer starts taking other processes first. */
+    private const val SYSTEM_RESERVE_KB = 512L * 1024
+
+    sealed interface Verdict {
+        /** Comfortable. */
+        data object Fits : Verdict
+
+        /**
+         * Likely to be killed. [message] names the numbers, because "out of memory" without them
+         * reads as a bug in the app rather than a limit of the device.
+         */
+        data class Tight(val message: String) : Verdict
+
+        /** Nothing to judge on — an unreadable `/proc/meminfo` or a manifest with no parameter count. */
+        data object Unknown : Verdict
+    }
+
+    /**
+     * `MemAvailable` in KiB: the kernel's own estimate of what can be allocated without swapping.
+     *
+     * Not `MemFree`, which excludes reclaimable page cache and reads far below what is obtainable.
+     */
+    fun availableKb(meminfo: File = File("/proc/meminfo")): Long? = runCatching {
+        meminfo.useLines { lines ->
+            lines.firstOrNull { it.startsWith("MemAvailable:") }
+                ?.filter { it.isDigit() }
+                ?.toLongOrNull()
+        }
+    }.getOrNull()
+
+    /**
+     * Pure policy, so it is testable without a device.
+     *
+     * @param trainingParameterCount from the manifest — the full parameter set the training graph
+     *   materialises, not the trainable subset. For a LoRA export those differ by three orders of
+     *   magnitude (268,098,176 against 368,640) and using the trainable count would under-estimate by
+     *   the entire model.
+     */
+    fun verdict(trainingParameterCount: Long, availableKb: Long?): Verdict {
+        if (availableKb == null || availableKb <= 0 || trainingParameterCount <= 0) return Verdict.Unknown
+        val neededKb = (trainingParameterCount * BYTES_PER_PARAM / 1024.0 * TRAINING_OVERHEAD).toLong()
+        val usableKb = availableKb - SYSTEM_RESERVE_KB
+        if (neededKb <= usableKb) return Verdict.Fits
+        return Verdict.Tight(
+            "this training run needs roughly ${mb(neededKb)} of working memory " +
+                "(${trainingParameterCount / 1_000_000}M parameters at 4 bytes, plus gradients, " +
+                "optimizer state and activations) and only ${mb(availableKb)} is available, of which " +
+                "${mb(SYSTEM_RESERVE_KB)} has to be left for the system. Android kills the app " +
+                "outright when memory runs out — there is no error to report and no checkpoint is " +
+                "written — so close other apps first, or train a smaller package.",
+        )
+    }
+
+    private fun mb(kb: Long): String =
+        if (kb >= 1024L * 1024) "%.1f GB".format(kb / 1024.0 / 1024.0) else "${kb / 1024} MB"
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryProbe.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryProbe.kt
new file mode 100644
index 0000000..e825fee
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/MemoryProbe.kt
@@ -0,0 +1,31 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import com.martinkorelic.mobiletransformers.NativeLibrary
+
+/**
+ * Process resident-set-size sampler (#12, Gate 0.2).
+ *
+ * Reads `VmRSS` from `/proc/self/status` in native code. `Debug.getPss()` measures the JVM's accounting
+ * of the process; the weight blobs are mapped by native code outside it, so the gate's four-point table
+ * (base/merged x copy/mmap) is specified against `VmRSS`.
+ *
+ * The zero-copy load is default-off and toggled with `adb shell setprop debug.mtf.mmap_weights 1` (or
+ * the `MTF_MMAP_WEIGHTS` environment variable off-device). [mmapWeightsEnabled] reports what native
+ * code actually resolved, so a harness can assert the flip took effect instead of assuming it.
+ */
+object MemoryProbe {
+
+    init {
+        NativeLibrary.ensureLoaded()
+    }
+
+    /** Resident set size in KiB, or -1 when `/proc/self/status` is unreadable. */
+    fun currentRssKb(): Long = runCatching { nativeCurrentRssKb() }.getOrDefault(-1L)
+
+    /** True when the next weight load will take the mmap branch. */
+    fun mmapWeightsEnabled(): Boolean = runCatching { nativeMmapWeightsEnabled() }.getOrDefault(false)
+
+    private external fun nativeCurrentRssKb(): Long
+
+    private external fun nativeMmapWeightsEnabled(): Boolean
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelRuntime.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelRuntime.kt
new file mode 100644
index 0000000..21df523
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelRuntime.kt
@@ -0,0 +1,216 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import android.util.Log
+import com.martinkorelic.mobiletransformers.EngineUnavailableException
+import com.martinkorelic.mobiletransformers.NativeLibrary
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.ORTGeneratorGenAI
+import com.martinkorelic.mobiletransformers.ORTGeneratorNative
+import com.martinkorelic.mobiletransformers.ORTTokenizerNative
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.repository.GenerationCallback
+
+/**
+ * The single inference-engine boundary (#11): one interface, two implementations — Native (guaranteed
+ * floor) and GenAI (opt-in) — over the **same** `inference/` package produced by File #9. The engine is a
+ * selection over one package, never a separate package/build. `generate` MUST drive the exact same
+ * `GenerationCallback`/`InferenceProgress` sequence on both engines so the facade/UI never branch on engine.
+ *
+ * This is `ModelRuntime` (engine boundary); #17's whole-model facade contract is `ModelSession`.
+ */
+interface ModelRuntime {
+    val capabilities: EngineCapabilities
+
+    /** Open a session over `<cacheDir>/<repoName>/inference` for [config]. */
+    suspend fun load(cacheDir: String, config: ORTGenerationConfig)
+
+    /** Same return + callback sequence as `ORTGeneratorNative.generate`. */
+    fun generate(
+        promptText: String,
+        generationArgs: ORTGenerationConfig,
+        callback: GenerationCallback? = null,
+    ): String
+
+    fun release()
+}
+
+/** Engine-level capability record (distinct from #17's model-level `RuntimeCapabilities`). */
+data class EngineCapabilities(
+    val engine: InferenceEngine,
+    val supportsStreaming: Boolean,
+    val supportsLoadMergedWeights: Boolean,
+    val maxContextLength: Int,
+)
+
+/**
+ * Data-driven execution-provider registry (F3): the engine's ORT execution providers are rows, not an
+ * `if/elif` over EP names. Each row carries an availability probe + an [InferenceEngine] affinity. Adding a
+ * provider (e.g. an NPU EP) is a registry row + enum member — no business-logic edit. `ModelRuntimeFactory`
+ * resolves the ordered provider list for a chosen engine from this registry.
+ */
+data class ExecutionProviderRow(
+    val provider: String,
+    val engine: InferenceEngine,
+    val available: () -> Boolean,
+    /** Lower = earlier in the EP append order for its engine. */
+    val order: Int,
+)
+
+object EngineRegistry {
+    /** The single source of EP→engine affinity + availability. `genai` is GenAI's provider row. */
+    val EXECUTION_PROVIDER_REGISTRY: List<ExecutionProviderRow> = listOf(
+        ExecutionProviderRow(ExecutionProvider.CPU.wire, InferenceEngine.NATIVE, { true }, 0),
+        ExecutionProviderRow(ExecutionProvider.XNNPACK.wire, InferenceEngine.NATIVE, { true }, 1),
+        ExecutionProviderRow(ExecutionProvider.NNAPI.wire, InferenceEngine.NATIVE, { true }, 2),
+        ExecutionProviderRow("genai", InferenceEngine.GENAI, { GenAiSupport.available() }, 0),
+    )
+
+    /** Ordered, available EP names for [engine] (F3 — resolved from data, not branched on strings). */
+    fun providersFor(engine: InferenceEngine): List<String> =
+        EXECUTION_PROVIDER_REGISTRY
+            .filter { it.engine == engine && it.available() }
+            .sortedBy { it.order }
+            .map { it.provider }
+}
+
+/**
+ * `genaiAvailable()` = Gate 0.1 passed AND the GenAI stack is linked AND `OgaCreateModel` is present. The
+ * native probe is injectable (default: JNI symbol/init check) so selection logic is JVM-testable.
+ */
+object GenAiSupport {
+    /** Overridable for tests; production points at the native probe. */
+    @Volatile
+    var probe: () -> Boolean = {
+        NativeLibrary.ensureLoaded()
+        nativeGenAiAvailable()
+    }
+
+    fun available(): Boolean = runCatching { probe() }.getOrDefault(false)
+
+    private external fun nativeGenAiAvailable(): Boolean
+}
+
+/**
+ * Selects an engine and constructs a [ModelRuntime]. GenAI that was **auto-selected** falls back to
+ * Native transparently (#11's guaranteed floor); GenAI that the caller **explicitly asked for** fails
+ * loudly instead. The pure [selectEngine] decision is JVM-testable; [create] performs the device
+ * construction.
+ */
+object ModelRuntimeFactory {
+    /**
+     * Pure selection: honor [requested] (or [defaultEngine]) only if the variant supports it AND GenAI is
+     * available; otherwise Native (the floor).
+     */
+    fun selectEngine(
+        requested: InferenceEngine?,
+        supportedEngines: Set<String>,
+        defaultEngine: InferenceEngine,
+        genaiAvailable: Boolean,
+    ): InferenceEngine {
+        val want = requested ?: defaultEngine
+        val genaiOk =
+            want == InferenceEngine.GENAI &&
+                "genai" in supportedEngines &&
+                genaiAvailable
+        return if (genaiOk) InferenceEngine.GENAI else InferenceEngine.NATIVE
+    }
+
+    /**
+     * The engines a picker may offer for this package on this device — the same decision
+     * [selectEngine] makes, asked ahead of time.
+     *
+     * ### Why this is here and not in the facade
+     *
+     * `RuntimeCapabilities.availableEngines` used to be built inline in `MobileTransformers`, from
+     * **two** of the three conditions [selectEngine] applies: the package ships `genai_config.json`,
+     * and the native probe succeeds. It ignored the third — the manifest variant's `supportedEngines`.
+     *
+     * FunctionGemma is exactly the package that separates them. Its `inference/` stage carries a
+     * `genai_config.json` (optimum writes one), but its manifest declares `supportedEngines:
+     * ["native"]`, because Gemma-3 inference export goes through optimum's `main_export` rather than
+     * the vendored GenAI builder. So the facade advertised GenAI, the app's picker offered it, the
+     * user chose it, and [create] then refused it — correctly — with "explicitly requested but not
+     * selectable". The SDK contradicted itself within one load, and the app was blamed for it.
+     *
+     * Deriving both answers from one place is the fix; `EngineSelectionTest` asserts they agree for
+     * every combination of the three inputs.
+     *
+     * @param declaredEngines the manifest variant's declaration, or `null` when the package declares
+     *   none. Null stays permissive — an unknown declaration must not become a narrower one, which is
+     *   the same rule [create]'s default argument encodes.
+     */
+    fun enginesAvailableFor(
+        declaredEngines: Set<String>?,
+        genaiConfigPresent: Boolean,
+        genaiAvailable: Boolean,
+    ): Set<InferenceEngine> = buildSet {
+        add(InferenceEngine.NATIVE)
+        val selectable = selectEngine(
+            requested = InferenceEngine.GENAI,
+            supportedEngines = declaredEngines ?: setOf("native", "genai"),
+            defaultEngine = InferenceEngine.NATIVE,
+            genaiAvailable = genaiAvailable,
+        )
+        if (genaiConfigPresent && selectable == InferenceEngine.GENAI) add(InferenceEngine.GENAI)
+    }
+
+    /**
+     * Pure rule: may a GenAI that is unavailable or failed to load be silently replaced by Native?
+     *
+     * Only when the caller expressed no preference. `requested == null` means "pick for me", and Native
+     * is #11's guaranteed floor. Naming an engine and receiving a different one is a wrong answer, not a
+     * graceful degradation — see [create].
+     */
+    fun mayFallBackToNative(requested: InferenceEngine?): Boolean = requested != InferenceEngine.GENAI
+
+    /**
+     * Construct + load a [ModelRuntime] over one `inference/` package. [supportedEngines] comes from the
+     * manifest variant (#13); when unknown, pass both and let [GenAiSupport]/`config.engine` decide.
+     *
+     * **Fallback is conditional on who chose the engine.** When GenAI was auto-selected (the caller
+     * expressed no preference) a load failure falls through to Native, which is #11's guaranteed floor.
+     * When the caller *named* GenAI it is raised as [EngineUnavailableException].
+     *
+     * The unconditional version of this was a real defect, not a hypothetical one: genai_config.json
+     * carried a `config_entries` key that GenAI 0.14 rejects, so GenAI never loaded on any package the
+     * training stage touched — and nothing said so. `DualEngineParityTest` compared Native with Native
+     * and passed, and both `MemoryRssTest` rows recorded Native, so Gate 0.1 #1 and #4 were both read as
+     * proven off measurements of a single engine. A degradation nobody can observe is worse than a
+     * failure; asking for an engine and silently getting another one is not a floor, it is a lie.
+     */
+    suspend fun create(
+        cacheDir: String,
+        tokenizer: ORTTokenizerNative,
+        config: ORTGenerationConfig,
+        supportedEngines: Set<String> = setOf("native", "genai"),
+    ): ModelRuntime {
+        val engine = selectEngine(
+            config.engine, supportedEngines, InferenceEngine.NATIVE, GenAiSupport.available(),
+        )
+        val explicitlyRequested = !mayFallBackToNative(config.engine)
+        if (engine == InferenceEngine.GENAI) {
+            try {
+                return ORTGeneratorGenAI(cacheDir, tokenizer, config).also { it.load(cacheDir, config) }
+            } catch (e: Throwable) {
+                if (explicitlyRequested) {
+                    throw EngineUnavailableException(
+                        InferenceEngine.GENAI,
+                        "explicitly requested but failed to load from '$cacheDir': ${e.message}. " +
+                            "Not falling back to Native — that would silently answer a different " +
+                            "question than the one asked. Pass engine=null to allow the fallback.",
+                    )
+                }
+                Log.w("ModelRuntimeFactory", "GenAI engine unavailable, falling back to Native: ${e.message}")
+            }
+        } else if (explicitlyRequested) {
+            // Selection itself rejected GenAI (unsupported by the variant, or unavailable on this
+            // device). Same rule: the caller named it, so say so rather than quietly substituting.
+            throw EngineUnavailableException(
+                InferenceEngine.GENAI,
+                "explicitly requested but not selectable: supportedEngines=$supportedEngines, " +
+                    "genaiAvailable=${GenAiSupport.available()}. Pass engine=null to allow the fallback.",
+            )
+        }
+        return ORTGeneratorNative(cacheDir, tokenizer, config).also { it.load(cacheDir, config) }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelSession.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelSession.kt
new file mode 100644
index 0000000..d477262
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/ModelSession.kt
@@ -0,0 +1,108 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import com.martinkorelic.mobiletransformers.GenerateCallback
+import com.martinkorelic.mobiletransformers.RetrieveCallback
+import com.martinkorelic.mobiletransformers.TrainCallback
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedRoundResult
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.PromptStrategy
+import com.martinkorelic.mobiletransformers.training.TrainingJob
+
+/**
+ * The internal whole-model contract the facade delegates to (#17, extended by #19). This is
+ * **`ModelSession`**, NOT #11's engine-level `ModelRuntime` (`load/generate/release`) — this is the
+ * facade-level `applyPeft/train/merge/generate/retrieve` surface. `RepositoryBackedModelSession` is the
+ * only implementation; it never talks to a concrete engine, delegating generation to whichever engine
+ * #11's `ModelRuntimeFactory` selected.
+ */
+interface ModelSession {
+    val capabilities: RuntimeCapabilities
+
+    /** #19: select/validate the PEFT method against what the installed package supports. No native call. */
+    suspend fun applyPeft(peft: PeftConfig)
+
+    suspend fun train(dataset: DatasetConfig, config: TrainConfig, callback: TrainCallback? = null): TrainingResult
+
+    /**
+     * The lifecycle-shaped training handle for this model (#18): `status`/`events` flows, cooperative
+     * `cancel`, and `checkpoint`/`canResume`.
+     *
+     * [train] remains the one-shot convenience. Without this accessor the whole `training/` package
+     * (`TrainingJob`, `TrainingJobManager`, `TrainingStatus`, `TrainingEvent`, `TrainingEventAdapter`)
+     * was unreachable from the public API — it had zero non-test callers — and there was no way to
+     * cancel a run at all.
+     */
+    fun trainingJob(): TrainingJob
+
+    suspend fun merge(): MergeResult
+
+    suspend fun generate(prompt: String, config: GenerationConfig, callback: GenerateCallback? = null): GenerationResult
+
+    suspend fun retrieve(query: String, config: RagConfig, callback: RetrieveCallback? = null): RetrievalResult
+
+    /** #26: ingest a `.txt`/`.md`/`.jsonl` file into the RAG vector store (chunk → embed → store). */
+    suspend fun ingest(path: String, config: RagConfig, progress: IngestionProgress? = null): IngestResult
+
+    /**
+     * #33: classify [text] with a sequence-classification package.
+     *
+     * The missing half of encoder support. Training an encoder worked end to end; running the result
+     * did not exist, so a fine-tuned classifier could never be asked anything. Fails closed when the
+     * package is not a classifier or does not name its labels — `RuntimeCapabilities.supportsClassification`
+     * is the question to ask first.
+     */
+    suspend fun classify(text: String, device: DeviceConfig, topK: Int): ClassificationResult
+
+    /**
+     * #27: retrieve → assemble prompt → generate; the assembled prompt is returned for inspection.
+     *
+     * [callback] observes the GENERATION leg only — retrieval is over by the time it fires, so its
+     * first event is also the signal that the retrieve half finished. Without it a grounded answer
+     * was the one path in the SDK that produced nothing at all until it was completely done, which
+     * on a phone is tens of seconds of a screen that cannot be told apart from a hang.
+     *
+     * [retrieveCallback] observes the retrieve leg, and delivers the matches at the moment they are
+     * found rather than at the end of the whole turn. That ordering is the point: what was retrieved
+     * is knowable, and worth showing, long before the answer built on it exists.
+     */
+    suspend fun generateWithRag(
+        query: String,
+        rag: RagConfig,
+        generation: GenerationConfig,
+        promptStrategy: PromptStrategy,
+        callback: GenerateCallback? = null,
+        retrieveCallback: RetrieveCallback? = null,
+    ): GroundedResult
+
+    /** #19 surface; throws `NotImplementedFeatureException` until the #22 adapter push-back lands. */
+    suspend fun pushAdapter(hubConfig: HubConfig, repoId: String): PushResult
+
+    /**
+     * #35/#36: run one federated round — import the global adapter, train locally, export the update.
+     *
+     * #17/#19 gap: `FederatedTrainingRepository.forSession` is `internal`, and assembling one by hand
+     * needs `FederatedRound` + `NativeCheckpointTensorStore(trainer: ORTTrainerNative)`. So federation
+     * was **entirely unreachable** from the public API — the only shipped capability with no facade
+     * door at all. Exposed here as one round in, one [FederatedRoundResult] out, so the caller never
+     * names a repository or a native handle.
+     */
+    suspend fun federatedRound(
+        config: FederatedConfig,
+        globalRecord: ByteArray?,
+        roundNumber: Int,
+        localTraining: LocalRoundTraining,
+        metrics: Map<String, Double> = emptyMap(),
+        train: Boolean = true,
+    ): FederatedRoundResult
+
+    fun close()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/Results.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/Results.kt
new file mode 100644
index 0000000..ccba443
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/Results.kt
@@ -0,0 +1,177 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+/**
+ * Public result types returned by the facade (#17). They wrap the existing callback payloads
+ * (`TrainingProgress`, `InferenceProgress`, `RagResult`) without leaking the `ORT*`/`*Native` types.
+ *
+ * NOTE: [TrainingResult] is the SAME type #18 enriches (it adds `checkpoint`/`summary` fields) — it is not
+ * a second type. #24 refines generation metrics over [GenerationResult].
+ */
+
+data class TrainingResult(
+    val finalStep: Int = 0,
+    val finalEpoch: Int = 0,
+    val finalLoss: Float = 0f,
+    val totalDurationMs: Long = 0L,
+    val merged: Boolean = false,
+    // Enriched by #18 (training lifecycle). Null until a checkpoint/summary is available.
+    val checkpoint: com.martinkorelic.mobiletransformers.training.CheckpointInfo? = null,
+    val summary: TrainingSummary? = null,
+)
+
+/**
+ * Public mirror of the run-level training metrics (#17).
+ *
+ * This field used to be typed `ORTTrainerNative.TrainingSummary` — a nested type of the JNI-holding
+ * class — on [TrainingResult], which `MobileTransformerModel.train()` returns. That put an `ORT*`
+ * type on the public surface, contradicting this file's own contract above. The payload is eight
+ * plain scalars, so mirroring costs nothing; field names are also normalized to Kotlin camelCase.
+ */
+data class TrainingSummary(
+    val trainRuntimeSeconds: Float = 0f,
+    val trainStepsPerSecond: Float = 0f,
+    val trainSamplesPerSecond: Float = 0f,
+    val totalSteps: Int = 0,
+    val totalSamples: Int = 0,
+    val finalLoss: Float = 0f,
+    val peakMemoryMb: Long = 0L,
+    val averageMemoryMb: Float = 0f,
+)
+
+data class MergeResult(
+    val merged: Boolean,
+    /** Path to the inference-ready package produced by the handoff-validated merge (#8/#9). */
+    val inferencePackagePath: String? = null,
+)
+
+data class GenerationResult(
+    val text: String,
+    val tokenCount: Int = 0,
+    val generationTimeMs: Long = 0L,
+    val avgTokensPerSecond: Double = 0.0,
+    /** Tokens the prompt occupied, after templating and after any trim. */
+    val promptTokenCount: Int = 0,
+    /** Tokens the model can attend to at once, or 0 when the package declares none. */
+    val contextLimit: Int = 0,
+) {
+    /**
+     * Prompt plus completion — what this turn left in the window.
+     *
+     * The pair (this, [contextLimit]) is the honest form of "how much context is used". Reporting
+     * only the completion length, which is all `tokenCount` gives, understates it by the whole
+     * conversation so far.
+     */
+    val contextUsedTokens: Int get() = promptTokenCount + tokenCount
+
+    /** Fraction of the window consumed, or null when the package declares no limit. */
+    val contextUsedFraction: Float?
+        get() = if (contextLimit > 0) contextUsedTokens.toFloat() / contextLimit else null
+}
+
+/**
+ * One retrieved passage: the chunk text, how close it was, and **where it came from**.
+ *
+ * ### Why the provenance fields exist
+ *
+ * A match is a *chunk*, not a document — ingestion splits each file into `chunkSize` pieces and
+ * stores each one separately, keeping the source file's name as its title and `<docId>#<n>` as its
+ * id. Both survive all the way into the vector store and were then dropped at this boundary, which
+ * left every caller able to show the retrieved text and unable to say what it was retrieved *from*.
+ * "Found in 2 documents" is not derivable from text and score alone, and neither is the far more
+ * important question a user actually asks of a grounded answer: which of my files did this come from.
+ *
+ * Both default to empty so a caller constructing a match by hand (a test, a fake store) keeps
+ * compiling, and so a hit from a store that predates them degrades to "unattributed" rather than
+ * failing.
+ */
+data class RetrievalMatch(
+    val text: String,
+    val score: Double,
+    /** The source document's title — the ingested file's name (`notes.md`), when it is known. */
+    val title: String = "",
+    /** The chunk's own id, `<documentId>#<chunkIndex>`, e.g. `notes#3`. */
+    val chunkId: String = "",
+) {
+    /**
+     * The id of the DOCUMENT this chunk came from, i.e. [chunkId] without its `#<n>` suffix.
+     *
+     * `substringBeforeLast`, because an ingested id may legitimately contain a `#` of its own (a
+     * JSONL record may name itself anything) and only the last one is the chunk index.
+     */
+    val documentId: String get() = chunkId.substringBeforeLast('#', chunkId)
+}
+
+data class RetrievalResult(
+    val matches: List<RetrievalMatch> = emptyList(),
+    val queryTimeMs: Long = 0L,
+) {
+    /**
+     * How many distinct documents these passages came from.
+     *
+     * Grouped by [RetrievalMatch.title] rather than by id: the title is what a user recognises, and
+     * two chunks of one file share it. Falls back to counting unattributed matches individually,
+     * since nothing lets us claim they are the same source.
+     */
+    val documentCount: Int
+        get() = matches.count { it.title.isBlank() } +
+            matches.mapNotNull { it.title.takeIf(String::isNotBlank) }.distinct().size
+
+    /** The distinct source titles, in the order their best-scoring passage appeared. */
+    val documentTitles: List<String>
+        get() = matches.mapNotNull { it.title.takeIf(String::isNotBlank) }.distinct()
+}
+
+/** Result of pushing a trained adapter to the Hub (#19 surface; real upload lands with #22). */
+data class PushResult(
+    val repoId: String,
+    val url: String? = null,
+)
+
+/** Result of ingesting documents into the RAG vector store (#26). */
+data class IngestResult(
+    val chunkCount: Int,
+)
+
+/** One class the head predicts, with the probability assigned to it. */
+data class LabelScore(
+    /** The package's own name for this class, from `id2label`. */
+    val label: String,
+    /** Softmax probability in `0.0..1.0`. */
+    val score: Double,
+    /** The class index, kept because a label name need not be unique or stable across exports. */
+    val index: Int,
+)
+
+/**
+ * Result of sequence classification (#33).
+ *
+ * Encoder fine-tuning worked end to end and the resulting model could not be *run* — the facade had
+ * generate/retrieve/ingest/train and nothing that returns a class. Training a classifier and then
+ * being unable to ask it anything is what this closes.
+ */
+data class ClassificationResult(
+    /** Every class, highest probability first. */
+    val scores: List<LabelScore> = emptyList(),
+    /** How many entries a caller asked to see; [top] is capped by it. */
+    val topK: Int = 5,
+) {
+    /** The predicted class, or `null` for a head with no labels. */
+    val best: LabelScore? get() = scores.firstOrNull()
+
+    val top: List<LabelScore> get() = scores.take(topK.coerceAtLeast(1))
+}
+
+/** Result of grounded generation (#27): the answer, the retrieved matches, and the exact assembled prompt. */
+data class GroundedResult(
+    val text: String,
+    val matches: List<RetrievalMatch> = emptyList(),
+    val prompt: String = "",
+    /**
+     * The underlying generation, including its token counts.
+     *
+     * A grounded turn consumes *more* context than an ungrained one — that is the whole point of the
+     * assembled prompt — so it is the turn where "how much of the window is left" matters most, and
+     * it was the one path that reported nothing.
+     */
+    val generation: GenerationResult? = null,
+)
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/RuntimeCapabilities.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/RuntimeCapabilities.kt
new file mode 100644
index 0000000..d6db992
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/runtime/RuntimeCapabilities.kt
@@ -0,0 +1,119 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+
+/**
+ * Model-level capability flags (#17). Distinct from #11's engine-level `EngineCapabilities`: these describe
+ * what the whole [com.martinkorelic.mobiletransformers.MobileTransformerModel] can do, derived directly from
+ * `LLMRepository.isTrainingAvailable/isGenerationAvailable/isRagAvailable` + the selected engine.
+ */
+data class RuntimeCapabilities(
+    val engine: InferenceEngine,
+    val supportsTraining: Boolean,
+    val supportsMerge: Boolean,
+    val supportsRag: Boolean,
+    val supportsEmbedding: Boolean,
+    /** #34: `TrainingScheduler.schedule()` can run charging-constrained chunks for this model. */
+    val supportsScheduledTraining: Boolean = false,
+    val supportsAdapterTensorExport: Boolean = false, // future (#35/#36)
+    val availableFeatures: Set<ModelFeature> = emptySet(),
+    /**
+     * The engines this package can actually be run with **on this device**, which is what an engine
+     * picker must offer.
+     *
+     * #17/#19 gap found building the showcase app's Chat screen. `engine` said which engine this
+     * handle resolved to, but nothing said which *others* were selectable, so a picker could only
+     * offer both and discover the answer by catching `EngineUnavailableException` — i.e. by using an
+     * exception as control flow for a question the SDK already knows the answer to.
+     *
+     * Always contains [InferenceEngine.NATIVE]: it is #11's guaranteed floor. It contains
+     * [InferenceEngine.GENAI] only when the installed package ships `inference/genai_config.json`
+     * **and** the GenAI native probe succeeds — the same two conditions `ModelRuntimeFactory` applies,
+     * so offering an engine from this set and then being refused it would be a bug in one of them.
+     */
+    val availableEngines: Set<InferenceEngine> = setOf(InferenceEngine.NATIVE),
+    /**
+     * What objective this package's inference graph was exported for.
+     *
+     * Until this existed, capabilities answered only "can it train / retrieve / run GenAI" and never
+     * "what kind of model is it", so a sequence-classification encoder was indistinguishable from a
+     * chat decoder to every caller. An app could only find out by asking for generation and reading
+     * the failure. Read from the `inference/optimum_config.json` the exporter has always written —
+     * see [com.martinkorelic.mobiletransformers.packages.PackageTask].
+     */
+    val task: com.martinkorelic.mobiletransformers.packages.PackageTask =
+        com.martinkorelic.mobiletransformers.packages.PackageTask.UNKNOWN,
+    /**
+     * Whether this model was trained to emit tool calls, and in which grammar.
+     *
+     * Read from the package's own chat template — see
+     * [com.martinkorelic.mobiletransformers.packages.ToolCallSupport]. Two things depended on
+     * knowing this and neither could: `generateToolCall` chose its parser by looking for the string
+     * `"functiongemma"` in the *architecture* name (`gemma3_text`), and an app had no way to tell a
+     * user which of its models can call tools at all.
+     */
+    val toolCalling: com.martinkorelic.mobiletransformers.packages.ToolCallSupport =
+        com.martinkorelic.mobiletransformers.packages.ToolCallSupport.NONE,
+    /**
+     * Every parameter this package's training graph materialises, or 0 when it declares none.
+     *
+     * Exposed because it is the input to
+     * [com.martinkorelic.mobiletransformers.runtime.MemoryHeadroom] — the only way an app can warn a
+     * user that a run will not fit **before** Android kills the process for it, which it does with
+     * SIGKILL and no recoverable error. The exporter has written this since the training stage
+     * existed and nothing on the device read it.
+     */
+    val trainingParameterCount: Long = 0L,
+    /**
+ * The PEFT method(s) this package was exported for — `lora`, `lora-xs`, `mars`, …
+     *
+ * The exporter has recorded this in the manifest since the training stage existed and nothing on
+ * the device read it, so an app could not tell a MARS package from a LoRA one. That matters most
+ * for MARS, which is this project's own contribution: someone watching the fine-tuning demo could
+ * not see which technique they were watching.
+     *
+ * Empty for a package with no training stage, and for older exports that predate the field —
+ * absence means "not declared", never "no PEFT".
+ */
+    val peftMethods: Set<String> = emptySet(),
+) {
+    /**
+ * The PEFT method to show when there is room for exactly one, or `null` when none is declared.
+     *
+ * Every package produced so far declares a single method; the field is a list because the format
+ * allows more, not because a package has ever had two.
+ */
+    val primaryPeftMethod: String? get() = peftMethods.firstOrNull()
+
+    /** The precision measured in the shipped graph — see [PackageTask.inferenceGraphPrecision]. */
+    val graphPrecision: String? get() = task.inferenceGraphPrecision
+
+    /** This model has a tool-call grammar of its own; asking it for a call is reasonable. */
+    val supportsToolCalling: Boolean get() = toolCalling.supported
+
+    /** This package predicts a class per input rather than generating tokens. */
+    val isClassifier: Boolean get() = task.isClassifier
+
+    /**
+ * This package has no generative head at all, so nothing that produces tokens can work with it.
+     *
+ * Broader than [isClassifier] on purpose. A plain embedding model (`feature-extraction`, e.g.
+ * `all-MiniLM-L6-v2` on its own) is not a classifier and cannot generate either — a check that
+ * tested only for classifiers offered it a chat box, which is a promise the package cannot keep.
+ * An UNKNOWN task is deliberately not included: an older package that declares nothing must keep
+ * working, and withholding generation from it would be a narrower answer than the evidence
+ * supports.
+ */
+    val isEncoderOnly: Boolean
+    get() = task.isClassifier ||
+    task.taskType == com.martinkorelic.mobiletransformers.constants.TaskType.FEATURE_EXTRACTION
+
+    /**
+     * `classify()` will work: the package is a classifier **and** it names its labels.
+     *
+     * Both halves are required. A classification graph whose labels are unknown can still be run,
+     * but every prediction comes back as `LABEL_3` — which is a number in a costume, not an answer,
+     * so the honest report is that the capability is not usable on this package.
+     */
+    val supportsClassification: Boolean get() = task.isClassifier && task.labelCount > 0
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/ThermalGuard.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/ThermalGuard.kt
new file mode 100644
index 0000000..6654d3f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/ThermalGuard.kt
@@ -0,0 +1,77 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import android.content.Context
+import android.os.BatteryManager
+import android.os.Build
+import android.os.PowerManager
+
+/**
+ * #34: the device-state readings a scheduled chunk records and acts on.
+ *
+ * The plan's framing is that **the measurement is the contribution**, so this is not only a gate —
+ * every chunk emits a [ThermalSample] into the run log, which is what the thermal/energy trace is
+ * made of. Keeping the *decision* pure ([shouldPause]) lets it be asserted on a host, while the
+ * *reading* stays a thin platform call.
+ */
+data class ThermalSample(
+    /** [PowerManager.getCurrentThermalStatus], or -1 when the platform predates API 29. */
+    val thermalStatus: Int,
+    /** Battery charge 0..100, or -1 when unavailable. */
+    val batteryPercent: Int,
+    /** Battery temperature in tenths of a degree C, or -1 when unavailable. */
+    val batteryTemperatureDeciC: Int,
+    /** Cumulative charge counter in µAh, or -1. Differenced across chunks it gives energy drawn. */
+    val chargeCounterMicroAh: Long,
+    val timestampMillis: Long,
+) {
+    /** One CSV row, in the `docs/mobile_evaluation.md` style. */
+    fun toCsvRow(chunk: Int, globalStep: Int): String =
+        "$timestampMillis,$chunk,$globalStep,$thermalStatus,$batteryPercent," +
+            "$batteryTemperatureDeciC,$chargeCounterMicroAh"
+
+    companion object {
+        const val CSV_HEADER =
+            "timestampMillis,chunk,globalStep,thermalStatus,batteryPercent," +
+                "batteryTemperatureDeciC,chargeCounterMicroAh"
+    }
+}
+
+object ThermalGuard {
+
+    /**
+     * Pause the run at [PowerManager.THERMAL_STATUS_SEVERE] or worse.
+     *
+     * Pure, so the boundary is asserted rather than assumed. `-1` (pre-API-29, no reading) does NOT
+     * pause: refusing to train because the platform is too old to tell us the temperature would make
+     * the feature unavailable on exactly the devices it is meant for.
+     */
+    fun shouldPause(thermalStatus: Int): Boolean =
+        thermalStatus >= PowerManager.THERMAL_STATUS_SEVERE
+
+    fun sample(context: Context, nowMillis: Long = System.currentTimeMillis()): ThermalSample {
+        val power = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
+        val battery = context.getSystemService(Context.BATTERY_SERVICE) as? BatteryManager
+
+        val thermal =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && power != null) {
+                power.currentThermalStatus
+            } else {
+                -1
+            }
+
+        return ThermalSample(
+            thermalStatus = thermal,
+            batteryPercent = battery?.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY) ?: -1,
+            batteryTemperatureDeciC = readBatteryTemperature(context),
+            chargeCounterMicroAh =
+                battery?.getLongProperty(BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER) ?: -1L,
+            timestampMillis = nowMillis,
+        )
+    }
+
+    private fun readBatteryTemperature(context: Context): Int {
+        val intent =
+            context.registerReceiver(null, android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED))
+        return intent?.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, -1) ?: -1
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfig.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfig.kt
new file mode 100644
index 0000000..ed0c4e8
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfig.kt
@@ -0,0 +1,97 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import androidx.work.Constraints
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+
+/**
+ * #34: when a scheduled training chunk is allowed to run, and how big it is.
+ *
+ * The framing this plan insists on is "train safely when constraints allow, checkpoint, resume" —
+ * **not** invisible background training. Every field here is either a device-state precondition or a
+ * bound on how much work one chunk may do before it must checkpoint.
+ *
+ * This is pure data with two pure mappings ([toConstraints], [applyTo]) so both can be asserted on a
+ * host; the worker that consumes them is the device leg.
+ */
+data class TrainingScheduleConfig(
+    /** Only run while plugged in. The whole point of the feature. */
+    val requiresCharging: Boolean = true,
+    /** Also wait for device idle. Off by default: it makes a short demo run untestable. */
+    val requiresDeviceIdle: Boolean = false,
+    /** Never run the battery down past the system's "low" threshold. */
+    val requiresBatteryNotLow: Boolean = true,
+    /** Wall-clock bound on one chunk. */
+    val maxRuntimeMinutes: Int = 30,
+    /** Step bound on one chunk. Whichever bound is hit first ends the chunk — and it checkpoints. */
+    val maxStepsPerChunk: Int = 50,
+    /** Maps onto [ORTTrainingConfig.saveSteps]: how often the native loop persists mid-chunk. */
+    val checkpointEverySteps: Int = 50,
+    /** Total steps the whole job should reach across all chunks; null = run the configured epochs out. */
+    val totalSteps: Int? = null,
+    /**
+     * Earliest the **first** chunk may start, in minutes from `schedule()`. 0 = as soon as the
+     * constraints allow.
+     *
+     * ### What Android does and does not let you promise
+     *
+     * WorkManager's `setInitialDelay` is the only start-time control there is, and it is a **floor,
+     * not an appointment**: the system batches deferrable work, and Doze can hold it well past the
+     * delay. So "start at 02:00" is expressible as "not before 02:00" and nothing stronger. An exact
+     * wall-clock start would need `AlarmManager.setExactAndAllowWhileIdle` plus the
+     * `SCHEDULE_EXACT_ALARM` permission, which is the wrong trade for a multi-hour training job —
+     * exact alarms exist for alarm clocks and calendar reminders, and Google Play restricts them to
+     * that. The constraints ([requiresCharging] and friends) are the real gate anyway; a delay only
+     * moves the earliest moment they are consulted.
+     *
+     * Applied to the first chunk only. Chunk N+1 re-enqueues immediately and waits on constraints —
+     * re-delaying each chunk would stretch a run by the delay on every boundary.
+     */
+    val initialDelayMinutes: Long = 0L,
+    val notificationTitle: String = "Training",
+    val notificationChannelId: String = "mt_training",
+) {
+    init {
+        require(maxRuntimeMinutes > 0) { "maxRuntimeMinutes must be positive, was $maxRuntimeMinutes" }
+        require(maxStepsPerChunk > 0) { "maxStepsPerChunk must be positive, was $maxStepsPerChunk" }
+        require(checkpointEverySteps > 0) {
+            "checkpointEverySteps must be positive, was $checkpointEverySteps"
+        }
+        require(initialDelayMinutes >= 0) {
+            "initialDelayMinutes cannot be negative, was $initialDelayMinutes"
+        }
+    }
+
+    /** The WorkManager preconditions. Storage-not-low is unconditional: a checkpoint needs room. */
+    fun toConstraints(): Constraints =
+        Constraints.Builder()
+            .setRequiresCharging(requiresCharging)
+            .setRequiresDeviceIdle(requiresDeviceIdle)
+            .setRequiresBatteryNotLow(requiresBatteryNotLow)
+            .setRequiresStorageNotLow(true)
+            .build()
+
+    /**
+     * Bound one chunk of an existing training config.
+     *
+     * `loadFromState = true` is what makes chunk N+1 continue chunk N rather than restart it: it
+     * restores `globalStep`/`epoch` **and** the LR scheduler state from `training_state.json`.
+     * `saveModelAtEnd` guarantees the chunk boundary is itself a checkpoint. Merging is deliberately
+     * NOT done per chunk — merge is an end-of-job act, and doing it every chunk would rewrite every
+     * trainable tensor on disk each time.
+     */
+    fun applyTo(base: ORTTrainingConfig, resumedGlobalStep: Int = 0): ORTTrainingConfig =
+        base.copy(
+            // `maxSteps` is a CUMULATIVE target, not a per-chunk budget: `ORTTrainerNative` computes
+            // `totalSteps = maxSteps ?: epochs*stepsPerEpoch` and loops `while (globalStep < totalSteps)`
+            // AFTER restoring `globalStep` from `training_state.json`. Passing the chunk size directly
+            // therefore made every chunk after the first a no-op — chunk 2 restored globalStep=2, read
+            // "Training for 2 steps", found `2 < 2` false and exited having trained nothing, while
+            // still reporting success. Caught on device by `ScheduledTrainingDeviceTest`; the host
+            // tests could not see it because they exercise the LR arithmetic, not the loop bound.
+            maxSteps = resumedGlobalStep + maxStepsPerChunk,
+            saveSteps = checkpointEverySteps,
+            loadFromState = true,
+            saveModelAtEnd = true,
+            mergeWeightsAtEnd = false,
+        )
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduler.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduler.kt
new file mode 100644
index 0000000..bd73b59
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduler.kt
@@ -0,0 +1,339 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import android.content.Context
+import androidx.work.Data
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.workDataOf
+import com.martinkorelic.mobiletransformers.DatasetOptions
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.Tasks
+import com.martinkorelic.mobiletransformers.SchedulerConfig
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import java.io.File
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+/** Serializes [TrainingScheduleConfig] through WorkManager's [Data], which holds only primitives. */
+internal object TrainingScheduleConfigCodec {
+    private const val K_CHARGING = "requiresCharging"
+    private const val K_IDLE = "requiresDeviceIdle"
+    private const val K_BATTERY = "requiresBatteryNotLow"
+    private const val K_RUNTIME = "maxRuntimeMinutes"
+    private const val K_STEPS = "maxStepsPerChunk"
+    private const val K_CKPT = "checkpointEverySteps"
+    private const val K_TOTAL = "totalSteps"
+    private const val K_TITLE = "notificationTitle"
+    private const val K_CHANNEL = "notificationChannelId"
+    private const val K_DELAY = "initialDelayMinutes"
+
+    /**
+     * The input-data pairs for a chunk. Also used by the #34 device test so it builds the SAME input
+     * the scheduler does, rather than a parallel encoding that could drift from it.
+     */
+    fun toPairs(config: TrainingScheduleConfig): Array<Pair<String, Any?>> = arrayOf(
+        K_CHARGING to config.requiresCharging,
+        K_IDLE to config.requiresDeviceIdle,
+        K_BATTERY to config.requiresBatteryNotLow,
+        K_RUNTIME to config.maxRuntimeMinutes,
+        K_STEPS to config.maxStepsPerChunk,
+        K_CKPT to config.checkpointEverySteps,
+        // -1 encodes "no total": Data has no nullable Int.
+        K_TOTAL to (config.totalSteps ?: -1),
+        K_TITLE to config.notificationTitle,
+        K_CHANNEL to config.notificationChannelId,
+        K_DELAY to config.initialDelayMinutes,
+    )
+
+    fun fromData(data: Data): TrainingScheduleConfig {
+        val defaults = TrainingScheduleConfig()
+        val total = data.getInt(K_TOTAL, -1)
+        return TrainingScheduleConfig(
+            requiresCharging = data.getBoolean(K_CHARGING, defaults.requiresCharging),
+            requiresDeviceIdle = data.getBoolean(K_IDLE, defaults.requiresDeviceIdle),
+            requiresBatteryNotLow = data.getBoolean(K_BATTERY, defaults.requiresBatteryNotLow),
+            maxRuntimeMinutes = data.getInt(K_RUNTIME, defaults.maxRuntimeMinutes),
+            initialDelayMinutes = data.getLong(K_DELAY, defaults.initialDelayMinutes),
+            maxStepsPerChunk = data.getInt(K_STEPS, defaults.maxStepsPerChunk),
+            checkpointEverySteps = data.getInt(K_CKPT, defaults.checkpointEverySteps),
+            totalSteps = if (total <= 0) null else total,
+            notificationTitle = data.getString(K_TITLE) ?: defaults.notificationTitle,
+            notificationChannelId = data.getString(K_CHANNEL) ?: defaults.notificationChannelId,
+        )
+    }
+}
+
+/**
+ * Serializes the **job** — what to train on — through WorkManager's [Data].
+ *
+ * Distinct from [TrainingScheduleConfigCodec], which carries *when* a chunk may run. The two are
+ * genuinely different concerns, and only this one has to survive process death: `TrainingJobSpec` is
+ * documented as "a reconstructable description of a training job", and a worker rebuilt hours later
+ * has nothing but its input `Data` to rebuild from.
+ *
+ * That is why the fields are enumerated rather than handed to a general object serializer. The sealed
+ * [SchedulerConfig] has no single JSON shape, and — the real constraint —
+ * [ORTTrainingConfig.customPreprocess] is a **lambda**, which cannot be serialized at all. A scheduled
+ * job must therefore name a registered task; [TrainingScheduler.schedule] rejects a custom
+ * preprocessor up front rather than letting the worker discover it after a reboot.
+ */
+internal object TrainingJobCodec {
+    private const val K_TASK = "taskName"
+    private const val K_ONNX = "onnxName"
+    private const val K_TRAIN_FILE = "trainFile"
+    private const val K_BATCH = "batchSize"
+    private const val K_EPOCHS = "numTrainEpochs"
+    private const val K_GRAD_ACCUM = "gradAccumSteps"
+    private const val K_DS_BATCH = "datasetBatchSize"
+    private const val K_MAX_SEQ = "maxSequenceLength"
+    private const val K_MAX_LEN = "maxDatasetLength"
+    private const val K_SCHED_TYPE = "schedulerType"
+    private const val K_LR = "learningRate"
+    private const val K_MIN_LR = "minLearningRate"
+    private const val K_WARMUP = "warmupSteps"
+
+    fun toPairs(config: ORTTrainingConfig): Array<Pair<String, Any?>> {
+        val scheduler = config.schedulerConfig
+        return arrayOf(
+            K_TASK to config.taskName,
+            K_ONNX to config.onnxName,
+            K_TRAIN_FILE to config.datasetOptions.trainFile,
+            K_BATCH to config.batchSize,
+            K_EPOCHS to config.numTrainEpochs,
+            K_GRAD_ACCUM to config.gradAccumSteps,
+            K_DS_BATCH to (config.datasetOptions.datasetBatchSize ?: -1),
+            K_MAX_SEQ to (config.datasetOptions.maxSequenceLength ?: -1),
+            K_MAX_LEN to (config.datasetOptions.maxDatasetLength ?: -1),
+            K_SCHED_TYPE to config.schedulerType,
+            K_LR to config.learningRate,
+            K_MIN_LR to (scheduler as? SchedulerConfig.Cosine)?.minLearningRate,
+            K_WARMUP to (scheduler as? SchedulerConfig.Cosine)?.warmupSteps,
+        )
+    }
+
+    fun fromData(data: Data, repoId: String): ORTTrainingConfig {
+        val defaults = ORTTrainingConfig()
+        val schedulerType = data.getString(K_SCHED_TYPE) ?: defaults.schedulerType
+        val learningRate = data.getFloat(K_LR, defaults.learningRate)
+        return ORTTrainingConfig(
+            repoName = repoId,
+            onnxName = data.getString(K_ONNX) ?: defaults.onnxName,
+            taskName = data.getString(K_TASK) ?: defaults.taskName,
+            batchSize = data.getInt(K_BATCH, defaults.batchSize),
+            numTrainEpochs = data.getInt(K_EPOCHS, defaults.numTrainEpochs),
+            gradAccumSteps = data.getInt(K_GRAD_ACCUM, defaults.gradAccumSteps),
+            datasetOptions = DatasetOptions(
+                trainFile = data.getString(K_TRAIN_FILE) ?: defaults.datasetOptions.trainFile,
+                datasetBatchSize = data.getInt(K_DS_BATCH, -1).takeIf { it > 0 },
+                maxSequenceLength = data.getInt(K_MAX_SEQ, -1).takeIf { it > 0 },
+                maxDatasetLength = data.getInt(K_MAX_LEN, -1).takeIf { it > 0 },
+            ),
+            schedulerType = schedulerType,
+            schedulerConfig = if (schedulerType.equals("cosine", ignoreCase = true)) {
+                SchedulerConfig.Cosine(
+                    learningRate = learningRate,
+                    minLearningRate = data.getFloat(K_MIN_LR, 0f),
+                    warmupSteps = data.getInt(K_WARMUP, 10),
+                )
+            } else {
+                SchedulerConfig.Linear(learningRate = learningRate)
+            },
+        )
+    }
+}
+
+/**
+ * #34: enqueue charging-constrained training chunks and observe them.
+ *
+ * Unique per model, `ExistingWorkPolicy.KEEP` — the same reason [
+ * com.martinkorelic.mobiletransformers.hub.PackageDownloadWorker] is unique per repo id: a second
+ * `schedule` for a model already training must not start a second native session against the same
+ * checkpoint. That, plus `LLMRepository.sessionLock` inside the worker's own load path, is what keeps
+ * a scheduled chunk from racing a foreground train/merge/generate.
+ */
+object TrainingScheduler {
+
+    /** Stable unique-work name so a repeat schedule for one model coalesces. */
+    fun uniqueWorkName(repoId: String): String =
+        "mobiletransformers-training:${PackageFormat.sanitizeRepoId(repoId)}"
+
+    /**
+     * Schedule chunk 1. Later chunks are chained by [TrainingWorker] itself, so each one re-enters
+     * the WorkManager queue and its constraints are **re-evaluated** — unplug between chunks and the
+     * next one waits.
+     */
+    fun schedule(
+        context: Context,
+        repoId: String,
+        training: ORTTrainingConfig,
+        cacheDir: File = context.filesDir,
+        config: TrainingScheduleConfig = TrainingScheduleConfig(),
+    ): UUID {
+        // Fail here, not hours later inside a rebuilt worker. A lambda cannot be serialized into
+        // WorkManager's Data, so a scheduled job must name a task the preprocessor registry knows.
+        require(training.customPreprocess == null) {
+            "scheduled training cannot use a customPreprocess lambda: a chunk may be rebuilt after " +
+                "process death from its input Data alone. Use a registered taskName instead."
+        }
+        return enqueueChunk(context, repoId, cacheDir.absolutePath, config, training, chunk = 1)
+    }
+
+    /**
+     * Schedule charging-cycle training from the **public** config types.
+     *
+     * #17/#19 gap found building the showcase app's Train screen: the only `schedule` overload took an
+     * `ORTTrainingConfig`, so #34's scheduler — which `RuntimeCapabilities.supportsScheduledTraining`
+     * advertises through the facade — could not be driven by a facade-only app at all. A capability the
+     * public API advertises has to be reachable from the public API.
+     *
+     * The `customPreprocess == null` precondition the other overload enforces is satisfied by
+     * construction here: [DatasetConfig] names a registered task rather than carrying a lambda, which
+     * is exactly what a chunk rebuilt from `Data` after process death needs.
+     *
+     * @param base the package's own training config, used for the fields `TrainConfig` does not carry
+     *   (`repoName`, `onnxName`). Pass `LLMRepository.trainingConfig`'s equivalent from the facade.
+     */
+    fun schedule(
+        context: Context,
+        repoId: String,
+        dataset: DatasetConfig,
+        training: TrainConfig = TrainConfig(),
+        base: ORTTrainingConfig = ORTTrainingConfig(repoName = repoId),
+        cacheDir: File = context.filesDir,
+        config: TrainingScheduleConfig = TrainingScheduleConfig(),
+    ): UUID =
+        schedule(
+            context = context,
+            repoId = repoId,
+            training = training.toOrt(base).copy(
+                datasetOptions = dataset.toOrt(),
+                // Rejected at SCHEDULE time. A chunk only runs once the device is charging and
+                // idle, so an unresolvable task discovered inside the worker surfaces hours later,
+                // as a failed background job nobody was watching.
+                taskName = Tasks.resolve(dataset.task, base.taskName),
+            ),
+            cacheDir = cacheDir,
+            config = config,
+        )
+
+    internal fun enqueueChunk(
+        context: Context,
+        repoId: String,
+        cacheDir: String,
+        config: TrainingScheduleConfig,
+        training: ORTTrainingConfig,
+        chunk: Int,
+    ): UUID {
+        val request = OneTimeWorkRequestBuilder<TrainingWorker>()
+            .setConstraints(config.toConstraints())
+            // First chunk only: the delay is "do not start before", and re-applying it to every
+            // chunk would add it again at each boundary, stretching a 10-chunk run by 10x the delay.
+            .apply {
+                if (chunk == 1 && config.initialDelayMinutes > 0) {
+                    setInitialDelay(config.initialDelayMinutes, TimeUnit.MINUTES)
+                }
+            }
+            .setInputData(
+                workDataOf(
+                    *TrainingScheduleConfigCodec.toPairs(config),
+                    *TrainingJobCodec.toPairs(training),
+                    TrainingWorker.KEY_REPO_ID to repoId,
+                    TrainingWorker.KEY_CACHE_DIR to cacheDir,
+                    TrainingWorker.KEY_CHUNK to chunk,
+                ),
+            )
+            // The chunk's own wall-clock bound. WorkManager stops the worker at this point, which
+            // routes through onStopped() -> cooperative cancel -> checkpoint.
+            .setBackoffCriteria(
+                androidx.work.BackoffPolicy.LINEAR,
+                config.maxRuntimeMinutes.toLong(),
+                TimeUnit.MINUTES,
+            )
+            .build()
+
+        WorkManager.getInstance(context).enqueueUniqueWork(
+            uniqueWorkName(repoId),
+            // REPLACE, not KEEP: chunk N+1 legitimately supersedes the finished chunk N under the
+            // same unique name. KEEP would drop every chunk after the first.
+            if (chunk == 1) ExistingWorkPolicy.KEEP else ExistingWorkPolicy.REPLACE,
+            request,
+        )
+        return request.id
+    }
+
+    /** Cancel the scheduled job. The running chunk checkpoints via `onStopped`. */
+    fun cancel(context: Context, repoId: String) {
+        WorkManager.getInstance(context).cancelUniqueWork(uniqueWorkName(repoId))
+    }
+
+    /** Observe chunk progress: the `globalStep` each finished chunk reported. */
+    fun observe(context: Context, repoId: String): Flow<List<WorkInfo>> =
+        WorkManager.getInstance(context)
+            .getWorkInfosForUniqueWorkFlow(uniqueWorkName(repoId))
+            .map { it }
+
+    /**
+     * The scheduled queue for [repoId], already interpreted.
+     *
+     * #17/#19 gap found building the showcase app's Schedule tab. [observe] returns
+     * `List<WorkInfo>` — a WorkManager type — so a facade-only app could not read the queue of a
+     * feature the facade advertises (`RuntimeCapabilities.supportsScheduledTraining`) without taking
+     * a direct dependency on `androidx.work` and decoding this object's own progress keys. It had no
+     * caller at all, which is why scheduling reported a UUID and nothing else.
+     *
+     * The interpretation belongs here rather than in each app: `ENQUEUED` is the state that matters
+     * and the one its own name explains worst — it means "accepted, and its charging/idle constraints
+     * are not met", an indefinite and entirely normal wait.
+     */
+    fun observeChunks(context: Context, repoId: String): Flow<List<ScheduledChunk>> =
+        observe(context, repoId).map { infos -> infos.map { it.toChunk() } }
+
+    private fun WorkInfo.toChunk(): ScheduledChunk =
+        ScheduledChunk(
+            state = when (state) {
+                WorkInfo.State.ENQUEUED -> ScheduledChunk.State.WaitingForConstraints
+                WorkInfo.State.RUNNING -> ScheduledChunk.State.Running
+                WorkInfo.State.SUCCEEDED -> ScheduledChunk.State.Finished
+                WorkInfo.State.FAILED -> ScheduledChunk.State.Failed
+                WorkInfo.State.BLOCKED -> ScheduledChunk.State.Blocked
+                WorkInfo.State.CANCELLED -> ScheduledChunk.State.Cancelled
+            },
+            chunk = progress.getInt(TrainingWorker.KEY_CHUNK, -1).takeIf { it > 0 }
+                ?: outputData.getInt(TrainingWorker.KEY_CHUNK, -1).takeIf { it > 0 },
+            globalStep = outputData.getInt(TrainingWorker.KEY_GLOBAL_STEP, -1).takeIf { it >= 0 },
+            stalled = outputData.getBoolean(TrainingWorker.KEY_STALLED, false),
+            error = outputData.getString(TrainingWorker.KEY_ERROR),
+        )
+}
+
+/**
+ * One scheduled training chunk, in terms a caller can render without knowing about WorkManager.
+ *
+ * @property stalled the chunk advanced no steps. The worker stops chaining when this happens — a
+ *   chunk that made no progress would otherwise re-enqueue forever — so it is the difference between
+ *   "the run paused" and "the run is over and achieved nothing".
+ */
+data class ScheduledChunk(
+    val state: State,
+    val chunk: Int?,
+    val globalStep: Int?,
+    val stalled: Boolean = false,
+    val error: String? = null,
+) {
+    enum class State {
+        /** Accepted; waiting for charging + idle. Indefinite, and entirely normal. */
+        WaitingForConstraints,
+        Running,
+        Finished,
+        Failed,
+        Blocked,
+        Cancelled,
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingWorker.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingWorker.kt
new file mode 100644
index 0000000..1861c7e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/scheduler/TrainingWorker.kt
@@ -0,0 +1,300 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.work.CoroutineWorker
+import androidx.work.Data
+import androidx.work.ForegroundInfo
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import com.martinkorelic.mobiletransformers.MobileTransformers
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.training.CheckpointInfo
+import com.martinkorelic.mobiletransformers.training.TrainingEvent
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+
+/**
+ * #34: one bounded training chunk, run as a foreground [CoroutineWorker] under charging/idle/
+ * battery-not-low constraints.
+ *
+ * The shape is copied from [com.martinkorelic.mobiletransformers.hub.PackageDownloadWorker] (#21),
+ * which is already the correct WorkManager idiom in this codebase — `CoroutineWorker` +
+ * `enqueueUniqueWork`. What is genuinely new here is the foreground service, the chunk/resume
+ * boundary, and the thermal/energy trace.
+ *
+ * ### One chunk
+ *
+ * ```
+ * setForeground(dataSync notification)          // Android 14+ requires a declared service type
+ * sample device state; pause (Result.retry) at THERMAL_STATUS_SEVERE
+ * fromPretrained(repoId)                        // rebuilds after process death from the spec alone
+ * trainingJob().start(config bounded by maxStepsPerChunk, loadFromState = true)
+ * append a thermal/energy trace row
+ * release; chain the next chunk if steps remain
+ * ```
+ *
+ * Resume across a chunk boundary and across process death is the SAME mechanism: `loadFromState`
+ * restores `globalStep`/`epoch` and the LR scheduler state from `training_state.json`. Nothing in
+ * `ORTTrainerNative` changed for this — the scheduler lives outside it, as the plan requires.
+ *
+ * The chunk **always** checkpoints before exiting, on success, stop and cancel alike:
+ * `saveModelAtEnd` covers the normal exit, and the cancellation path below covers the
+ * interrupted one via `TrainingJob.cancel(saveCheckpoint = true)`.
+ */
+class TrainingWorker(
+    private val context: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        val repoId = inputData.getString(KEY_REPO_ID) ?: return Result.failure(error("missing repoId"))
+        val cacheDir = inputData.getString(KEY_CACHE_DIR) ?: context.filesDir.absolutePath
+        val chunk = inputData.getInt(KEY_CHUNK, 1)
+        val config = TrainingScheduleConfigCodec.fromData(inputData)
+
+        // Promotion can legitimately be refused — Android 12+ throws
+        // ForegroundServiceStartNotAllowedException when the app is in the background, and a test
+        // runtime has nothing to promote to. A refused promotion must not lose the chunk: the work is
+        // bounded and checkpoints on exit either way, so log and carry on rather than dying.
+        runCatching { setForeground(foregroundInfo(config, chunk, progress = null)) }
+            .onFailure { Log.w(TAG, "could not promote chunk $chunk to foreground; continuing", it) }
+
+        // Read BEFORE any work: a chunk that starts hot has already lost.
+        val sample = ThermalGuard.sample(context)
+        if (ThermalGuard.shouldPause(sample.thermalStatus)) {
+            Log.i(TAG, "chunk $chunk paused: thermal status ${sample.thermalStatus}")
+            // retry, not failure: WorkManager re-runs this when the device has cooled and the
+            // constraints are met again. The checkpoint from the previous chunk is untouched.
+            return Result.retry()
+        }
+
+        var model: com.martinkorelic.mobiletransformers.MobileTransformerModel? = null
+        return try {
+            // Rebuilt from the spec alone — this is what makes the job survive process death.
+            model = MobileTransformers.fromPretrained(
+                context = context,
+                repoId = repoId,
+                cacheDir = cacheDir,
+                features = setOf(ModelFeature.Inference, ModelFeature.Training),
+            )
+            if (!model.capabilities.supportsTraining) {
+                return Result.failure(error("package '$repoId' has no train/ stage"))
+            }
+
+            val job = model.trainingJob()
+            // Read from `training_state.json` DIRECTLY, not via `job.checkpoint()`: that returns null
+            // until the native trainer exists, which it does not before `start()`. So it always read
+            // 0 here, which both broke the chunk budget below and made the `stalled` check downstream
+            // meaningless (anything > 0 looked like progress).
+            val stepsBefore = checkpointOnDisk(cacheDir, repoId)?.currentGlobalStep ?: 0
+
+            // WorkManager stopping us (constraint lost — unplugged — or cancelled) cancels this
+            // coroutine. `CoroutineWorker.onStopped` is final, so the cooperative stop is wired
+            // through the job handle instead: `TrainingJob.cancel` sets the native
+            // `cancelRequested` flag, the step loop breaks, and the existing save path persists a
+            // checkpoint. The chunk is never killed mid-step.
+            try {
+                // The ongoing notification used to be posted once, before the first step, and never
+                // touched again — `foregroundInfo` has always taken a `progress`, and the sole call
+                // site passed null. So a multi-hour run showed a static "Training chunk 1" with no
+                // sign it was alive. Feed it from the step stream instead.
+                coroutineScope {
+                    val reporter = launch { reportProgress(config, chunk, job) }
+            try {
+                job.start(
+                    config.applyTo(TrainingJobCodec.fromData(inputData, repoId), stepsBefore),
+                )
+        } finally {
+            // `events` is a SharedFlow and never completes, so the collector has to be
+            // cancelled or `coroutineScope` would never return.
+            reporter.cancel()
+        }
+        }
+            } catch (cancellation: kotlinx.coroutines.CancellationException) {
+                Log.i(TAG, "chunk $chunk stopped; checkpointing cooperatively")
+                withContext(NonCancellable) { job.cancel(saveCheckpoint = true) }
+                throw cancellation
+            }
+
+            val stepsAfter = checkpointOnDisk(cacheDir, repoId)?.currentGlobalStep ?: stepsBefore
+            appendTrace(cacheDir, repoId, chunk, stepsAfter, sample)
+            Log.i(TAG, "chunk $chunk: globalStep $stepsBefore -> $stepsAfter")
+
+            val done = config.totalSteps != null && stepsAfter >= config.totalSteps
+            // A chunk that advanced nothing is not progress; chaining again would spin forever.
+            val stalled = stepsAfter <= stepsBefore
+            if (!done && !stalled) {
+                TrainingScheduler.enqueueChunk(
+                    context, repoId, cacheDir, config,
+                    TrainingJobCodec.fromData(inputData, repoId), chunk + 1,
+                )
+            }
+            Result.success(
+                workDataOf(
+                    KEY_GLOBAL_STEP to stepsAfter,
+                    KEY_CHUNK to chunk,
+                    KEY_STALLED to stalled,
+                ),
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "chunk $chunk failed", e)
+            Result.failure(error(e.message ?: e::class.java.simpleName))
+        } finally {
+            runCatching { model?.close() }
+        }
+    }
+
+    private fun error(message: String): Data = workDataOf(KEY_ERROR to message)
+
+    /**
+     * The persisted checkpoint projection, read without a native trainer.
+     *
+     * The on-device cache layout is flat (`<cacheDir>/<repoId>/train/`), which is what
+     * `ModelPackageInstaller` produces and what `scripts/device_package.sh` pushes — NOT the hub
+     * package's `variants/<id>/train`. Centralised here so the worker has one place that knows it.
+     */
+    private fun checkpointOnDisk(cacheDir: String, repoId: String): CheckpointInfo? {
+        val trainDir = PackagePaths.forCache(cacheDir, repoId).train
+        if (!trainDir.isDirectory) return null
+        return CheckpointInfo.read(
+            File(trainDir, "checkpoint").absolutePath,
+            File(trainDir, "training_state.json").absolutePath,
+        )
+    }
+
+    private fun appendTrace(
+        cacheDir: String,
+        repoId: String,
+        chunk: Int,
+        globalStep: Int,
+        sample: ThermalSample,
+    ) {
+        // Per the plan, the traces ARE part of the deliverable, so they are written by the worker
+        // rather than reconstructed from logcat afterwards.
+        runCatching {
+            val file = File(File(cacheDir), "$repoId-training-trace.csv")
+            if (!file.exists()) file.writeText(ThermalSample.CSV_HEADER + "\n")
+            file.appendText(
+                ThermalGuard.sample(context).toCsvRow(chunk, globalStep) + "\n",
+            )
+        }
+    }
+
+    /**
+ * Drive the ongoing notification from the trainer's step stream for as long as the chunk runs.
+ *
+ * Throttled to whole percent changes, and to the step stream only. `setForeground` crosses a
+ * binder to the NotificationManager, and a training loop emits several events per optimizer step;
+ * posting each one would spend more time updating a notification than training.
+ *
+ * A null [TrainingScheduleConfig.totalSteps] means nobody declared a target, so there is no
+ * fraction to show — the notification keeps its indeterminate text rather than inventing one.
+ */
+    private suspend fun reportProgress(
+        config: TrainingScheduleConfig,
+        chunk: Int,
+        job: com.martinkorelic.mobiletransformers.training.TrainingJob,
+    ) {
+        val total = config.totalSteps?.takeIf { it > 0 } ?: return
+        var lastPercent = -1
+        job.events.collect { event ->
+            val progress = (event as? TrainingEvent.Step)?.progress ?: return@collect
+            val percent = percentComplete(progress.currentStep, total) ?: return@collect
+            if (percent == lastPercent) return@collect
+            lastPercent = percent
+
+            // Same reason as the initial promotion: a refused foreground update must not kill the
+            // chunk. Losing a notification frame is not worth losing the work.
+        runCatching {
+                setForeground(
+                    foregroundInfo(
+                        config,
+                        chunk,
+                        progress = percent,
+                        detail = "Step ${progress.currentStep}/$total · loss %.4f".format(progress.stepLoss),
+                ),
+            )
+            }.onFailure { Log.d(TAG, "notification update refused at $percent%", it) }
+        }
+        }
+
+    private fun foregroundInfo(
+        config: TrainingScheduleConfig,
+        chunk: Int,
+        progress: Int?,
+        detail: String? = null,
+    ): ForegroundInfo {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            manager.createNotificationChannel(
+                NotificationChannel(
+                    config.notificationChannelId,
+                    config.notificationTitle,
+                    NotificationManager.IMPORTANCE_LOW,
+                ),
+            )
+        }
+
+        val cancel: PendingIntent =
+            WorkManager.getInstance(context).createCancelPendingIntent(id)
+
+        val notification =
+            NotificationCompat.Builder(context, config.notificationChannelId)
+                .setContentTitle(config.notificationTitle)
+.setContentText(detail ?: "Training chunk $chunk")
+                .setSmallIcon(android.R.drawable.stat_sys_download)
+                .setOngoing(true)
+                .addAction(android.R.drawable.ic_delete, "Cancel", cancel)
+                .apply { if (progress != null) setProgress(100, progress, false) }
+                .build()
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            // API 34+ requires the service TYPE, and the manifest must declare the matching
+            // permission — in the LIBRARY, not by accident in the sample app.
+            ForegroundInfo(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+        } else {
+            ForegroundInfo(NOTIFICATION_ID, notification)
+        }
+    }
+
+    companion object {
+        private const val TAG = "MobileTransformers"
+        const val NOTIFICATION_ID = 4211
+
+    /**
+ * Whole-percent completion, or null when there is no meaningful fraction to show.
+ *
+ * `currentStep` is the CUMULATIVE global step — `ORTTrainerNative` sets it from `globalStep`,
+ * which is restored from `training_state.json` — and `TrainingScheduleConfig.totalSteps` is
+ * likewise a cumulative target. So this is the whole-run fraction, not the chunk's, and a
+ * resumed chunk 3 correctly opens at wherever chunk 2 left off rather than back at 0%.
+ *
+ * Clamped because a chunk can legitimately overshoot: `maxSteps` is `resumedGlobalStep +
+ * maxStepsPerChunk`, which the last chunk may carry past `totalSteps`.
+ */
+        internal fun percentComplete(currentStep: Int, totalSteps: Int?): Int? {
+            val total = totalSteps?.takeIf { it > 0 } ?: return null
+            if (currentStep < 0) return null
+            return ((currentStep.toLong() * 100L) / total).toInt().coerceIn(0, 100)
+        }
+
+        const val KEY_REPO_ID = "repoId"
+        const val KEY_CACHE_DIR = "cacheDir"
+        const val KEY_CHUNK = "chunk"
+        const val KEY_GLOBAL_STEP = "globalStep"
+        const val KEY_STALLED = "stalled"
+        const val KEY_ERROR = "error"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/CheckpointInfo.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/CheckpointInfo.kt
new file mode 100644
index 0000000..f6a8757
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/CheckpointInfo.kt
@@ -0,0 +1,46 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.google.gson.Gson
+import com.martinkorelic.mobiletransformers.TrainingState
+import java.io.File
+
+/**
+ * Read-only projection of `train/training_state.json` (#18). **No format change** — it parses the existing
+ * [TrainingState] (`{ schedulerState, currentGlobalStep, currentEpoch }`) written by
+ * `ORTTrainerNative.saveTrainingState` and projects the fields the public surface exposes. Reading never
+ * rewrites the file.
+ */
+data class CheckpointInfo(
+    val currentGlobalStep: Int,
+    val currentEpoch: Int,
+    val schedulerStep: Int,
+    val totalSteps: Int,
+    val checkpointDirPath: String,
+    val stateJsonPath: String,
+    val exists: Boolean,
+) {
+    companion object {
+        private val gson = Gson()
+
+        /**
+         * Project the checkpoint at [checkpointDirPath] with its sibling [stateJsonPath]. If the state file
+         * is absent, returns a projection with [exists] = false and zeroed counters.
+         */
+        fun read(checkpointDirPath: String, stateJsonPath: String): CheckpointInfo {
+            val file = File(stateJsonPath)
+            if (!file.isFile) {
+                return CheckpointInfo(0, 0, 0, 0, checkpointDirPath, stateJsonPath, exists = false)
+            }
+            val state = gson.fromJson(file.readText(), TrainingState::class.java)
+            return CheckpointInfo(
+                currentGlobalStep = state.currentGlobalStep,
+                currentEpoch = state.currentEpoch,
+                schedulerStep = state.schedulerState.currentStep,
+                totalSteps = state.schedulerState.totalSteps,
+                checkpointDirPath = checkpointDirPath,
+                stateJsonPath = stateJsonPath,
+                exists = true,
+            )
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEvent.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEvent.kt
new file mode 100644
index 0000000..897c816
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEvent.kt
@@ -0,0 +1,31 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.ORTTrainerNative
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+
+/**
+ * Structured training event stream (#18), one-to-one with the existing `TrainingCallback` surface. Emitted
+ * on a `SharedFlow<TrainingEvent>` by [TrainingEventAdapter].
+ */
+sealed interface TrainingEvent {
+    data class DataLoaded(val totalSteps: Int, val stepsPerEpoch: Int) : TrainingEvent
+
+    data class Step(val progress: TrainingProgress) : TrainingEvent // onStepEnd
+
+    data class OptimizerStep(val progress: TrainingProgress) : TrainingEvent
+
+    data class Epoch(val progress: TrainingProgress) : TrainingEvent // onEpochEnd
+
+    data class Metric(val m: ORTTrainerNative.TrainingStepMetrics) : TrainingEvent
+
+    data object MergeStarted : TrainingEvent
+
+    data object MergeFinished : TrainingEvent
+
+    data class Saved(val progress: TrainingProgress) : TrainingEvent
+
+    data class Done(val result: TrainingResult) : TrainingEvent
+
+    data class Error(val t: Throwable) : TrainingEvent
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapter.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapter.kt
new file mode 100644
index 0000000..8a71782
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapter.kt
@@ -0,0 +1,103 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.ORTTrainerNative
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import com.martinkorelic.mobiletransformers.repository.TrainingCallback
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Translates the existing `TrainingCallback` surface (#18) into the public [TrainingStatus] state and the
+ * [TrainingEvent] stream, one-to-one. Pure of any native handle — it only reacts to callbacks, so it is
+ * unit-testable by driving a scripted callback sequence. The `checkpointSupplier`/`summarySupplier` seams let
+ * [TrainingJob] inject the real `training_state.json`/`training_logs.json` reads (defaults return null).
+ */
+class TrainingEventAdapter(
+    private val checkpointSupplier: () -> CheckpointInfo? = { null },
+    // The PUBLIC summary type (#17) — the ORT-side value is converted via `toPublic()`.
+    private val summarySupplier: () -> com.martinkorelic.mobiletransformers.runtime.TrainingSummary? = { null },
+) : TrainingCallback {
+
+    private val _status = MutableStateFlow<TrainingStatus>(TrainingStatus.Idle)
+    val status: StateFlow<TrainingStatus> = _status.asStateFlow()
+
+    private val _events = MutableSharedFlow<TrainingEvent>(replay = 0, extraBufferCapacity = 128)
+    val events: SharedFlow<TrainingEvent> = _events.asSharedFlow()
+
+    private var merged = false
+
+    private fun emit(event: TrainingEvent) {
+        _events.tryEmit(event)
+    }
+
+    override fun onModelLoadStart() {
+        _status.value = TrainingStatus.Preparing
+    }
+
+    override fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch: Int) {
+        emit(TrainingEvent.DataLoaded(totalSteps, stepsPerEpoch))
+    }
+
+    override fun onStepEnd(trainingProgress: TrainingProgress) {
+        _status.value = TrainingStatus.Running(trainingProgress)
+        emit(TrainingEvent.Step(trainingProgress))
+    }
+
+    override fun onOptimizerStep(trainingProgress: TrainingProgress) {
+        _status.value = TrainingStatus.Running(trainingProgress)
+        emit(TrainingEvent.OptimizerStep(trainingProgress))
+    }
+
+    override fun onEpochEnd(trainingProgress: TrainingProgress) {
+        _status.value = TrainingStatus.Running(trainingProgress)
+        emit(TrainingEvent.Epoch(trainingProgress))
+    }
+
+    override fun onMergeStart(trainingProgress: TrainingProgress) {
+        _status.value = TrainingStatus.Merging
+        emit(TrainingEvent.MergeStarted)
+    }
+
+    override fun onMergeEnd(trainingProgress: TrainingProgress) {
+        merged = true
+        emit(TrainingEvent.MergeFinished)
+    }
+
+    override fun onSaveModelStart(trainingProgress: TrainingProgress) {
+        _status.value = TrainingStatus.Saving
+    }
+
+    override fun onSaveModelEnd(trainingProgress: TrainingProgress) {
+        emit(TrainingEvent.Saved(trainingProgress))
+    }
+
+    override fun onCompletion(trainingProgress: TrainingProgress) {
+        val result =
+            TrainingResult(
+                finalStep = trainingProgress.currentStep,
+                finalEpoch = trainingProgress.currentEpoch,
+                finalLoss = trainingProgress.totalLoss,
+                totalDurationMs = trainingProgress.totalDurationMs,
+                merged = merged,
+                checkpoint = checkpointSupplier(),
+                summary = summarySupplier(),
+            )
+        _status.value = TrainingStatus.Completed(result)
+        emit(TrainingEvent.Done(result))
+    }
+
+    override fun onError(error: Throwable) {
+        _status.value = TrainingStatus.Failed(error)
+        emit(TrainingEvent.Error(error))
+    }
+
+    /** Called by [TrainingJob.cancel] after the loop breaks and the checkpoint (if any) is persisted. */
+    fun markCancelled(checkpoint: CheckpointInfo?) {
+        _status.value = TrainingStatus.Cancelled(checkpoint)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJob.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJob.kt
new file mode 100644
index 0000000..af64c90
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJob.kt
@@ -0,0 +1,91 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.TaskPreprocessor
+import com.martinkorelic.mobiletransformers.Tasks
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.repository.LLMRepository
+import com.martinkorelic.mobiletransformers.repository.TrainingRepository
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * Public, lifecycle-shaped training handle (#18). Wraps `LLMRepository`/`ORTTrainerNative` without leaking
+ * them or the native handle. `start` drives the existing prepare→train path with a [TrainingEventAdapter] as
+ * the callback; `cancel` sets the cooperative `ORTTrainerNative.cancelRequested` flag so the loop breaks and
+ * the existing `saveModel`+`saveTrainingState` path can persist a checkpoint; `checkpoint`/`canResume` are
+ * read-only projections of the unchanged `training_state.json` (see [CheckpointInfo]).
+ */
+class TrainingJob internal constructor(
+    private val repo: LLMRepository,
+    @Suppress("unused") private val repoId: String,
+) {
+    private val training = TrainingRepository(repo)
+
+    private val adapter =
+        TrainingEventAdapter(
+            checkpointSupplier = { checkpoint() },
+            // Real run summary when trainingConfig.profileMetrics collected one; null otherwise.
+            summarySupplier = { repo.ortTrainerNative?.lastSummary?.toPublic() },
+        )
+
+    val status: StateFlow<TrainingStatus> = adapter.status
+    val events: SharedFlow<TrainingEvent> = adapter.events
+
+    /** Start (or resume, when [canResume]) training. Suspends until the run completes or fails. */
+    suspend fun start(args: ORTTrainingConfig? = null, preprocess: TaskPreprocessor? = null) {
+        repo.ortTrainerNative?.cancelRequested = false
+        training.performTraining(args, adapter, preprocess)
+    }
+
+    /**
+     * Start (or resume) training from the **public** config types.
+     *
+     * #17/#19 gap found building the showcase app's Train screen. `MobileTransformerModel.trainingJob()`
+     * is the only way to reach `status`/`events`/`cancel`/`checkpoint`, but the sole way to *start* the
+     * job it returns took an `ORTTrainingConfig` — an engine-layer type the public API otherwise never
+     * mentions and a facade-only app is forbidden to import. So the lifecycle-shaped API was reachable
+     * and unusable at the same time: an app could either have progress flows and cancellation (by
+     * reaching around the facade) or stay on the facade and use the one-shot
+     * [com.martinkorelic.mobiletransformers.MobileTransformerModel.train], never both.
+     *
+     * Maps through the same `ConfigMappers` the one-shot path uses, including the "caller supplies the
+     * data, so the caller names its preprocessor" rule — so the two entry points cannot drift into
+     * training differently from the same configs.
+     */
+    suspend fun start(dataset: DatasetConfig, config: TrainConfig = TrainConfig()) {
+        val ortConfig = config.toOrt(repo.trainingConfig).copy(
+            datasetOptions = dataset.toOrt(),
+            // Checked here, in the caller's frame. Left to the trainer's constructor this throws
+            // inside LLMRepository's own coroutine scope, where no caller `catch` can see it and the
+            // process dies instead. See Tasks.resolve.
+            taskName = Tasks.resolve(dataset.task, repo.trainingConfig.taskName),
+        )
+        // `DatasetConfig` names a registered task rather than carrying a lambda, so the preprocessor
+        // is resolved by name inside the training path — the same rule scheduled training relies on
+        // (a lambda cannot survive a worker rebuilt after process death).
+        start(ortConfig, null)
+    }
+
+    /**
+     * Cooperatively cancel: set the native cancel flag, let the loop break, then persist via the existing
+     * save path if [saveCheckpoint]. Emits [TrainingStatus.Cancelled] with the persisted checkpoint.
+     */
+    suspend fun cancel(saveCheckpoint: Boolean = true) {
+        repo.ortTrainerNative?.cancelRequested = true
+        training.endTraining(saveCheckpoint)
+        adapter.markCancelled(if (saveCheckpoint) checkpoint() else null)
+    }
+
+    /** Read the current `training_state.json` projection, or null if the trainer isn't initialized. */
+    fun checkpoint(): CheckpointInfo? {
+        val trainer = repo.ortTrainerNative ?: return null
+        return CheckpointInfo.read(trainer.checkpointPath, "${trainer.checkpointPath.removeSuffix("checkpoint")}training_state.json")
+    }
+
+    /** True when a state file exists and `loadFromState` would restore it. */
+    val canResume: Boolean
+        get() = checkpoint()?.exists == true
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJobManager.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJobManager.kt
new file mode 100644
index 0000000..5501e96
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingJobManager.kt
@@ -0,0 +1,31 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.repository.LLMRepository
+
+/**
+ * A reconstructable description of a training job (#18) — the seam a future WorkManager `Worker` (#34) uses
+ * to rebuild a [TrainingJob] after process death. Defined here; **no WorkManager dependency is added**.
+ */
+data class TrainingJobSpec(
+    val repoId: String,
+    val config: ORTTrainingConfig,
+)
+
+/**
+ * Owns one [TrainingJob] per sanitized repo id (#18). Foundation hook for scheduled training (#34); this
+ * class only manages job identity/lifetime, not scheduling.
+ */
+class TrainingJobManager(private val repo: LLMRepository) {
+    private val jobs = mutableMapOf<String, TrainingJob>()
+
+    fun getOrCreate(repoId: String): TrainingJob {
+        val key = PackageFormat.sanitizeRepoId(repoId)
+        return jobs.getOrPut(key) { TrainingJob(repo, key) }
+    }
+
+    fun get(repoId: String): TrainingJob? = jobs[PackageFormat.sanitizeRepoId(repoId)]
+
+    fun clear() = jobs.clear()
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingStatus.kt b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingStatus.kt
new file mode 100644
index 0000000..dc1c4eb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers/training/TrainingStatus.kt
@@ -0,0 +1,27 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+
+/**
+ * Public, lifecycle-shaped training status (#18). Maps the `LLMState`/`TrainingCallback` surface without
+ * leaking `ORTTrainerNative` or the native handle. [TrainingResult] is the SAME type #17's
+ * `ModelSession.train` returns — #18 enriches it with `checkpoint`/`summary` (see `runtime/Results.kt`).
+ */
+sealed interface TrainingStatus {
+    data object Idle : TrainingStatus
+
+    data object Preparing : TrainingStatus // LLMState.ReadyTrain bring-up
+
+    data class Running(val progress: TrainingProgress) : TrainingStatus // LLMState.Training
+
+    data object Merging : TrainingStatus // onMergeStart..onMergeEnd
+
+    data object Saving : TrainingStatus // LLMState.SavingModel
+
+    data class Completed(val result: TrainingResult) : TrainingStatus
+
+    data class Cancelled(val checkpoint: CheckpointInfo?) : TrainingStatus
+
+    data class Failed(val error: Throwable) : TrainingStatus
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatFormattedTrainingPromptTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatFormattedTrainingPromptTest.kt
new file mode 100644
index 0000000..6b50717
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatFormattedTrainingPromptTest.kt
@@ -0,0 +1,130 @@
+package com.martinkorelic.mobiletransformers
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #37: the train/inference **prompt-shape seam** (JVM, Robolectric — the template handler logs).
+ *
+ * ### What this pins, and what it does not
+ *
+ * `ORTDataCurator` tokenized whatever the preprocessor returned, verbatim, while
+ * `ORTGeneratorNative.generate` tokenizes its first turn with `prependBos = true` and — when the
+ * package's tokenizer loaded a chat template — wraps the prompt via
+ * [ORTConversationState.addUserMessage]. So the two sides could disagree on the token sequence for
+ * one and the same instruction. `TaskPreprocessor.formatsPromptForGeneration` closes that.
+ *
+ * **Scope, honestly stated.** The BOS half of the mismatch was real and is fixed. The chat-template
+ * half *was* latent for the package this was measured on, and is no longer: `ORTTokenizerNative` read
+ * the template only from `tokenizer_config.json` while SmolLM2's export writes it to a sibling
+ * `chat_template.jinja`, so `chatTemplate` was null and neither side templated. The device log said so
+ * in as many words — `W/ORTTokenizerNative: Chat template not found … No chat template will be used`.
+ * `ORTTokenizerNative.resolveChatTemplate` now reads the sibling file, so both sides of this seam
+ * template for real; see `ChatTemplateResolutionTest`. The measurements below predate that fix and
+ * describe the untemplated behaviour — re-measure before citing them.
+ *
+ * **This did not fix the #37 gate.** With BOS parity and EOS in place, training reaches a loss of
+ * ~0.006, the merge completes over all 60 adapted tensors, 60 merged initializers load at inference
+ * with no base-weight fallback, and generation *still* collapses to token 198 (newline) on the very
+ * prompt it was trained on. That leaves merge numerics — not convergence, and not prompt format — as
+ * where the remaining defect lives. See the #37 self-check.
+ *
+ * ### Why these assertions can fail
+ *
+ * [promptFormatMatchingIsOptInAndMobileActionsOptsIn] fails if the opt-in is dropped or leaks to other
+ * tasks. [aRenderedFirstTurnEndsAtTheAssistantOpener] fails if the render stops short of the opener,
+ * which is what decides whether the completion is trained as the *assistant's* turn or glued onto the
+ * user's. [renderingChangesTheTokenizedPrompt] fails if the render becomes a no-op.
+ */
+@RunWith(RobolectricTestRunner::class)
+class ChatFormattedTrainingPromptTest {
+
+    /** SmolLM2's shipped template, verbatim from `shared/tokenizer/chat_template.jinja`. */
+    private val smolLm2Template =
+        "{% for message in messages %}" +
+            "{% if loop.first and messages[0]['role'] != 'system' %}" +
+            "{{ '<|im_start|>system\nYou are a helpful AI assistant named SmolLM, trained by Hugging Face<|im_end|>\n' }}" +
+            "{% endif %}" +
+            "{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}" +
+            "{% endfor %}" +
+            "{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"
+
+    /**
+     * The one expression both sides of the seam use: a **fresh** conversation state, no explicit system
+     * prompt (matching `GenerationConfig.systemPrompt`'s null default), rendering one first turn.
+     */
+    private fun renderFirstTurn(content: String): String =
+        ORTConversationState(ORTChatTemplateHandler(smolLm2Template), emptyMap(), null)
+            .addUserMessage(content)
+
+    @Test
+    fun promptFormatMatchingIsOptInAndMobileActionsOptsIn() {
+        assertTrue(
+            "mobile_actions is generated through generateToolCall, which goes through the chat " +
+                "template — its training data must be rendered the same way",
+            MobileActionsPreprocessor.formatsPromptForGeneration(),
+        )
+
+        // The default must stay false: every pre-existing task was trained and evaluated on raw
+        // prompts, and flipping them here would silently invalidate those runs.
+        assertFalse(CoLAPreprocessor.formatsPromptForGeneration())
+        assertFalse(BoolqPreprocessor.formatsPromptForGeneration())
+        assertFalse(LogiqaPreprocessor.formatsPromptForGeneration())
+        assertFalse(MiniPersonalQAPreprocessor.formatsPromptForGeneration())
+
+        // A caller's own preprocessor inherits the raw default rather than being opted in behind its back.
+        val custom = object : TaskPreprocessor {
+            override fun preprocess(json: org.json.JSONObject) = "in" to "out"
+        }
+        assertFalse(custom.formatsPromptForGeneration())
+    }
+
+    @Test
+    fun aRenderedFirstTurnEndsAtTheAssistantOpener() {
+        val rendered = renderFirstTurn("wake me at 07:30")
+
+        // The completion is concatenated directly after this string during training, so the prompt has
+        // to stop exactly where the assistant's turn begins. Ending anywhere else trains the JSON as
+        // part of the user's message.
+        assertTrue(
+            "a training prompt must end at the assistant opener, not mid-turn; got: '$rendered'",
+            rendered.endsWith("<|im_start|>assistant\n"),
+        )
+        assertTrue("the instruction must survive the render", rendered.contains("wake me at 07:30"))
+        assertTrue(
+            "the template injects its default system turn when none is supplied",
+            rendered.contains("<|im_start|>system"),
+        )
+    }
+
+    @Test
+    fun renderingChangesTheTokenizedPrompt() {
+        val raw = "wake me at 07:30"
+        assertNotEquals(
+            "if the render were a no-op the seam would be back and this test would pass vacuously",
+            raw,
+            renderFirstTurn(raw),
+        )
+    }
+
+    @Test
+    fun everyRowIsRenderedAsAFirstTurn() {
+        // The curator builds a new state per row. Were it to share one, row 2 would render only the
+        // delta (`buildNewUserMessageTemplate`) and train on a fragment with no system turn.
+        assertEquals(renderFirstTurn("timer for 30 seconds"), renderFirstTurn("timer for 30 seconds"))
+
+        val shared = ORTConversationState(ORTChatTemplateHandler(smolLm2Template), emptyMap(), null)
+        val first = shared.addUserMessage("timer for 30 seconds")
+        val second = shared.addUserMessage("timer for 30 seconds")
+        assertNotEquals(
+            "a shared state must NOT be what the curator uses — proving the per-row state matters",
+            first,
+            second,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatTemplateResolutionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatTemplateResolutionTest.kt
new file mode 100644
index 0000000..63913e5
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ChatTemplateResolutionTest.kt
@@ -0,0 +1,198 @@
+package com.martinkorelic.mobiletransformers
+
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.io.File
+
+/**
+ * Where `ORTTokenizerNative` looks for a chat template, and whether it trusts what it finds.
+ *
+ * ### The defect this pins
+ *
+ * `loadTokenizerConfiguration` read `chat_template` out of `tokenizer_config.json` and nowhere else.
+ * The exporter has never written it there: `export/pipeline.py::_emit_chat_template` writes a sibling
+ * `chat_template.jinja`, which the installers flatten into `tokenizer/`. Measured across every package
+ * on this machine — `build/pkg`, `pkg-ab`, `pkg-functiongemma`, `pkg-gemma3` — the sibling file is
+ * present in all of them and the key appears in **none**.
+ *
+ * So `chatTemplate` was null for every package ever shipped, [ORTConversationState] was never
+ * constructed, and no plain-chat prompt was wrapped in the model's turn format. A model trained on
+ * `<start_of_turn>user … <start_of_turn>model` was handed a bare string.
+ * [siblingFileIsReadWhenTheConfigCarriesNoKey] is the case that was broken; it fails against the
+ * key-only lookup.
+ *
+ * ### Why the probe half matters just as much
+ *
+ * Resolving more templates is only an improvement if the ones resolved actually work. Pebble is not
+ * Jinja, and FunctionGemma's template alone uses `namespace()`, `dictsort` and macros it does not
+ * implement. Without [ORTTokenizerNative.validatedChatTemplate], such a template would throw
+ * mid-generation once per turn instead of once at load — strictly worse than the null it replaced.
+ * [aTemplatePebbleCannotCompileIsDiscarded] and [aTemplateRenderingEmptyIsDiscarded] pin the fallback.
+ *
+ * Robolectric because both functions log.
+ */
+@RunWith(RobolectricTestRunner::class)
+class ChatTemplateResolutionTest {
+
+    @get:Rule
+    val temp = TemporaryFolder()
+
+    /** SmolLM2's shipped template, verbatim from `shared/tokenizer/chat_template.jinja`. */
+    private val workingTemplate =
+        "{% for message in messages %}" +
+            "{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}" +
+            "{% endfor %}" +
+            "{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"
+
+    private val specialTokens = mapOf(
+        "bos_token" to "<|im_start|>",
+        "eos_token" to "<|im_end|>",
+    )
+
+    private fun config(json: String): JsonObject =
+        Gson().fromJson(json, JsonObject::class.java)
+
+    private fun dirWithSibling(template: String): File {
+        val dir = temp.newFolder("tokenizer-${template.hashCode()}")
+        File(dir, ORTTokenizerNative.CHAT_TEMPLATE_FILE_NAME).writeText(template)
+        return dir
+    }
+
+    // ---------------------------------------------------------------- resolution
+
+    /**
+     * **The regression.** Config carries no `chat_template`; the template is in the sibling file.
+     * This is the shape of every package the exporter produces, and the key-only lookup returned null
+     * for all of them.
+     */
+    @Test
+    fun siblingFileIsReadWhenTheConfigCarriesNoKey() {
+        val dir = dirWithSibling(workingTemplate)
+        val resolved = ORTTokenizerNative.resolveChatTemplate(config("""{"model_max_length": 2048}"""), dir)
+
+        assertEquals(workingTemplate, resolved)
+    }
+
+    /** Packages predating the exporter change inline it, and must keep working. */
+    @Test
+    fun inlineKeyIsReadWhenThereIsNoSiblingFile() {
+        val dir = temp.newFolder("tokenizer-inline-only")
+        val resolved = ORTTokenizerNative.resolveChatTemplate(
+            config("""{"chat_template": "{{ 'inline' }}"}"""),
+            dir,
+        )
+
+        assertEquals("{{ 'inline' }}", resolved)
+    }
+
+    /** A package shipping both is stating a deliberate override, so the key wins. */
+    @Test
+    fun inlineKeyWinsOverTheSiblingFile() {
+        val dir = dirWithSibling(workingTemplate)
+        val resolved = ORTTokenizerNative.resolveChatTemplate(
+            config("""{"chat_template": "{{ 'inline' }}"}"""),
+            dir,
+        )
+
+        assertEquals("{{ 'inline' }}", resolved)
+    }
+
+    @Test
+    fun neitherSourcePresentResolvesToNull() {
+        assertNull(
+            ORTTokenizerNative.resolveChatTemplate(config("""{"model_max_length": 2048}"""), temp.newFolder("empty")),
+        )
+    }
+
+    /**
+     * Some tokenizer configs carry a LIST of named templates (`[{name, template}]`) rather than a
+     * string. `asString` throws on that shape, which would take down the whole of
+     * `loadTokenizerConfiguration` — including the special-token parsing above it — via its catch-all.
+     * The non-primitive must be stepped over so the sibling file is still found.
+     */
+    @Test
+    fun aNonStringChatTemplateFallsThroughToTheSiblingInsteadOfThrowing() {
+        val dir = dirWithSibling(workingTemplate)
+        val resolved = ORTTokenizerNative.resolveChatTemplate(
+            config("""{"chat_template": [{"name": "default", "template": "x"}]}"""),
+            dir,
+        )
+
+        assertEquals(workingTemplate, resolved)
+    }
+
+    @Test
+    fun aBlankTemplateIsTreatedAsAbsent() {
+        val dir = dirWithSibling("   \n  ")
+        assertNull(ORTTokenizerNative.resolveChatTemplate(config("{}"), dir))
+    }
+
+    @Test
+    fun aMissingDirectoryResolvesToNullRatherThanThrowing() {
+        assertNull(ORTTokenizerNative.resolveChatTemplate(config("{}"), File("/does/not/exist")))
+        assertNull(ORTTokenizerNative.resolveChatTemplate(null, null))
+    }
+
+    // ---------------------------------------------------------------- probe render
+
+    @Test
+    fun aWorkingTemplateSurvivesTheProbe() {
+        val kept = ORTTokenizerNative.validatedChatTemplate(workingTemplate, specialTokens)
+
+        assertNotNull("SmolLM2's own template must survive the probe", kept)
+        assertEquals(workingTemplate, kept)
+    }
+
+    /**
+     * The probe must reject rather than propagate. Unclosed `{% if %}` is a compile error in any
+     * Jinja-alike, so this is deterministic regardless of which constructs Pebble happens to support.
+     */
+    @Test
+    fun aTemplatePebbleCannotCompileIsDiscarded() {
+        assertNull(ORTTokenizerNative.validatedChatTemplate("{% if true %}never closed", specialTokens))
+    }
+
+    /** A template that evaluates to nothing would hand generation an empty prompt every turn. */
+    @Test
+    fun aTemplateRenderingEmptyIsDiscarded() {
+        assertNull(ORTTokenizerNative.validatedChatTemplate("{% if false %}x{% endif %}", specialTokens))
+    }
+
+    @Test
+    fun aNullCandidateStaysNull() {
+        assertNull(ORTTokenizerNative.validatedChatTemplate(null, specialTokens))
+    }
+
+    /**
+     * The probe renders a real two-turn conversation, so a template that only references
+     * `messages` still produces both turns and the assistant opener — i.e. the probe exercises the
+     * same path a live turn does, rather than a degenerate empty-message render that would pass
+     * templates which break on real input.
+     */
+    @Test
+    fun theProbeExercisesBothTurnsAndTheGenerationPrompt() {
+        // Rendering the same context the probe uses, to assert on what it produced.
+        val rendered = ORTChatTemplateHandler(workingTemplate).buildInput(
+            mutableMapOf<String, Any>(
+                "messages" to listOf(
+                    mapOf("role" to "user", "content" to "ping"),
+                    mapOf("role" to "assistant", "content" to "pong"),
+                ),
+                "add_generation_prompt" to true,
+            ).also { it.putAll(specialTokens) },
+        )
+
+        assertTrue("probe must render the user turn", rendered.contains("ping"))
+        assertTrue("probe must render the assistant turn", rendered.contains("pong"))
+        assertTrue("probe must reach the generation opener", rendered.trimEnd().endsWith("assistant"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/FileUtilParseTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/FileUtilParseTest.kt
new file mode 100644
index 0000000..9560f63
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/FileUtilParseTest.kt
@@ -0,0 +1,143 @@
+package com.martinkorelic.mobiletransformers
+
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #6/#10: config parsing is fail-closed on every closed-set field (JVM, Robolectric — no device).
+ *
+ * These parsers were untestable before Robolectric was on the classpath: `FileUtil` uses
+ * `org.json.JSONObject`, which throws "Method ... not mocked" under plain JUnit. That gap is why an
+ * unknown `schedulerType` silently defaulted to Linear (with a `println` that release builds drop)
+ * for as long as it did — no test could reach the code.
+ */
+@RunWith(RobolectricTestRunner::class)
+class FileUtilParseTest {
+
+    private val dir: File = Files.createTempDirectory("fileutil-parse").toFile()
+
+    @After
+    fun cleanup() {
+        dir.deleteRecursively()
+    }
+
+    private fun writeConfig(name: String, json: String): String =
+        File(dir, name).apply { writeText(json) }.absolutePath
+
+    // --- scheduler -------------------------------------------------------------------------------
+
+    @Test
+    fun linearSchedulerParsesItsOwnOptions() {
+        val path = writeConfig(
+            "train.json",
+            """{"schedulerType":"linear","schedulerOptions":{"learningRate":0.001,"startFactor":1.0,"endFactor":0.5}}""",
+        )
+        val config = parseTrainingArguments(path)
+        val scheduler = config.schedulerConfig as SchedulerConfig.Linear
+        assertEquals(0.001f, scheduler.learningRate, 1e-6f)
+        assertEquals(0.5f, scheduler.endFactor, 1e-6f)
+    }
+
+    @Test
+    fun cosineSchedulerParsesItsOwnOptions() {
+        val path = writeConfig(
+            "train.json",
+            """{"schedulerType":"cosine","schedulerOptions":{"learningRate":0.002,"warmupSteps":25}}""",
+        )
+        val scheduler = parseTrainingArguments(path).schedulerConfig as SchedulerConfig.Cosine
+        assertEquals(0.002f, scheduler.learningRate, 1e-6f)
+        assertEquals(25, scheduler.warmupSteps)
+    }
+
+    /** The regression: an unknown scheduler used to become Linear with an invisible warning. */
+    @Test
+    fun unknownSchedulerTypeFailsClosed() {
+        val path = writeConfig("train.json", """{"schedulerType":"consine"}""")
+        assertThrows(IllegalStateException::class.java) { parseTrainingArguments(path) }
+    }
+
+    /** Root-level scheduler options are the backward-compat path; it must fail closed identically. */
+    @Test
+    fun unknownSchedulerTypeFailsClosedOnTheRootLevelPath() {
+        val path = writeConfig("train.json", """{"schedulerType":"exponential","learningRate":0.001}""")
+        assertThrows(IllegalStateException::class.java) { parseTrainingArguments(path) }
+    }
+
+    // --- device options --------------------------------------------------------------------------
+
+    @Test
+    fun deviceOptionsParseFromEitherNestedOrRootLevel() {
+        val nested = writeConfig(
+            "a.json",
+            """{"deviceOptions":{"coreConfigId":"opt2","memoryConfigId":"low_mem","executionProvider":"nnapi"}}""",
+        )
+        val root = writeConfig(
+            "b.json",
+            """{"coreConfigId":"opt2","memoryConfigId":"low_mem","executionProvider":"nnapi"}""",
+        )
+        for (path in listOf(nested, root)) {
+            val opts = parseTrainingArguments(path).deviceOptions
+            assertEquals("opt2", opts.coreConfigId)
+            assertEquals("low_mem", opts.memoryConfigId)
+            assertEquals("nnapi", opts.executionProvider)
+        }
+    }
+
+    @Test
+    fun unknownExecutionProviderFailsClosed() {
+        val path = writeConfig("train.json", """{"deviceOptions":{"executionProvider":"cuda"}}""")
+        assertThrows(IllegalStateException::class.java) { parseTrainingArguments(path) }
+    }
+
+    @Test
+    fun unknownMemoryConfigIdFailsClosed() {
+        val path = writeConfig("train.json", """{"deviceOptions":{"memoryConfigId":"turbo"}}""")
+        assertThrows(IllegalStateException::class.java) { parseTrainingArguments(path) }
+    }
+
+    // --- generation + rag ------------------------------------------------------------------------
+
+    @Test
+    fun unknownSamplingMethodFailsClosed() {
+        val path = writeConfig("gen.json", """{"sampling":{"method":"beam"}}""")
+        assertThrows(IllegalStateException::class.java) { parseGenerationArguments(path) }
+    }
+
+    @Test
+    fun unknownSearchTypeFailsClosed() {
+        val path = writeConfig("rag.json", """{"searchType":"hybrid"}""")
+        assertThrows(IllegalStateException::class.java) { parseRagArguments(path) }
+    }
+
+    @Test
+    fun unknownIndexingModeFailsClosed() {
+        val path = writeConfig("rag.json", """{"indexingMode":"streaming"}""")
+        assertThrows(IllegalStateException::class.java) { parseRagArguments(path) }
+    }
+
+    @Test
+    fun validRagFieldsRoundTrip() {
+        val path = writeConfig(
+            "rag.json",
+            """{"searchType":"text","indexingMode":"precompute","topK":7,"minScore":0.25}""",
+        )
+        val config = parseRagArguments(path)
+        assertEquals("text", config.searchType)
+        assertEquals("precompute", config.indexingMode)
+        assertEquals(7, config.topK)
+        assertEquals(0.25, config.minScore, 1e-9)
+    }
+
+    /** An absent/blank path is not an error — it yields defaults (unchanged behavior). */
+    @Test
+    fun absentConfigYieldsDefaults() {
+        assertEquals(ORTTrainingConfig(), parseTrainingArguments(""))
+        assertEquals(ORTRagConfig(), parseRagArguments(File(dir, "nope.json").absolutePath))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/LabelShapeDeclarationTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/LabelShapeDeclarationTest.kt
new file mode 100644
index 0000000..9747475
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/LabelShapeDeclarationTest.kt
@@ -0,0 +1,49 @@
+package com.martinkorelic.mobiletransformers
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #33: how a preprocessor DECLARES its label shape.
+ *
+ * Robolectric because these parse real `org.json.JSONObject`s, which the plain unit-test classpath
+ * stubs — and `isReturnDefaultValues = false` (build.gradle.kts) makes that stub throw rather than
+ * silently return 0/null, so a test could otherwise "pass" against a method that never ran.
+ */
+@RunWith(RobolectricTestRunner::class)
+class LabelShapeDeclarationTest {
+
+    @Test
+    fun aTokenLevelPreprocessorDeclaresNoClassLabelSoNothingElseChanges() {
+        // The default keeps every existing preprocessor — including users' own `customPreprocess`,
+        // which is public API — on the token-level path without any change.
+        val json = JSONObject("""{"sentence": "The cat sat.", "label": 1}""")
+
+        assertNull(CoLAPreprocessor.classLabel(json))
+        assertEquals(1, CoLAClassificationPreprocessor.classLabel(json))
+    }
+
+    @Test
+    fun theClassificationPreprocessorKeepsTheLabelAnIndexRatherThanStringifyingIt() {
+        val json = JSONObject("""{"sentence": "The cat sat.", "label": 0}""")
+
+        // CoLAPreprocessor works around having only one label shape by turning the class into words.
+        assertEquals("unacceptable", CoLAPreprocessor.preprocess(json).second)
+        // The classification objective does not need that: the index goes straight to `labels[batch]`.
+        assertEquals(0, CoLAClassificationPreprocessor.classLabel(json))
+        assertEquals("The cat sat.", CoLAClassificationPreprocessor.preprocess(json).first)
+    }
+
+    @Test
+    fun theRegistryResolvesBothObjectivesOverTheSameDatasetFile() {
+        assertTrue(getPreprocessFunctionForTask("cola") === CoLAPreprocessor)
+        assertTrue(getPreprocessFunctionForTask("cola_cls") === CoLAClassificationPreprocessor)
+        assertFalse(getPreprocessFunctionForTask("cola") === getPreprocessFunctionForTask("cola_cls"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTConversationStateTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTConversationStateTest.kt
new file mode 100644
index 0000000..9ad72a0
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTConversationStateTest.kt
@@ -0,0 +1,40 @@
+package com.martinkorelic.mobiletransformers
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #23: conversation-state lifecycle (JVM, no template engine / device).
+ *
+ * With a null template handler the class exercises its pure history/reset bookkeeping without touching
+ * Pebble or `android.util.Log`. The rendered-offset fix in [ORTConversationState.addAssistantMessage]
+ * (which needs a real chat template) is validated by the device conversation-reset smoke; here we pin
+ * that [ORTConversationState.resetForNewConversation] fully clears state so a new conversation never
+ * inherits the previous turn's prepend state.
+ */
+class ORTConversationStateTest {
+
+    @Test
+    fun resetClearsHistoryAndFirstMessageFlag() {
+        val state = ORTConversationState(null, emptyMap(), systemPrompt = "sys")
+        state.addUserMessage("hello") // first message -> system + user added to history
+        state.addAssistantMessage("hi there") // + assistant
+        assertEquals(3, state.getConversationHistory().size)
+
+        state.resetForNewConversation()
+        assertTrue(state.getConversationHistory().isEmpty())
+
+        // After reset the next user message is treated as the first again (system prompt re-applied).
+        state.addUserMessage("again")
+        assertEquals(listOf("system", "user"), state.getConversationHistory().map { it["role"] })
+    }
+
+    @Test
+    fun systemPromptAppliedOnFirstMessage() {
+        val state = ORTConversationState(null, emptyMap(), systemPrompt = null)
+        state.setSystemPrompt("you are helpful")
+        state.addUserMessage("q")
+        assertEquals("you are helpful", state.getConversationHistory().first()["content"])
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTSchedulerTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTSchedulerTest.kt
new file mode 100644
index 0000000..cb247fd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/ORTSchedulerTest.kt
@@ -0,0 +1,94 @@
+package com.martinkorelic.mobiletransformers
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #34/#18: learning-rate schedule state round-trip (JVM, no device/JNI).
+ *
+ * [ORTTrainerNative.saveTrainingState] calls `scheduler.stateDict()` on EVERY checkpoint write, and
+ * [LinearLRScheduler] — the default schedule — implemented it as `TODO("Not yet implemented")`.
+ * `NotImplementedError` is an `Error`, so it was not caught by the `catch (e: Exception)` guarding the
+ * save: any run with `maxSteps > saveSteps` on the default schedule died at its first checkpoint.
+ */
+class ORTSchedulerTest {
+
+    private val eps = 1e-5f
+
+    // --- LinearLRScheduler ------------------------------------------------------------------------
+
+    @Test
+    fun linearStateDictDoesNotThrowAndCarriesThePosition() {
+        val s = LinearLRScheduler(baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 5)
+        repeat(3) { s.step() }
+
+        val state = s.stateDict()
+        assertEquals(5, state.totalSteps)
+        assertEquals(0, state.warmupSteps) // linear has no warmup phase
+        assertEquals(1e-3f, state.initialLr, eps) // baseLr * startFactor
+        assertEquals(1e-3f / 3f, state.minLr, eps) // baseLr * endFactor
+        assertEquals(3, state.currentStep)
+    }
+
+    @Test
+    fun linearResumesMidScheduleWithoutRestartingIt() {
+        val a = LinearLRScheduler(baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 10)
+        repeat(4) { a.step() }
+        val lrAtInterrupt = a.getLR()
+
+        val b = LinearLRScheduler(baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 10)
+        b.loadFromState(a.stateDict())
+
+        // Resuming restores the LR the interrupted run was last on, not the start of the schedule.
+        assertEquals(lrAtInterrupt, b.getLR(), eps)
+        assertTrue("resumed LR must have decayed below baseLr", b.getLR() < 1e-3f)
+
+        // ...and the schedules stay in lockstep from there on.
+        repeat(5) { assertEquals(a.step(), b.step(), eps) }
+    }
+
+    @Test
+    fun linearLoadFromStepZeroIsTheScheduleStart() {
+        val s = LinearLRScheduler(baseLr = 2e-3f, startFactor = 1f, endFactor = 0.5f, totalIters = 4)
+        repeat(3) { s.step() }
+        s.loadFromState(SchedulerState(4, 0, 1e-3f, 2e-3f, 0))
+        assertEquals(2e-3f, s.getLR(), eps)
+    }
+
+    @Test
+    fun linearClampsToEndFactorPastTotalIters() {
+        val s = LinearLRScheduler(baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 3)
+        repeat(10) { s.step() }
+        assertEquals(1e-3f / 3f, s.getLR(), eps)
+    }
+
+    // --- CosineLRScheduler (the reference implementation; guards against regressions) --------------
+
+    @Test
+    fun cosineResumesMidScheduleWithoutRestartingIt() {
+        val a = CosineLRScheduler(totalSteps = 20, warmupSteps = 2, minLr = 0f, initialLr = 1e-3f)
+        repeat(7) { a.step() }
+
+        val b = CosineLRScheduler(totalSteps = 20, warmupSteps = 2, minLr = 0f, initialLr = 1e-3f)
+        b.loadFromState(a.stateDict())
+
+        assertEquals(a.getLR(), b.getLR(), eps)
+        repeat(5) { assertEquals(a.step(), b.step(), eps) }
+    }
+
+    /** Both schedulers must project onto the SAME record — `training_state.json` has one shape. */
+    @Test
+    fun bothSchedulersRoundTripThroughTheSharedStateRecord() {
+        for (scheduler in listOf(
+            LinearLRScheduler(baseLr = 1e-3f, totalIters = 8),
+            CosineLRScheduler(totalSteps = 8, initialLr = 1e-3f),
+        )) {
+            repeat(3) { scheduler.step() }
+            val state = scheduler.stateDict()
+            assertEquals(8, state.totalSteps)
+            assertEquals(3, state.currentStep)
+            scheduler.loadFromState(state) // must not throw
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/SequenceLabelCollationTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/SequenceLabelCollationTest.kt
new file mode 100644
index 0000000..a46dcd0
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/SequenceLabelCollationTest.kt
@@ -0,0 +1,74 @@
+package com.martinkorelic.mobiletransformers
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * #33: per-SEQUENCE labels survive collation unpadded, which is what makes the native rank inference
+ * work.
+ *
+ * The seam these pin: `training_inputs.h::labels_shape` decides `[batch, seq]` vs `[batch]` from **how
+ * many label elements the caller supplied**. So the collator is the half that determines the exported
+ * graph's label rank, and padding a single class index out to `maxLength` silently converts a
+ * classification batch into a per-token one. Both halves were correct alone; only the seam decides.
+ */
+class SequenceLabelCollationTest {
+
+    private fun sample(inputIds: List<Int>, labels: List<Int>, perSequence: Boolean) =
+        ORTDataCurator.TrainingSample(inputIds = inputIds, labels = labels, perSequenceLabel = perSequence)
+
+    @Test
+    fun perSequenceLabelsAreNotPaddedToTheSequenceLength() {
+        val batch = listOf(
+            sample(listOf(1, 2, 3, 4, 5), listOf(1), perSequence = true),
+            sample(listOf(6, 7), listOf(0), perSequence = true),
+        )
+
+        val collated = DataCollatorForSupervisedDataset(padToken = 0).collate(batch)
+
+        // One label per example. `batchSize` elements total is exactly what makes the native side bind
+        // `labels[batch]`; padding to maxLength (5) would yield batch*seq and bind `[batch, seq]`.
+        assertEquals(2, collated.labels.size)
+        assertEquals(1, collated.labels[0].size)
+        assertEquals(1, collated.labels[1].size)
+        assertEquals(listOf(1L, 0L), collated.labels.map { it[0] })
+        // Inputs are still padded — only the LABEL axis differs between the two objectives.
+        assertEquals(5, collated.sequenceLength)
+        assertEquals(5, collated.inputIds[1].size)
+    }
+
+    @Test
+    fun perTokenLabelsAreStillPaddedExactlyAsBefore() {
+        val batch = listOf(
+            sample(listOf(1, 2, 3, 4, 5), listOf(-100, -100, 3, 4, 5), perSequence = false),
+            sample(listOf(6, 7), listOf(-100, 7), perSequence = false),
+        )
+
+        val collated = DataCollatorForSupervisedDataset(padToken = 0).collate(batch)
+
+        // The decoder's shipped shape is unchanged: one label per position, short rows padded to -100.
+        assertEquals(5, collated.labels[0].size)
+        assertEquals(5, collated.labels[1].size)
+        assertEquals(listOf(-100L, 7L, -100L, -100L, -100L), collated.labels[1].toList())
+    }
+
+    @Test
+    fun theTotalLabelCountIsWhatTheNativeBinderReadsTheRankFrom() {
+        val perSequence = listOf(
+            sample(listOf(1, 2, 3), listOf(1), perSequence = true),
+            sample(listOf(4, 5, 6), listOf(0), perSequence = true),
+        )
+        val perToken = listOf(
+            sample(listOf(1, 2, 3), listOf(1, 2, 3), perSequence = false),
+            sample(listOf(4, 5, 6), listOf(4, 5, 6), perSequence = false),
+        )
+        val collator = DataCollatorForSupervisedDataset(padToken = 0)
+
+        val seqBatch = collator.collate(perSequence)
+        val tokBatch = collator.collate(perToken)
+
+        // `batch` vs `batch * seq` — the two counts the native side distinguishes.
+        assertEquals(seqBatch.batchSize, seqBatch.labels.sumOf { it.size })
+        assertEquals(tokBatch.batchSize * tokBatch.sequenceLength, tokBatch.labels.sumOf { it.size })
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TaskRegistryTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TaskRegistryTest.kt
new file mode 100644
index 0000000..d6d57db
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TaskRegistryTest.kt
@@ -0,0 +1,134 @@
+package com.martinkorelic.mobiletransformers
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * [Tasks.TASKS] and `getPreprocessFunctionForTask`'s dispatch must name the same set.
+ *
+ * The list exists so a UI can offer a picker instead of asking the user to spell a task name from
+ * memory — `DatasetConfig.task` is a free string, and a typo surfaces as `Unsupported task: …`
+ * minutes into a training run. A list that drifts from the dispatch reintroduces exactly that failure
+ * while looking like it prevents it: the picker would offer a name the trainer then rejects.
+ *
+ * Checked in both directions, because each direction is a different mistake. A dispatch entry missing
+ * from the list is a task nobody can select; a list entry missing from the dispatch is an option that
+ * fails when chosen.
+ */
+class TaskRegistryTest {
+
+    @Test
+    fun everyListedTaskResolvesToAPreprocessor() {
+        for (task in Tasks.TASKS) {
+            val preprocessor = getPreprocessFunctionForTask(task.name)
+            assertNotNull("'${task.name}' is offered but has no preprocessor", preprocessor)
+        }
+    }
+
+    /**
+     * The reverse direction, read off the source rather than the dispatch — there is no way to
+     * enumerate a `when`'s branches at runtime, and a test that could only see the list would pass
+     * vacuously when a preprocessor was added without listing it.
+     */
+    @Test
+    fun everyDispatchBranchIsListed() {
+        val source = TestSources.read("main/java/com/martinkorelic/mobiletransformers/DataUtil.kt")
+        val dispatchBody = source
+            .substringAfter("fun getPreprocessFunctionForTask")
+            .substringAfter("return when (taskName.lowercase()) {")
+            .substringBefore("else ->")
+        val branches = Regex("\"([a-z_]+)\"\\s*->").findAll(dispatchBody).map { it.groupValues[1] }.toList()
+
+        assertTrue("could not read the dispatch branches — the guard would pass vacuously", branches.size >= 5)
+        assertEquals(
+            "the task list and the dispatch have drifted",
+            branches.sorted(),
+            Tasks.NAMES.sorted(),
+        )
+    }
+
+    @Test
+    fun everyListedTaskDescribesWhatItsRowsContain() {
+        for (task in Tasks.TASKS) {
+            assertTrue("'${task.name}' has no description", task.description.isNotBlank())
+            assertEquals(task.description, Tasks.describe(task.name))
+        }
+    }
+
+    @Test
+    fun anUnlistedTaskStillFailsClosed() {
+        // The picker removes the typo; it must not remove the check behind it.
+        assertThrows(IllegalArgumentException::class.java) {
+            getPreprocessFunctionForTask("mobileactions")
+        }
+    }
+
+    // --- Tasks.resolve: the same check, moved to where the caller can survive it ---------------
+    //
+    // `Unsupported task: none` used to reach the user as a FATAL EXCEPTION. The throw happened in
+    // `ORTTrainerNative.<init>`, called from a `launch` on LLMRepository's own scope, whose parent
+    // job has no handler — so it went to the thread's default handler and killed the process. These
+    // pin the resolution that now happens in the caller's frame instead.
+
+    @Test
+    fun resolvePrefersWhatTheCallerNamed() {
+        assertEquals("mobile_actions", Tasks.resolve("mobile_actions", "cola"))
+    }
+
+    @Test
+    fun resolveFallsBackToThePackagesDeclaration() {
+        assertEquals("cola", Tasks.resolve(null, "cola"))
+    }
+
+    @Test
+    fun resolveRejectsTheDefaultSentinelWithAnActionableMessage() {
+        // The exact input that crashed the app: DatasetConfig.task unset, package declaring nothing,
+        // so ORTTrainingConfig's default "none" reached the dispatch.
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            Tasks.resolve(null, Tasks.UNSET)
+        }
+        val message = error.message.orEmpty()
+        assertTrue(
+            "the message must say nothing NAMED a task, not that 'none' is an unknown one — " +
+                "'none' is a default the user never typed: $message",
+            message.contains("No task was named"),
+        )
+        assertTrue(
+            "the message must name the field to set: $message",
+            message.contains("DatasetConfig.task"),
+        )
+        for (name in Tasks.NAMES) {
+            assertTrue("the message must offer '$name': $message", message.contains(name))
+        }
+    }
+
+    @Test
+    fun resolveRejectsAMisspelledTask() {
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            Tasks.resolve("mobileactions", null)
+        }
+        assertTrue(error.message.orEmpty().contains("'mobileactions' is not a known task"))
+    }
+
+    @Test
+    fun resolveAllowsAnythingWhenTheCallerSuppliesAPreprocessor() {
+        // The name is never dispatched on in that case, so checking it would reject a legal setup.
+        assertEquals("whatever", Tasks.resolve("whatever", null, hasCustomPreprocess = true))
+    }
+
+    @Test
+    fun everyResolvedNameActuallyDispatches() {
+        // The point of the whole exercise: resolve() must not admit a name the trainer then rejects.
+        for (name in Tasks.NAMES) {
+            assertNotNull(getPreprocessFunctionForTask(Tasks.resolve(name, null)))
+        }
+    }
+
+    @Test
+    fun resolveTreatsBlankAsUnset() {
+        assertThrows(IllegalArgumentException::class.java) { Tasks.resolve("", "  ") }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TestSources.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TestSources.kt
new file mode 100644
index 0000000..d7ef84c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TestSources.kt
@@ -0,0 +1,42 @@
+package com.martinkorelic.mobiletransformers
+
+import java.io.File
+
+/**
+ * Reads a file out of this module's own source tree, for the handful of guards that can only be
+ * expressed over source.
+ *
+ * Some invariants have no runtime handle. A Kotlin `when` does not expose its branches, so "every
+ * dispatch branch is also listed in the public registry" can be checked only by reading the `when`.
+ * That is the same reasoning as `tests/unit/test_guards.py`, which greps the Kotlin sources from the
+ * Python side — this is its in-module equivalent, so a Kotlin-only invariant does not have to be
+ * enforced from another language's test suite.
+ *
+ * Walks up to the module root rather than assuming a working directory: Gradle's test JVM starts in
+ * the module directory, but the same tests are run from the repo root by `make test-jvm`.
+ */
+object TestSources {
+
+    private const val MODULE = "android/MobileTransformers/MobileTransformers"
+
+    private fun moduleRoot(): File {
+        var dir: File? = File("").absoluteFile
+        while (dir != null) {
+            // Either we are already inside the module, or we can see it from the repo root.
+            if (File(dir, "src/main/java/com/martinkorelic/mobiletransformers").isDirectory) return dir
+            val fromRepoRoot = File(dir, MODULE)
+            if (File(fromRepoRoot, "src/main/java/com/martinkorelic/mobiletransformers").isDirectory) {
+                return fromRepoRoot
+            }
+            dir = dir.parentFile
+        }
+        error("could not locate the SDK module from ${File("").absolutePath}")
+    }
+
+    /** @param relativePath path under `src/`, e.g. `main/java/.../DataUtil.kt`. */
+    fun read(relativePath: String): String {
+        val file = File(moduleRoot(), "src/$relativePath")
+        check(file.isFile) { "source not found: ${file.path}" }
+        return file.readText(Charsets.UTF_8)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TrainingMemoryProfileTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TrainingMemoryProfileTest.kt
new file mode 100644
index 0000000..2f4d9dd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/TrainingMemoryProfileTest.kt
@@ -0,0 +1,99 @@
+package com.martinkorelic.mobiletransformers
+
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.constants.MemoryConfigId
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Training defaults to the low-memory allocator profile. Inference does not.
+ *
+ * ### What `high_perf` actually does to a training run
+ *
+ * In `session_cache.h` it maps to `EnableMemPattern()` + `EnableCpuMemArena()`. For a forward-only
+ * inference session that is the right trade. For training it is not: the memory-pattern planner
+ * pre-allocates the whole backward activation plan, and the CPU arena grows to the peak and never
+ * gives it back.
+ *
+ * Measured on an S21 FE (5.5 GB): FunctionGemma-270M — 268,098,176 parameters, ~1.07 GB of fp32
+ * weights, 368,640 of them trainable — reached **2.35 GB RSS + 1.02 GB swap** and was SIGKILLed by
+ * `lmkd`. Roughly 3x the model, none of which the model needs.
+ *
+ * Three places had to agree, and each was a separate way to get `high_perf` back:
+ *  - `ORTTrainingConfig`'s own default,
+ *  - `parseTrainingArguments`, since exported `training_config.json` files carry **no** device
+ *    section at all, so its fallback *is* the setting for every real run,
+ *  - the public `TrainConfig`, which is what the app passes.
+ */
+@RunWith(RobolectricTestRunner::class)
+class TrainingMemoryProfileTest {
+
+    // FileUtil's parsers take a path and use org.json, which needs Robolectric on the JVM.
+    private val dir: File = Files.createTempDirectory("training-memory-profile").toFile()
+
+    @After
+    fun cleanup() = dir.deleteRecursively().let { }
+
+    private fun writeConfig(name: String, json: String): String =
+        File(dir, name).apply { writeText(json) }.absolutePath
+
+    @Test
+    fun theEngineLevelTrainingConfigDefaultsToLowMem() {
+        assertEquals(MemoryConfigId.LOW_MEM.wire, ORTTrainingConfig().deviceOptions.memoryConfigId)
+    }
+
+    @Test
+    fun thePublicTrainConfigDefaultsToLowMem() {
+        assertEquals(MemoryConfigId.LOW_MEM, TrainConfig().device.memoryConfigId)
+    }
+
+    @Test
+    fun thePublicDefaultSurvivesTheMappingToTheEngineConfig() {
+        // The app hands a TrainConfig to trainingJob().start(); if the mapper dropped the device
+        // options the default would be silently undone one layer down.
+        assertEquals(MemoryConfigId.LOW_MEM.wire, TrainConfig().toOrt().deviceOptions.memoryConfigId)
+    }
+
+    @Test
+    fun anExportedTrainingConfigWithNoDeviceSectionGetsLowMem() {
+        // Exactly what `variants/*/train/training_config.json` looks like: requires_grad and PEFT
+        // metadata, and nothing about the device. This fallback is the real-world setting.
+        val exported = writeConfig(
+            "training_config.json",
+            """{"requires_grad": ["a.lora_A.lora.weight"], "rank": 8, "alpha": 8}""",
+        )
+
+        val parsed = parseTrainingArguments(exported)
+
+        assertEquals(MemoryConfigId.LOW_MEM.wire, parsed.deviceOptions.memoryConfigId)
+    }
+
+    @Test
+    fun anExplicitHighPerfInTheConfigIsStillHonoured() {
+        // The default is a default, not a policy: a caller who wants the arena can have it.
+        val declared = writeConfig(
+            "training_config.json",
+            """{"deviceOptions": {"memoryConfigId": "high_perf", "coreConfigId": "opt1"}}""",
+        )
+
+        val parsed = parseTrainingArguments(declared)
+
+        assertEquals(MemoryConfigId.HIGH_PERF.wire, parsed.deviceOptions.memoryConfigId)
+    }
+
+    @Test
+    fun generationKeepsHighPerf() {
+        // The change must not leak into inference, where the arena is a win and no backward plan
+        // exists to pre-allocate.
+        val generationConfig =
+            parseGenerationArguments(writeConfig("generation_config.json", """{"repoName": "m"}"""))
+
+        assertEquals(MemoryConfigId.HIGH_PERF.wire, generationConfig.deviceOptions.memoryConfigId)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidatorTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidatorTest.kt
new file mode 100644
index 0000000..f33a60f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/FunctionCallValidatorTest.kt
@@ -0,0 +1,208 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+
+/**
+ * #37 self-check 2: "Does it **never** execute raw model output (allowlist + dry-run + validated tool
+ * calls)?"
+ *
+ * These are written as the shapes a wrong-but-plausible model output actually takes, not as a happy
+ * path plus one negative. A validator that only rejects malformed JSON provides no safety at all —
+ * the dangerous input is well-formed JSON naming something the app never declared.
+ */
+class FunctionCallValidatorTest {
+
+    private val alarm = ActionSpec(
+        actionName = "set_alarm",
+        parameters = mapOf("time" to "string", "label" to "string"),
+        allowedIntent = "android.intent.action.SET_ALARM",
+        validationRules = mapOf("time" to "HH:mm"),
+        privacyClass = "harmless-demo",
+    )
+    private val timer = ActionSpec(
+        actionName = "set_timer",
+        parameters = mapOf("seconds" to "string"),
+        allowedIntent = "android.intent.action.SET_TIMER",
+        validationRules = mapOf("seconds" to "/[0-9]{1,4}/"),
+    )
+    private val validator = FunctionCallValidator(listOf(alarm, timer))
+
+    @Test
+    fun acceptsAnAllowlistedCallThatSatisfiesItsRules() {
+        val call = validator.validate(
+            """{"actionName": "set_alarm", "parameters": {"time": "07:30", "label": "gym"}}"""
+        )
+
+        assertEquals("set_alarm", call.actionName)
+        assertEquals("android.intent.action.SET_ALARM", call.allowedIntent)
+        assertEquals(mapOf("time" to "07:30", "label" to "gym"), call.parameters)
+    }
+
+    @Test
+    fun rejectsAnActionTheAppNeverDeclared() {
+        // The dangerous input: perfectly well-formed JSON asking for something else entirely.
+        val error = assertThrows(RejectedCallException::class.java) {
+            validator.validate("""{"actionName": "wipe_device", "parameters": {}}""")
+        }
+        assertTrue(error.message!!.contains("not allowlisted"))
+        assertTrue("the message must name the offending action", error.message!!.contains("wipe_device"))
+    }
+
+    @Test
+    fun rejectsAnIntentSmuggledInAsAParameter() {
+        // A model cannot introduce an intent: `allowedIntent` is read from the app's spec, and an
+        // undeclared parameter is refused outright rather than ignored.
+        val error = assertThrows(RejectedCallException::class.java) {
+            validator.validate(
+                """{"actionName": "set_alarm", "parameters": {"time": "07:30", "label": "x",
+                   "allowedIntent": "android.intent.action.CALL"}}"""
+            )
+        }
+        assertTrue(error.message!!.contains("does not declare parameter"))
+    }
+
+    @Test
+    fun rejectsAValueThatBreaksItsRule() {
+        val error = assertThrows(RejectedCallException::class.java) {
+            validator.validate("""{"actionName": "set_alarm", "parameters": {"time": "25:99", "label": "x"}}""")
+        }
+        assertTrue(error.message!!.contains("does not satisfy rule"))
+        assertTrue(error.message!!.contains("25:99"))
+    }
+
+    @Test
+    fun rejectsAMissingParameterRatherThanDefaultingIt() {
+        // `alarm` declares no `requiredParameters`, so every declared parameter stays mandatory —
+        // the default must not loosen for allowlists written before optional parameters existed.
+        val error = assertThrows(RejectedCallException::class.java) {
+            validator.validate("""{"actionName": "set_alarm", "parameters": {"time": "07:30"}}""")
+        }
+        assertTrue(error.message!!.contains("missing required parameter"))
+        assertTrue(error.message!!.contains("label"))
+    }
+
+    @Test
+    fun rejectsMalformedOrEmptyOutput() {
+        for (raw in listOf("not json at all {", "", "   ")) {
+            assertThrows(
+                "raw output '$raw' must be rejected",
+                RejectedCallException::class.java,
+            ) { validator.validate(raw) }
+        }
+    }
+
+    @Test
+    fun rejectsJsonWithoutAnActionName() {
+        val error = assertThrows(RejectedCallException::class.java) {
+            validator.validate("""{"parameters": {"time": "07:30"}}""")
+        }
+        assertTrue(error.message!!.contains("actionName"))
+    }
+
+    @Test
+    fun anUnrecognisedRuleRejectsRatherThanPassingByDefault() {
+        // A typo in the app's allowlist must not silently disable the check it was written to perform.
+        val typo = FunctionCallValidator(
+            listOf(alarm.copy(validationRules = mapOf("time" to "HH:MM")))  // wrong case
+        )
+
+        assertThrows(RejectedCallException::class.java) {
+            typo.validate("""{"actionName": "set_alarm", "parameters": {"time": "07:30", "label": "x"}}""")
+        }
+    }
+
+    @Test
+    fun aRegexRuleIsAnchoredSoAPrefixDoesNotSlipThrough() {
+        assertEquals(
+            "60",
+            validator.validate("""{"actionName": "set_timer", "parameters": {"seconds": "60"}}""")
+                .parameters["seconds"],
+        )
+        // `Regex.matches` is whole-string; a trailing payload must not be accepted.
+        assertThrows(RejectedCallException::class.java) {
+            validator.validate("""{"actionName": "set_timer", "parameters": {"seconds": "60; rm -rf /"}}""")
+        }
+    }
+
+    @Test
+    fun aDuplicatedActionNameFailsAtConstructionNotSilently() {
+        // `associateBy` keeps the last silently, so two rows disagreeing about what is permitted would
+        // resolve to whichever came last in the list.
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            FunctionCallValidator(listOf(alarm, alarm.copy(allowedIntent = "android.intent.action.CALL")))
+        }
+        assertTrue(error.message!!.contains("duplicate action names"))
+    }
+
+    @Test
+    fun theReachableIntentSetIsFixedByTheAllowlist() {
+        // The property that makes this a boundary: every intent any accepted call can produce is one
+        // the app declared, so the set is knowable without reasoning about the model at all.
+        assertEquals(setOf("set_alarm", "set_timer"), validator.allowedActions)
+    }
+
+    // --- optional parameters, and loading the allowlist the dataset command emits ----------------
+
+    /** `send_email` in `google/mobile-actions`: 3 declared, 2 required. */
+    private val email = ActionSpec(
+        actionName = "send_email",
+        parameters = mapOf("to" to "string", "subject" to "string", "body" to "string"),
+        allowedIntent = "android.intent.action.SENDTO",
+        requiredParameters = setOf("to", "subject"),
+    )
+
+    @Test
+    fun anOptionalParameterMayBeOmitted() {
+        val call = FunctionCallValidator(listOf(email)).validate(
+            """{"actionName": "send_email", "parameters": {"to": "a@b.c", "subject": "hi"}}""",
+        )
+        assertEquals("send_email", call.actionName)
+        assertEquals(setOf("to", "subject"), call.parameters.keys)
+    }
+
+    @Test
+    fun aRequiredParameterMayNotBeOmitted() {
+        val error = assertThrows(RejectedCallException::class.java) {
+            FunctionCallValidator(listOf(email)).validate(
+                """{"actionName": "send_email", "parameters": {"to": "a@b.c"}}""",
+            )
+        }
+        assertTrue(error.message!!.contains("missing required parameter(s) [subject]"))
+    }
+
+    @Test
+    fun buildsFromTheActionSchemaTheDatasetCommandWrites() {
+        val file = File.createTempFile("action_schema", ".json").apply {
+            writeText(
+                """
+                [{"actionName": "show_map",
+                  "parameters": {"query": "string"},
+                  "allowedIntent": "android.intent.action.VIEW",
+                  "requiredParameters": ["query"],
+                  "validationRules": {},
+                  "privacyClass": "imported-corpus"}]
+                """.trimIndent(),
+            )
+            deleteOnExit()
+        }
+        val fromSchema = FunctionCallValidator.fromSchema(file)
+        assertEquals(setOf("show_map"), fromSchema.allowedActions)
+        assertEquals(
+            "android.intent.action.VIEW",
+            fromSchema.validate("""{"actionName": "show_map", "parameters": {"query": "gym"}}""").allowedIntent,
+        )
+    }
+
+    @Test
+    fun aMissingOrUnparseableSchemaFailsClosed() {
+        assertThrows(RejectedCallException::class.java) {
+            FunctionCallValidator.fromSchema(File("/nonexistent/action_schema.json"))
+        }
+        val bad = File.createTempFile("bad", ".json").apply { writeText("{not json"); deleteOnExit() }
+        assertThrows(RejectedCallException::class.java) { FunctionCallValidator.fromSchema(bad) }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/IntentBinderTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/IntentBinderTest.kt
new file mode 100644
index 0000000..5c94bff
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/IntentBinderTest.kt
@@ -0,0 +1,86 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #37 self-check 2, the binding half: the intended action is produced, and nothing runs it.
+ *
+ * Robolectric because `android.content.Intent` is a real framework class; the plain unit-test classpath
+ * stubs it, and `isReturnDefaultValues = false` makes that stub throw rather than quietly return null —
+ * which is what would otherwise let these assertions "pass" against a method that never ran.
+ */
+@RunWith(RobolectricTestRunner::class)
+class IntentBinderTest {
+
+    private val alarm = ActionSpec(
+        actionName = "set_alarm",
+        parameters = mapOf("time" to "string", "label" to "string"),
+        allowedIntent = "android.intent.action.SET_ALARM",
+        validationRules = mapOf("time" to "HH:mm"),
+        privacyClass = "harmless-demo",
+    )
+    private val validator = FunctionCallValidator(listOf(alarm))
+
+    private fun accepted() = validator.validate(
+        """{"actionName": "set_alarm", "parameters": {"time": "07:30", "label": "gym"}}"""
+    )
+
+    @Test
+    fun buildsTheDeclaredIntentWithTheValidatedParametersAsExtras() {
+        val action = IntentBinder.dryRun(accepted())
+
+        assertEquals("android.intent.action.SET_ALARM", action.intent.action)
+        assertEquals("07:30", action.intent.getStringExtra("time"))
+        assertEquals("gym", action.intent.getStringExtra("label"))
+    }
+
+    @Test
+    fun dryRunIsNeverMarkedExecutable() {
+        // The flag exists so a caller that chooses to execute must read it and act on it, rather than
+        // executing because the object happened to contain an Intent.
+        assertFalse(IntentBinder.dryRun(accepted()).willExecute)
+    }
+
+    @Test
+    fun theIntentActionComesFromTheAppsSpecNotFromModelOutput() {
+        // The property that makes this safe: a model selects an ACTION, it does not name an INTENT.
+        // Even a spec whose action name looks hostile yields only the intent the app declared.
+        val odd = ActionSpec(
+            actionName = "android.intent.action.CALL",  // a name, not an intent
+            parameters = emptyMap(),
+            allowedIntent = "android.intent.action.SET_ALARM",
+        )
+        val call = FunctionCallValidator(listOf(odd))
+            .validate("""{"actionName": "android.intent.action.CALL", "parameters": {}}""")
+
+        assertEquals("android.intent.action.SET_ALARM", IntentBinder.dryRun(call).intent.action)
+    }
+
+    @Test
+    fun onlyDeclaredParameterKeysReachTheExtras() {
+        // The validator refuses undeclared parameters, so no model-chosen key can appear here. Asserting
+        // it across the seam rather than trusting the validator's own test.
+        val action = IntentBinder.dryRun(accepted())
+
+        assertNull(action.intent.getStringExtra("allowedIntent"))
+        assertNull(action.intent.getStringExtra("uri"))
+    }
+
+    @Test
+    fun theBinderCarriesNoContextSoItCannotStartAnything() {
+        // Structural, not behavioural: `IntentBinder` is an object with no Context field and no
+        // startActivity call site. Executing is the caller's decision with the caller's own Context —
+        // deliberately not offered here, because the convenience is the risk.
+        val fields = IntentBinder::class.java.declaredFields.map { it.type.name }
+
+        assertFalse(
+            "IntentBinder must not hold a Context",
+            fields.any { it.contains("android.content.Context") },
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/MobileActionsParityTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/MobileActionsParityTest.kt
new file mode 100644
index 0000000..cfe85ea
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/MobileActionsParityTest.kt
@@ -0,0 +1,107 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import com.martinkorelic.mobiletransformers.MobileActionsPreprocessor
+import java.io.File
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #37 cross-language parity: **every training target the Python importer emits is a call this
+ * validator accepts.**
+ *
+ * This is the property the whole tool-call design rests on. `mobiletransformers agent-dataset` writes
+ * the training rows and the action schema from one corpus in one command; if the two could disagree,
+ * a model that learned the data perfectly would still be refused at the boundary, and the failure
+ * would only appear after an export → push → long device run.
+ *
+ * Both fixtures are generated by that command from
+ * `tests/fixtures/agent/mobile_actions_sample.jsonl` (excerpted from `google/mobile-actions`,
+ * CC-BY-4.0) and read here from the repo root — the same shared-oracle pattern `PackagesTest` uses,
+ * so Kotlin and Python cannot drift.
+ *
+ * Robolectric for the same reason `FileUtilParseTest` needs it: `org.json.JSONObject` and
+ * `android.content.Intent` are real framework classes that the plain unit-test classpath stubs, and
+ * `isReturnDefaultValues = false` makes those stubs throw rather than quietly return null.
+ */
+@RunWith(RobolectricTestRunner::class)
+class MobileActionsParityTest {
+
+    private fun repoRoot(): File {
+        var dir: File? = File("").absoluteFile
+        while (dir != null) {
+            if (File(dir, "tests/fixtures/agent/expected_action_schema.json").isFile) return dir
+            dir = dir.parentFile
+        }
+        error("could not locate repo root from ${File("").absolutePath}")
+    }
+
+    private fun fixtures() = File(repoRoot(), "tests/fixtures/agent")
+    private fun validator() = FunctionCallValidator.fromSchema(File(fixtures(), "expected_action_schema.json"))
+    private fun rows(): List<JSONObject> =
+        File(fixtures(), "expected_rows.jsonl").readLines()
+            .filter { it.isNotBlank() }
+            .map { JSONObject(it) }
+
+    @Test
+    fun everyEmittedCompletionIsAcceptedByTheValidator() {
+        val validator = validator()
+        val rows = rows()
+        assertTrue("fixture carries no rows", rows.isNotEmpty())
+
+        for (row in rows) {
+            val completion = row.getString("completion")
+            // Throws RejectedCallException on any disagreement, naming the offending entity.
+            val call = validator.validate(completion)
+            assertTrue(
+                "accepted call names an action outside the schema",
+                call.actionName in validator.allowedActions,
+            )
+        }
+    }
+
+    @Test
+    fun acceptedCallsCarryOnlyIntentsTheSchemaDeclared() {
+        val validator = validator()
+        val declared = FunctionCallValidator
+            .fromSchema(File(fixtures(), "expected_action_schema.json"))
+            .allowedActions
+
+        for (row in rows()) {
+            val call = validator.validate(row.getString("completion"))
+            assertTrue(call.actionName in declared)
+            // An action with no mapped Android intent is trainable and validatable but NEVER bindable;
+            // the importer leaves `allowedIntent` empty rather than inventing one.
+            if (call.allowedIntent.isNotEmpty()) {
+                val intended = IntentBinder.dryRun(call)
+                assertEquals(call.allowedIntent, intended.intent.action)
+                assertTrue("dry-run must never mark itself executable", !intended.willExecute)
+            }
+        }
+    }
+
+    @Test
+    fun theCuratorReadsTheEmittedRowShape() {
+        // The bridge that did not exist until 2026-08-14: without a preprocessor registered for this
+        // schema, `ORTDataCurator` drops every row and trains on nothing while reporting success.
+        for (row in rows()) {
+            val (input, label) = MobileActionsPreprocessor.preprocess(row)
+            assertTrue("prompt must not be blank", input.isNotBlank())
+            assertTrue("completion must not be blank", label.isNotBlank())
+            // The label IS the tool call — not a prose rendering of it.
+            assertEquals(row.getString("completion"), label)
+        }
+    }
+
+    @Test
+    fun aCallNamingAnActionOutsideTheCorpusIsStillRejected() {
+        // The schema is derived from data, which must not make it permissive.
+        val error = org.junit.Assert.assertThrows(RejectedCallException::class.java) {
+            validator().validate("""{"actionName": "wipe_device", "parameters": {}}""")
+        }
+        assertTrue(error.message!!.contains("not allowlisted"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallFramingTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallFramingTest.kt
new file mode 100644
index 0000000..37845af
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallFramingTest.kt
@@ -0,0 +1,224 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import com.martinkorelic.mobiletransformers.GenerateCallback
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.RetrieveCallback
+import com.martinkorelic.mobiletransformers.TrainCallback
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedRoundResult
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.rag.IngestionProgress
+import com.martinkorelic.mobiletransformers.rag.PromptStrategy
+import com.martinkorelic.mobiletransformers.runtime.ClassificationResult
+import com.martinkorelic.mobiletransformers.runtime.GenerationResult
+import com.martinkorelic.mobiletransformers.runtime.GroundedResult
+import com.martinkorelic.mobiletransformers.runtime.IngestResult
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.MergeResult
+import com.martinkorelic.mobiletransformers.runtime.ModelSession
+import com.martinkorelic.mobiletransformers.runtime.PushResult
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+import com.martinkorelic.mobiletransformers.training.TrainingJob
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * A tool-call prompt must be framed exactly **once**.
+ *
+ * [ToolPromptBuilder] writes a complete `<start_of_turn>…` turn structure of its own, deliberately:
+ * FunctionGemma's shipped chat template is 13 KB of `namespace()`, `dictsort` and macros Pebble cannot
+ * evaluate, so relying on the tokenizer to supply the framing was never an option for the one family
+ * that most needs it.
+ *
+ * That made a *second* framing impossible for a while, and the invariant went unenforced as a result:
+ * `ORTTokenizerNative` read the chat template only from `tokenizer_config.json`, the exporter has only
+ * ever written it to a sibling `chat_template.jinja`, so `chatTemplate` was null for every package and
+ * the generator never wrapped anything. Teaching the tokenizer to read that sibling file (see
+ * `ChatTemplateResolutionTest`) turns the dormant hazard live for any package whose template Pebble
+ * *can* render — SmolLM2's, for one. [toolCallPromptsAreNotWrappedTwice] pins the guard; it fails if
+ * `generateToolCall` stops suppressing the template.
+ */
+class ToolCallFramingTest {
+
+    /** Records the [GenerationConfig] each generate() was handed, which is the thing under test. */
+    private class RecordingSession(override val capabilities: RuntimeCapabilities) : ModelSession {
+        val configs = mutableListOf<GenerationConfig>()
+        val prompts = mutableListOf<String>()
+
+        override suspend fun generate(
+            prompt: String,
+            config: GenerationConfig,
+            callback: GenerateCallback?,
+        ): GenerationResult {
+            prompts += prompt
+            configs += config
+            // Not a tool call — generateToolCall then returns NoCall, which is fine: this test is
+            // about what went IN, not what came back.
+            return GenerationResult(text = "no call here", tokenCount = 3)
+        }
+
+        override suspend fun applyPeft(peft: PeftConfig) = Unit
+        override suspend fun train(dataset: DatasetConfig, config: TrainConfig, callback: TrainCallback?) =
+            TrainingResult(finalStep = 0, merged = false)
+        override fun trainingJob(): TrainingJob = throw UnsupportedOperationException()
+        override suspend fun merge() = MergeResult(merged = false)
+        override suspend fun retrieve(query: String, config: RagConfig, callback: RetrieveCallback?) =
+            RetrievalResult()
+        override suspend fun ingest(path: String, config: RagConfig, progress: IngestionProgress?) =
+            IngestResult(0)
+        override suspend fun classify(text: String, device: DeviceConfig, topK: Int) =
+            ClassificationResult()
+        override suspend fun generateWithRag(
+            query: String,
+            rag: RagConfig,
+            generation: GenerationConfig,
+            promptStrategy: PromptStrategy,
+            callback: com.martinkorelic.mobiletransformers.GenerateCallback?,
+            retrieveCallback: com.martinkorelic.mobiletransformers.RetrieveCallback?,
+        ) = GroundedResult("")
+        override suspend fun pushAdapter(hubConfig: HubConfig, repoId: String) = PushResult(repoId)
+        override suspend fun federatedRound(
+            config: FederatedConfig,
+            globalRecord: ByteArray?,
+            roundNumber: Int,
+            localTraining: LocalRoundTraining,
+            metrics: Map<String, Double>,
+            train: Boolean,
+        ) = FederatedRoundResult(round = roundNumber, importedTensors = 0, update = ByteArray(0), trainedLocally = false)
+        override fun close() = Unit
+    }
+
+    private fun caps() =
+        RuntimeCapabilities(
+            engine = InferenceEngine.NATIVE,
+            supportsTraining = false,
+            supportsMerge = false,
+            supportsRag = false,
+            supportsEmbedding = false,
+        )
+
+    private fun validator() =
+        FunctionCallValidator(
+            listOf(
+                ActionSpec(
+                    actionName = "set_alarm",
+                    parameters = mapOf("time" to "string"),
+                    allowedIntent = "android.intent.action.SET_ALARM",
+                    validationRules = mapOf("time" to "HH:mm"),
+                    privacyClass = "harmless-demo",
+                ),
+            ),
+        )
+
+    /** The guard: having framed the turns itself, the facade must suppress the tokenizer's template. */
+    @Test
+    fun toolCallPromptsAreNotWrappedTwice() = runBlocking {
+        val session = RecordingSession(caps())
+        val model = MobileTransformerModel(session, caps(), "test/repo")
+
+        model.generateToolCall("wake me at 07:30", validator(), parser = ToolCallParser.FunctionGemma)
+
+        assertEquals(1, session.configs.size)
+        assertFalse(
+            "generateToolCall framed the prompt itself, so the chat template must be suppressed",
+            session.configs.single().applyChatTemplate,
+        )
+        assertTrue(
+            "sanity: the prompt really was framed by ToolPromptBuilder",
+            session.prompts.single().contains("<start_of_turn>"),
+        )
+    }
+
+    /**
+     * The distinction the blanket version got wrong. The JSON dialect emits **no** turn markers — just
+     * declarations and the instruction — so the chat template is what supplies the framing there.
+     * Suppressing it would strip framing rather than de-duplicate it, leaving a JSON-dialect model on
+     * a template-carrying package worse off than before the template was ever read.
+     */
+    @Test
+    fun jsonDialectToolCallsKeepTheTemplateBecauseTheyAreNotSelfFramed() = runBlocking {
+        val session = RecordingSession(caps())
+        val model = MobileTransformerModel(session, caps(), "test/repo")
+
+        model.generateToolCall("wake me at 07:30", validator(), parser = ToolCallParser.Json)
+
+        assertTrue(
+            "the JSON branch frames no turns, so the template must still apply",
+            session.configs.single().applyChatTemplate,
+        )
+        assertFalse(session.prompts.single().contains("<start_of_turn>"))
+    }
+
+    /** The predicate the facade keys on must agree with what the builder actually emits. */
+    @Test
+    fun framesOwnTurnsAgreesWithTheRenderedPrompt() {
+        val allowlist = validator().allowlist
+        for (parser in listOf(ToolCallParser.FunctionGemma, ToolCallParser.Json)) {
+            val rendered = ToolPromptBuilder.prompt(allowlist, parser, "hi")
+            assertEquals(
+                "framesOwnTurns disagrees with the rendered prompt for $parser",
+                ToolPromptBuilder.framesOwnTurns(parser),
+                rendered.contains("<start_of_turn>"),
+            )
+        }
+    }
+
+    /**
+     * `declareTools = false` means the caller supplied the whole prompt and wants the session's normal
+     * behaviour, template included. Suppressing it there would silently strip framing the caller was
+     * relying on.
+     */
+    @Test
+    fun anUnframedToolCallLeavesTheTemplateAlone() = runBlocking {
+        val session = RecordingSession(caps())
+        val model = MobileTransformerModel(session, caps(), "test/repo")
+
+        model.generateToolCall("wake me at 07:30", validator(), declareTools = false)
+
+        assertTrue(session.configs.single().applyChatTemplate)
+        assertEquals("wake me at 07:30", session.prompts.single())
+    }
+
+    /** Plain chat keeps the template. This is the whole point of reading `chat_template.jinja`. */
+    @Test
+    fun plainGenerationKeepsTheTemplate() = runBlocking {
+        val session = RecordingSession(caps())
+        val model = MobileTransformerModel(session, caps(), "test/repo")
+
+        model.generate("hello")
+
+        assertTrue(session.configs.single().applyChatTemplate)
+    }
+
+    /** The flag has to survive the public→internal mapping, or the guard never reaches the generator. */
+    @Test
+    fun theFlagSurvivesTheConfigMapping() {
+        assertFalse(GenerationConfig(applyChatTemplate = false).toOrt().applyChatTemplate)
+        assertTrue(GenerationConfig().toOrt().applyChatTemplate)
+    }
+
+    /** `overrideConfig` merges field-by-field; an explicit false must not be lost to the default. */
+    @Test
+    fun overrideConfigCarriesAnExplicitSuppression() {
+        val base = ORTGenerationConfig()
+        assertFalse(base.overrideConfig(ORTGenerationConfig(applyChatTemplate = false)).applyChatTemplate)
+        // And an override that says nothing leaves the base alone.
+        assertFalse(
+            ORTGenerationConfig(applyChatTemplate = false).overrideConfig(ORTGenerationConfig()).applyChatTemplate,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallParserTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallParserTest.kt
new file mode 100644
index 0000000..0a253c2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallParserTest.kt
@@ -0,0 +1,165 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #37: reading a tool call out of whatever dialect the model speaks.
+ *
+ * The case that forced this to exist: `FunctionCallValidator` parsed JSON, and **FunctionGemma does
+ * not emit JSON**. Its calls look like
+ * `<start_function_call>call:set_alarm{time:<escape>07:30<escape>}<end_function_call>`, which a JSON
+ * parser reports as a syntax error — so a correctly fine-tuned FunctionGemma had every well-formed
+ * call rejected, and no further training could have changed that.
+ *
+ * The samples below are Google's documented ones, kept verbatim so the parser is checked against the
+ * specification rather than against our own idea of it.
+ */
+class ToolCallParserTest {
+
+    private val gemma = ToolCallParser.FunctionGemma
+    private val json = ToolCallParser.Json
+
+    // --- FunctionGemma ---------------------------------------------------------
+
+    @Test
+    fun parsesTheDocumentedFunctionGemmaCall() {
+        val raw = "<start_function_call>call:get_current_weather" +
+            "{location:<escape>Tokyo, Japan<escape>}<end_function_call>"
+
+        val call = gemma.parse(raw)
+        assertNotNull(call)
+        assertEquals("get_current_weather", call!!.actionName)
+        // The comma is INSIDE the value. `<escape>` exists precisely so it can be, and a parser that
+        // splits fields on every comma turns this into two parameters, the second named " Japan".
+        assertEquals(mapOf("location" to "Tokyo, Japan"), call.parameters)
+    }
+
+    @Test
+    fun aColonInsideAValueIsNotAFieldSeparator() {
+        val call = gemma.parse("<start_function_call>call:set_alarm{time:<escape>07:30<escape>}<end_function_call>")
+        assertEquals(mapOf("time" to "07:30"), call?.parameters)
+    }
+
+    @Test
+    fun parsesSeveralParametersIncludingBareValues() {
+        val call = gemma.parse(
+            "<start_function_call>call:set_timer{seconds:90,label:<escape>tea, strong<escape>}" +
+                "<end_function_call>",
+        )
+        // A bare numeric keeps its text form: `validationRules` are regexes over strings, so
+        // "/[0-9]{1,4}/" must see "90" rather than a parsed number.
+        assertEquals(mapOf("seconds" to "90", "label" to "tea, strong"), call?.parameters)
+    }
+
+    @Test
+    fun anActionWithNoParametersParses() {
+        val call = gemma.parse("<start_function_call>call:open_wifi_settings{}<end_function_call>")
+        assertEquals("open_wifi_settings", call?.actionName)
+        assertEquals(emptyMap<String, String>(), call?.parameters)
+    }
+
+    /**
+     * Generation stops at `maxNewTokens`, so a call whose end token never arrived is routine. What was
+     * emitted is still the model's answer, and refusing it reports a model failure for what is really
+     * a configuration choice.
+     */
+    @Test
+    fun aTruncatedCallStillParses() {
+        val call = gemma.parse("<start_function_call>call:set_alarm{time:<escape>07:30<escape>}")
+        assertEquals("set_alarm", call?.actionName)
+        assertEquals(mapOf("time" to "07:30"), call?.parameters)
+    }
+
+    @Test
+    fun aClosingBraceInsideAValueDoesNotEndTheCall() {
+        val call = gemma.parse(
+            "<start_function_call>call:note{body:<escape>use {braces} freely<escape>,tag:x}<end_function_call>",
+        )
+        assertEquals(mapOf("body" to "use {braces} freely", "tag" to "x"), call?.parameters)
+    }
+
+    @Test
+    fun proseAroundTheCallIsIgnored() {
+        val call = gemma.parse(
+            "Sure, I'll do that.\n<start_function_call>call:set_alarm{time:<escape>08:00<escape>}" +
+                "<end_function_call>\nAnything else?",
+        )
+        assertEquals("set_alarm", call?.actionName)
+    }
+
+    @Test
+    fun textWithNoCallYieldsNull() {
+        assertNull(gemma.parse("I'm sorry, I can't help with that."))
+        assertNull(gemma.parse(""))
+    }
+
+    // --- JSON ------------------------------------------------------------------
+
+    @Test
+    fun jsonParserReadsAFencedObject() {
+        val call = json.parse("""Sure! ```json {"actionName":"set_alarm","parameters":{"time":"07:30"}} ```""")
+        assertEquals("set_alarm", call?.actionName)
+        assertEquals(mapOf("time" to "07:30"), call?.parameters)
+    }
+
+    @Test
+    fun jsonParserYieldsNullOnFunctionGemmaOutput() {
+        // The regression itself: this is a perfectly good call that the JSON reader cannot see.
+        assertNull(json.parse("<start_function_call>call:set_alarm{time:<escape>07:30<escape>}<end_function_call>"))
+    }
+
+    @Test
+    fun jsonParserYieldsNullOnProseWithNoObject() {
+        assertNull(json.parse("I can't do that."))
+    }
+
+    // --- selection -------------------------------------------------------------
+
+    @Test
+    fun theParserIsChosenFromTheModelFamily() {
+        assertEquals(ToolCallParser.FunctionGemma, ToolCallParser.forModel("mobiletransformers/functiongemma-270m-it"))
+        assertEquals(ToolCallParser.FunctionGemma, ToolCallParser.forModel("google/FunctionGemma-270M-IT"))
+        assertEquals(ToolCallParser.Json, ToolCallParser.forModel("HuggingFaceTB/SmolLM2-135M-Instruct"))
+        assertEquals(ToolCallParser.Json, ToolCallParser.forModel(null))
+    }
+
+    // --- the boundary is unchanged ---------------------------------------------
+
+    /**
+     * The point of the whole seam: a new parser must widen what can be *recognised*, never what can be
+     * *permitted*. A FunctionGemma call naming an action the app never declared is still refused.
+     */
+    @Test
+    fun anUndeclaredActionIsStillRejectedWhicheverDialectItArrivesIn() {
+        val validator = FunctionCallValidator(
+            listOf(ActionSpec(actionName = "set_alarm", parameters = mapOf("time" to "string"), allowedIntent = "X")),
+        )
+        val call = gemma.parse("<start_function_call>call:wipe_device{}<end_function_call>")!!
+        val error = assertThrows(RejectedCallException::class.java) { validator.validate(call) }
+        assertTrue(error.message!!.contains("not allowlisted"))
+    }
+
+    @Test
+    fun aParsedCallStillHasToSatisfyItsValidationRules() {
+        val validator = FunctionCallValidator(
+            listOf(
+                ActionSpec(
+                    actionName = "set_alarm",
+                    parameters = mapOf("time" to "string"),
+                    allowedIntent = "X",
+                    validationRules = mapOf("time" to "HH:mm"),
+                ),
+            ),
+        )
+        val bad = gemma.parse("<start_function_call>call:set_alarm{time:<escape>quarter past<escape>}<end_function_call>")!!
+        assertThrows(RejectedCallException::class.java) { validator.validate(bad) }
+
+        val good = gemma.parse("<start_function_call>call:set_alarm{time:<escape>07:30<escape>}<end_function_call>")!!
+        assertEquals("set_alarm", validator.validate(good).actionName)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallResultTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallResultTest.kt
new file mode 100644
index 0000000..028d670
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolCallResultTest.kt
@@ -0,0 +1,128 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #37: the accept/reject seam and the JSON extraction that feeds it.
+ *
+ * No Robolectric — that is the point of `Accepted.dryRun()` being a method rather than a field. The
+ * decision logic is framework-free and testable here; only a caller that actually wants an `Intent`
+ * pays for the framework (`IntentBinderTest`, `MobileActionsParityTest`).
+ */
+class ToolCallResultTest {
+
+    private val alarm = ActionSpec(
+        actionName = "set_alarm",
+        parameters = mapOf("time" to "string"),
+        allowedIntent = "android.intent.action.SET_ALARM",
+        validationRules = mapOf("time" to "HH:mm"),
+    )
+    private val validator = FunctionCallValidator(listOf(alarm))
+
+    /** What `generateToolCall` does, minus the model — kept in step with it by the assertions below. */
+    private fun classify(raw: String, extractJson: Boolean = true): ToolCallResult {
+        val candidate = if (extractJson) extractFirstJsonObject(raw) else raw
+        return try {
+            ToolCallResult.Accepted(raw, validator.validate(candidate))
+        } catch (e: RejectedCallException) {
+            ToolCallResult.Rejected(raw, e.message ?: "rejected")
+        }
+    }
+
+    // --- extraction -----------------------------------------------------------
+
+    @Test
+    fun extractsTheCallOutOfSurroundingProse() {
+        val raw = """Sure! Here you go:
+            |```json
+            |{"actionName": "set_alarm", "parameters": {"time": "07:30"}}
+            |```
+            |Anything else?
+        """.trimMargin()
+        assertEquals(
+            """{"actionName": "set_alarm", "parameters": {"time": "07:30"}}""",
+            extractFirstJsonObject(raw),
+        )
+        assertTrue(classify(raw) is ToolCallResult.Accepted)
+    }
+
+    @Test
+    fun bracesInsideStringValuesDoNotEndTheObjectEarly() {
+        // Brace-counting that ignored string literals would cut this off mid-object and report a
+        // syntax error for output that is perfectly well-formed.
+        val raw = """{"actionName": "set_alarm", "parameters": {"time": "07:30", "note": "a } brace"}}"""
+        assertEquals(raw, extractFirstJsonObject(raw))
+    }
+
+    @Test
+    fun escapedQuotesInsideStringsAreRespected() {
+        val raw = """prefix {"actionName": "x", "parameters": {"s": "say \"hi\" }"}} suffix"""
+        assertEquals(
+            """{"actionName": "x", "parameters": {"s": "say \"hi\" }"}}""",
+            extractFirstJsonObject(raw),
+        )
+    }
+
+    @Test
+    fun textWithNoBalancedObjectIsReturnedUnchangedSoTheValidatorReportsTheRealProblem() {
+        assertEquals("I'm not sure", extractFirstJsonObject("I'm not sure"))
+        assertEquals("{\"unclosed\": 1", extractFirstJsonObject("{\"unclosed\": 1"))
+    }
+
+    @Test
+    fun extractionCanBeTurnedOffToDemandBareJson() {
+        val raw = """Sure: {"actionName": "set_alarm", "parameters": {"time": "07:30"}}"""
+        assertTrue(classify(raw, extractJson = true) is ToolCallResult.Accepted)
+        assertTrue(classify(raw, extractJson = false) is ToolCallResult.Rejected)
+    }
+
+    // --- the boundary is not weakened by extraction ---------------------------
+
+    @Test
+    fun extractionCannotAdmitAnActionTheAppNeverDeclared() {
+        // The whole safety question for extraction, asked directly: choosing a substring must not
+        // change *which* actions are reachable.
+        val raw = """Of course. {"actionName": "wipe_device", "parameters": {}}"""
+        val result = classify(raw)
+        assertTrue(result is ToolCallResult.Rejected)
+        assertTrue((result as ToolCallResult.Rejected).reason.contains("not allowlisted"))
+    }
+
+    @Test
+    fun extractionCannotBypassAValidationRule() {
+        val raw = """Here: {"actionName": "set_alarm", "parameters": {"time": "25:99"}}"""
+        val result = classify(raw)
+        assertTrue(result is ToolCallResult.Rejected)
+        assertTrue((result as ToolCallResult.Rejected).reason.contains("does not satisfy rule"))
+    }
+
+    // --- the result type ------------------------------------------------------
+
+    @Test
+    fun bothOutcomesKeepTheRawTextForDisplayAndDebugging() {
+        val good = """{"actionName": "set_alarm", "parameters": {"time": "07:30"}}"""
+        val bad = "no idea"
+        assertEquals(good, classify(good).raw)
+        assertEquals(bad, classify(bad).raw)
+    }
+
+    @Test
+    fun anAcceptedCallCarriesTheAppsIntentNotTheModelsText() {
+        val result = classify(
+            """{"actionName": "set_alarm", "parameters": {"time": "07:30", }}"""
+                .replace(", }", " }"),
+        )
+        assertTrue(result is ToolCallResult.Accepted)
+        // Read off the ActionSpec, so it is knowable without reasoning about the model at all.
+        assertEquals("android.intent.action.SET_ALARM", (result as ToolCallResult.Accepted).call.allowedIntent)
+    }
+
+    @Test
+    fun rejectionNamesTheOffendingEntity() {
+        val result = classify("""{"actionName": "set_alarm", "parameters": {"time": "07:30", "x": "1"}}""")
+        val reason = (result as ToolCallResult.Rejected).reason
+        assertTrue("message must name the parameter, not just say 'invalid': $reason", reason.contains("[x]"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilderTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilderTest.kt
new file mode 100644
index 0000000..c208059
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/agent/ToolPromptBuilderTest.kt
@@ -0,0 +1,100 @@
+package com.martinkorelic.mobiletransformers.agent
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The prompt a tool-calling turn actually sends.
+ *
+ * ### Why the turn markers matter
+ *
+ * `generateToolCall` used to send `declarations + "\n" + instruction` with no turn structure at all.
+ * FunctionGemma is trained on `<start_of_turn>developer … <end_of_turn><start_of_turn>user …
+ * <end_of_turn><start_of_turn>model`, and the framing normally comes from the tokenizer's chat
+ * template — but the exporter writes that template to a sibling `chat_template.jinja` which
+ * `ORTTokenizerNative` does not read, so `chatTemplate` is null on device and **nothing** wrapped the
+ * prompt. The model was handed a bare instruction in a shape it has never been trained on and asked
+ * for a grammar it only emits inside a model turn.
+ */
+class ToolPromptBuilderTest {
+
+    private val allowlist = listOf(
+        ActionSpec(
+            actionName = "set_alarm",
+            parameters = mapOf("time" to "string"),
+            requiredParameters = setOf("time"),
+            validationRules = mapOf("time" to "^([01][0-9]|2[0-3]):[0-5][0-9]$"),
+            allowedIntent = "android.intent.action.SET_ALARM",
+        ),
+        ActionSpec(
+            actionName = "toggle_wifi",
+            parameters = emptyMap(),
+            allowedIntent = "android.settings.WIFI_SETTINGS",
+        ),
+    )
+
+    @Test
+    fun theFunctionGemmaPromptCarriesTheTurnStructureTheModelWasTrainedOn() {
+        val prompt = ToolPromptBuilder.prompt(allowlist, ToolCallParser.FunctionGemma, "wake me at 07:30")
+
+        assertTrue("declarations belong in the developer turn", prompt.contains("<start_of_turn>developer"))
+        assertTrue(prompt.contains("<start_function_declaration>declaration:set_alarm"))
+        assertTrue(prompt.contains("<end_of_turn>"))
+        assertTrue("the instruction belongs in the user turn", prompt.contains("<start_of_turn>user\nwake me at 07:30"))
+        assertTrue("the floor must be handed to the model", prompt.trimEnd().endsWith("<start_of_turn>model"))
+    }
+
+    @Test
+    fun theDeveloperTurnClosesBeforeTheUserTurnOpens() {
+        val prompt = ToolPromptBuilder.prompt(allowlist, ToolCallParser.FunctionGemma, "turn on wifi")
+
+        val developerAt = prompt.indexOf("<start_of_turn>developer")
+        val userAt = prompt.indexOf("<start_of_turn>user")
+        val closeAt = prompt.indexOf("<end_of_turn>")
+
+        assertTrue(developerAt in 0 until closeAt)
+        assertTrue("the developer turn must close before the user turn opens", closeAt < userAt)
+    }
+
+    @Test
+    fun everyAllowlistedActionIsDeclared() {
+        // The declaration and the boundary come from one object on purpose: a model asked for an
+        // action it was never shown cannot produce it, and one shown an action the validator does
+        // not permit is being taught to be refused.
+        val prompt = ToolPromptBuilder.prompt(allowlist, ToolCallParser.FunctionGemma, "hi")
+
+        for (spec in allowlist) {
+            assertTrue("'${spec.actionName}' was not declared", prompt.contains(spec.actionName))
+        }
+    }
+
+    @Test
+    fun theJsonDialectIsNotGivenGemmaTurnMarkers() {
+        // Framing is dialect-specific for the same reason the parser is. A SmolLM2 package has never
+        // seen <start_of_turn>developer and would treat it as content.
+        val prompt = ToolPromptBuilder.prompt(allowlist, ToolCallParser.Json, "wake me at 07:30")
+
+        assertFalse(prompt.contains("<start_of_turn>"))
+        assertTrue(prompt.contains("actionName"))
+        assertTrue(prompt.contains("wake me at 07:30"))
+    }
+
+    @Test
+    fun theInstructionIsNeverLost() {
+        for (parser in listOf(ToolCallParser.FunctionGemma, ToolCallParser.Json)) {
+            val prompt = ToolPromptBuilder.prompt(allowlist, parser, "set an alarm for quarter past six")
+            assertTrue(prompt.contains("set an alarm for quarter past six"))
+        }
+    }
+
+    @Test
+    fun aFunctionResponseRoundTripsThroughTheParsersGrammar() {
+        // The second half of the loop: what the app feeds back must be in the same dialect it read.
+        val response = ToolPromptBuilder.functionResponse("set_alarm", mapOf("status" to "ok"))
+
+        assertTrue(response.startsWith("<start_function_response>response:set_alarm{"))
+        assertTrue(response.contains("status:<escape>ok<escape>"))
+        assertTrue(response.endsWith("<end_function_response>"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMapperTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMapperTest.kt
new file mode 100644
index 0000000..d8b71b2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMapperTest.kt
@@ -0,0 +1,71 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.ORTGenerationConfig
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import com.martinkorelic.mobiletransformers.SchedulerConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/** #17: public configs map 1:1 to the existing ORT*Config defaults (no behavior shift). */
+class ConfigMapperTest {
+
+    @Test
+    fun trainConfigDefaultsMatchOrtDefaults() {
+        assertEquals(ORTTrainingConfig(), TrainConfig().toOrt())
+    }
+
+    @Test
+    fun generationConfigDefaultsMatchOrtDefaults() {
+        // #11: the mapper now states the engine explicitly rather than leaving it unset. That is the
+        // one deliberate delta from the bare ORT defaults — `engine` stays nullable on
+        // ORTGenerationConfig so `overrideConfig`'s `override.engine ?: this.engine` fallback keeps
+        // working (a non-null default would let an indifferent override clobber a GENAI base).
+        assertEquals(ORTGenerationConfig(engine = InferenceEngine.NATIVE), GenerationConfig().toOrt())
+    }
+
+    @Test
+    fun ragConfigDefaultsMatchOrtDefaults() {
+        assertEquals(ORTRagConfig(), RagConfig().toOrt())
+    }
+
+    @Test
+    fun trainConfigNonDefaultsPropagate() {
+        val ort = TrainConfig(epochs = 3, batchSize = 8, maxSteps = 50, mergeAtEnd = false).toOrt()
+        assertEquals(3, ort.numTrainEpochs)
+        assertEquals(8, ort.batchSize)
+        assertEquals(50, ort.maxSteps)
+        assertEquals(false, ort.mergeWeightsAtEnd)
+    }
+
+    @Test
+    fun cosineSchedulerMapsToCosineConfig() {
+        val ort =
+            TrainConfig(scheduler = SchedulerType.COSINE, warmupSteps = 20, minLearningRate = 1e-5f).toOrt()
+        assertEquals("cosine", ort.schedulerType)
+        val cfg = ort.schedulerConfig
+        assertEquals(true, cfg is SchedulerConfig.Cosine)
+        cfg as SchedulerConfig.Cosine
+        assertEquals(20, cfg.warmupSteps)
+    }
+
+    @Test
+    fun generationMaxNewTokensMapsToMaxSequenceLength() {
+        assertEquals(256, GenerationConfig(maxNewTokens = 256).toOrt().maxSequenceLength)
+        assertEquals("native", GenerationConfig().toOrt().type)
+    }
+
+    @Test
+    fun deviceConfigMapsProvider() {
+        val ort = DeviceConfig(executionProvider = ExecutionProvider.NNAPI).toOrt()
+        assertEquals("nnapi", ort.executionProvider)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMappingDeltaTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMappingDeltaTest.kt
new file mode 100644
index 0000000..c3adabd
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ConfigMappingDeltaTest.kt
@@ -0,0 +1,70 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #19/#24: the engine- and merge-state-driven bits of the generation mapping, plus the dataset mapping.
+ * (The 1:1 defaults round-trip is covered by [ConfigMapperTest].)
+ */
+class ConfigMappingDeltaTest {
+
+    @Test
+    fun engineDrivesGenerationType() {
+        assertEquals("native", GenerationConfig().toOrt(InferenceEngine.NATIVE).type)
+        assertEquals("genai", GenerationConfig().toOrt(InferenceEngine.GENAI).type)
+    }
+
+    /**
+     * #11 regression: the mapper used to set only [ORTGenerationConfig.type] and leave `engine` null.
+     * `ModelRuntimeFactory.selectEngine` reads `engine`, not `type`, so every session — including an
+     * explicit GENAI request — resolved to NATIVE, and the GenAI path was unreachable end to end.
+     */
+    @Test
+    fun engineFieldIsCarriedThroughForRuntimeSelection() {
+        assertEquals(InferenceEngine.NATIVE, GenerationConfig().toOrt(InferenceEngine.NATIVE).engine)
+        assertEquals(InferenceEngine.GENAI, GenerationConfig().toOrt(InferenceEngine.GENAI).engine)
+        // The no-arg overload keeps the #17 default rather than leaving selection unspecified.
+        assertEquals(InferenceEngine.NATIVE, GenerationConfig().toOrt().engine)
+    }
+
+    /** The two fields must never disagree — `type` is derived from `engine` by the same mapper. */
+    @Test
+    fun engineAndTypeAgree() {
+        for (engine in InferenceEngine.entries) {
+            val ort = GenerationConfig().toOrt(engine)
+            assertEquals(engine, ort.engine)
+            assertEquals(if (engine == InferenceEngine.GENAI) "genai" else "native", ort.type)
+        }
+    }
+
+    @Test
+    fun mergeStateDrivesLoadMergedWeights() {
+        assertFalse(GenerationConfig().toOrt(InferenceEngine.NATIVE, mergedLoaded = false).loadMergedWeights)
+        assertTrue(GenerationConfig().toOrt(InferenceEngine.NATIVE, mergedLoaded = true).loadMergedWeights)
+    }
+
+    @Test
+    fun defaultsPreserveNativeAndConfigLoadFlag() {
+        // No-arg overload must still equal the #17 behavior (native + the config's own loadMerged=false).
+        val ort = GenerationConfig().toOrt()
+        assertEquals("native", ort.type)
+        assertFalse(ort.loadMergedWeights)
+    }
+
+    @Test
+    fun datasetConfigMapsToDatasetOptions() {
+        val ds = DatasetConfig(trainFile = "squad", maxSequenceLength = 99, datasetBatchSize = 7, maxDatasetLength = 33)
+        val opts = ds.toOrt()
+        assertEquals("squad", opts.trainFile)
+        assertEquals(99, opts.maxSequenceLength)
+        assertEquals(7, opts.datasetBatchSize)
+        assertEquals(33, opts.maxDatasetLength)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ExceptionMessageTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ExceptionMessageTest.kt
new file mode 100644
index 0000000..a4d4497
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/ExceptionMessageTest.kt
@@ -0,0 +1,60 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.EngineUnavailableException
+import com.martinkorelic.mobiletransformers.FeatureNotInstalledException
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.ModelNotInstalledException
+import com.martinkorelic.mobiletransformers.NotImplementedFeatureException
+import com.martinkorelic.mobiletransformers.PeftMismatchException
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #19: the facade error hierarchy fails closed with friendly, path-naming messages.
+ */
+class ExceptionMessageTest {
+
+    @Test
+    fun missingArtifactNamesTheExactPath() {
+        val path = "/data/pkg/train/training_config.json"
+        val ex = MissingArtifactException(ModelFeature.Training, path)
+        assertTrue(ex.message!!.contains(path))
+        assertTrue(ex.message!!.contains("Training"))
+    }
+
+    @Test
+    fun modelNotInstalledNamesRepoAndCache() {
+        val ex = ModelNotInstalledException("org/model", "/data/cache")
+        assertTrue(ex.message!!.contains("org/model"))
+        assertTrue(ex.message!!.contains("/data/cache"))
+    }
+
+    @Test
+    fun featureNotInstalledListsInstalled() {
+        val ex = FeatureNotInstalledException(ModelFeature.Rag, setOf(ModelFeature.Inference, ModelFeature.Training))
+        assertTrue(ex.message!!.contains("Rag"))
+        assertTrue(ex.message!!.contains("Inference"))
+        assertTrue(ex.message!!.contains("Training"))
+    }
+
+    @Test
+    fun engineUnavailableNamesEngineAndReason() {
+        val ex = EngineUnavailableException(InferenceEngine.GENAI, "genai_config.json not found")
+        assertTrue(ex.message!!.contains("GENAI"))
+        assertTrue(ex.message!!.contains("genai_config.json"))
+    }
+
+    @Test
+    fun peftMismatchListsSupported() {
+        val ex = PeftMismatchException("lora", listOf("mars (optimization_level=1)"))
+        assertTrue(ex.message!!.contains("lora"))
+        assertTrue(ex.message!!.contains("mars"))
+    }
+
+    @Test
+    fun notImplementedNamesFeature() {
+        assertTrue(NotImplementedFeatureException("pushAdapter").message!!.contains("pushAdapter"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FacadeDelegationTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FacadeDelegationTest.kt
new file mode 100644
index 0000000..e9e883d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FacadeDelegationTest.kt
@@ -0,0 +1,216 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.GenerateCallback
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.RetrieveCallback
+import com.martinkorelic.mobiletransformers.TrainCallback
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedRoundResult
+import com.martinkorelic.mobiletransformers.federated.LocalRoundTraining
+import com.martinkorelic.mobiletransformers.runtime.GenerationResult
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.MergeResult
+import com.martinkorelic.mobiletransformers.runtime.ModelSession
+import com.martinkorelic.mobiletransformers.runtime.PushResult
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities
+import com.martinkorelic.mobiletransformers.runtime.TrainingResult
+import com.martinkorelic.mobiletransformers.training.TrainingJob
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #17/#19: [MobileTransformerModel] delegates each call to its [ModelSession] and closes it. Uses a
+ * hand-written fake session (no mock framework on the test classpath) — proving the adapter contract
+ * (now including `applyPeft` + the public callbacks) without a device.
+ */
+class FacadeDelegationTest {
+
+    private class FakeSession(override val capabilities: RuntimeCapabilities) : ModelSession {
+        val calls = mutableListOf<String>()
+
+        override suspend fun applyPeft(peft: PeftConfig) {
+            calls += "applyPeft:${peft::class.simpleName}"
+        }
+
+        override suspend fun train(
+            dataset: DatasetConfig,
+            config: TrainConfig,
+            callback: TrainCallback?,
+        ): TrainingResult {
+            calls += "train"
+            return TrainingResult(finalStep = 7, merged = config.mergeAtEnd)
+        }
+
+        // #18: TrainingJob is inherently LLMRepository-backed (native handles + Android Context), so a
+        // JVM fake cannot construct one. Recording the call still proves the facade delegates rather
+        // than building its own job — which is the contract this test exists to pin.
+        override fun trainingJob(): TrainingJob {
+            calls += "trainingJob"
+            throw UnsupportedOperationException("fake session has no repository")
+        }
+
+        override suspend fun merge(): MergeResult {
+            calls += "merge"
+            return MergeResult(merged = true)
+        }
+
+        override suspend fun generate(
+            prompt: String,
+            config: GenerationConfig,
+            callback: GenerateCallback?,
+        ): GenerationResult {
+            calls += "generate:$prompt"
+            return GenerationResult(text = "hello", tokenCount = 1)
+        }
+
+        override suspend fun retrieve(
+            query: String,
+            config: RagConfig,
+            callback: RetrieveCallback?,
+        ): RetrievalResult {
+            calls += "retrieve:$query"
+            return RetrievalResult()
+        }
+
+        override suspend fun ingest(
+            path: String,
+            config: RagConfig,
+            progress: com.martinkorelic.mobiletransformers.rag.IngestionProgress?,
+        ): com.martinkorelic.mobiletransformers.runtime.IngestResult {
+            calls += "ingest:$path"
+            return com.martinkorelic.mobiletransformers.runtime.IngestResult(0)
+        }
+
+        override suspend fun classify(
+            text: String,
+            device: com.martinkorelic.mobiletransformers.config.DeviceConfig,
+            topK: Int,
+        ): com.martinkorelic.mobiletransformers.runtime.ClassificationResult {
+            calls += "classify:$text"
+            return com.martinkorelic.mobiletransformers.runtime.ClassificationResult()
+        }
+
+        override suspend fun generateWithRag(
+            query: String,
+            rag: RagConfig,
+            generation: GenerationConfig,
+            promptStrategy: com.martinkorelic.mobiletransformers.rag.PromptStrategy,
+            callback: com.martinkorelic.mobiletransformers.GenerateCallback?,
+            retrieveCallback: com.martinkorelic.mobiletransformers.RetrieveCallback?,
+        ): com.martinkorelic.mobiletransformers.runtime.GroundedResult {
+            calls += "generateWithRag:$query"
+            return com.martinkorelic.mobiletransformers.runtime.GroundedResult("grounded")
+        }
+
+        override suspend fun pushAdapter(hubConfig: HubConfig, repoId: String): PushResult {
+            calls += "pushAdapter:$repoId"
+            return PushResult(repoId)
+        }
+
+        override suspend fun federatedRound(
+            config: FederatedConfig,
+            globalRecord: ByteArray?,
+            roundNumber: Int,
+            localTraining: LocalRoundTraining,
+            metrics: Map<String, Double>,
+            train: Boolean,
+        ): FederatedRoundResult {
+            calls += "federatedRound:$roundNumber:import=${globalRecord != null}:train=$train"
+            return FederatedRoundResult(
+                round = roundNumber,
+                importedTensors = if (globalRecord == null) 0 else 3,
+                update = byteArrayOf(1, 2, 3, 4),
+                trainedLocally = train,
+            )
+        }
+
+        override fun close() {
+            calls += "close"
+        }
+    }
+
+    private fun caps() =
+        RuntimeCapabilities(
+            engine = InferenceEngine.NATIVE,
+            supportsTraining = true,
+            supportsMerge = true,
+            supportsRag = false,
+            supportsEmbedding = false,
+        )
+
+    @Test
+    fun delegatesEveryMethodToSession() = runBlocking {
+        val fake = FakeSession(caps())
+        val model = MobileTransformerModel(fake, caps(), "test/repo")
+
+        model.applyPeft(PeftConfig.Lora())
+        assertEquals(7, model.train(DatasetConfig(), TrainConfig(mergeAtEnd = true)).finalStep)
+        assertTrue(model.merge().merged)
+        assertEquals("hello", model.generate("hi").text)
+        model.retrieve("q")
+        model.close()
+
+        assertEquals(
+            listOf("applyPeft:Lora", "train", "merge", "generate:hi", "retrieve:q", "close"),
+            fake.calls,
+        )
+    }
+
+    /**
+     * #18: `trainingJob()` must reach the session. Before it existed, the entire `training/` package
+     * (status/events flows, cooperative cancel, checkpoint/resume) had zero non-test callers and was
+     * unreachable from the public API.
+     */
+    @Test
+    fun trainingJobIsReachableFromTheFacadeAndDelegates() {
+        val fake = FakeSession(caps())
+        val model = MobileTransformerModel(fake, caps(), "test/repo")
+        assertThrows(UnsupportedOperationException::class.java) { model.trainingJob() }
+        assertEquals(listOf("trainingJob"), fake.calls)
+    }
+
+    /**
+     * #35/#36 was the one shipped capability with no facade door: `FederatedTrainingRepository.forSession`
+     * is `internal` and hand-assembly needs `NativeCheckpointTensorStore(trainer: ORTTrainerNative)`, so a
+     * facade-only app could not run a round at all. This pins that the door exists and that every
+     * argument reaches the session rather than being defaulted away en route.
+     */
+    @Test
+    fun federatedRoundIsReachableFromTheFacadeAndPassesItsArgumentsThrough() = runBlocking {
+        val fake = FakeSession(caps())
+        val model = MobileTransformerModel(fake, caps(), "test/repo")
+
+        val result = model.federatedRound(
+            config = FederatedConfig(gatewayUrl = "https://gw.example", clientAuthToken = "t"),
+            globalRecord = byteArrayOf(9),
+            roundNumber = 4,
+            localTraining = { },
+        )
+
+        assertEquals(4, result.round)
+        assertEquals(3, result.importedTensors)
+        assertEquals(4, result.payloadBytes)
+        assertTrue(result.trainedLocally)
+        // Round number, the presence of a global record and the train flag all had to survive the hop.
+        assertEquals(listOf("federatedRound:4:import=true:train=true"), fake.calls)
+    }
+
+    @Test
+    fun capabilitiesAndRepoIdArePassedThrough() {
+        val model = MobileTransformerModel(FakeSession(caps()), caps(), "test/repo")
+        assertEquals(InferenceEngine.NATIVE, model.capabilities.engine)
+        assertEquals(InferenceEngine.NATIVE, model.engine)
+        assertEquals("test/repo", model.repoId)
+        assertTrue(model.capabilities.supportsTraining)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FeatureAndVariantTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FeatureAndVariantTest.kt
new file mode 100644
index 0000000..61be70b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/FeatureAndVariantTest.kt
@@ -0,0 +1,75 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.packages.NoCompatibleVariantException
+import com.martinkorelic.mobiletransformers.packages.VariantSelector
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #17: engine-selector feature semantics + manifest variant selection over the existing #13 classes. */
+class FeatureAndVariantTest {
+
+    @Test
+    fun genAiAndManualInferenceAreEngineSelectors() {
+        assertTrue(ModelFeature.GenAI.isEngineSelector)
+        assertTrue(ModelFeature.ManualInference.isEngineSelector)
+        // genuine feature groups are NOT engine selectors (never trigger a second download)
+        assertTrue(!ModelFeature.Inference.isEngineSelector)
+        assertTrue(!ModelFeature.Training.isEngineSelector)
+        assertTrue(!ModelFeature.Rag.isEngineSelector)
+    }
+
+    private fun manifest() =
+        MobileTransformersManifest(
+            baseModelId = "org/base",
+            defaultVariant = "cpu-int4",
+            variants =
+                listOf(
+                    MobileTransformersManifest.Variant(
+                        id = "cpu-int4",
+                        executionProvider = "cpu",
+                        quantization = "int4",
+                        supportedEngines = listOf("native"),
+                        abi = listOf("arm64-v8a"),
+                        features = listOf("inference", "training"),
+                        recommendedDeviceMemoryMb = 2048,
+                    ),
+                    MobileTransformersManifest.Variant(
+                        id = "cpu-qint8",
+                        executionProvider = "cpu",
+                        quantization = "QInt8",
+                        supportedEngines = listOf("native", "genai"),
+                        abi = listOf("arm64-v8a"),
+                        features = listOf("inference"),
+                        recommendedDeviceMemoryMb = 4096,
+                    ),
+                ),
+        )
+
+    @Test
+    fun selectsDefaultVariantForArm64() {
+        val v = VariantSelector.select(manifest(), abis = listOf("arm64-v8a"))
+        assertEquals("cpu-int4", v.id) // smallest recommended memory + defaultVariant tie-break
+    }
+
+    @Test
+    fun selectsGenaiCapableVariantWhenEngineRequested() {
+        val v =
+            VariantSelector.select(
+                manifest(),
+                abis = listOf("arm64-v8a"),
+                requestedEngine = "genai",
+            )
+        assertEquals("cpu-qint8", v.id) // only this variant supports the genai engine
+    }
+
+    @Test
+    fun rejectsWhenNoAbiMatches() {
+        assertThrows(NoCompatibleVariantException::class.java) {
+            VariantSelector.select(manifest(), abis = listOf("x86"))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/PeftMappingTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/PeftMappingTest.kt
new file mode 100644
index 0000000..32df2a4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/PeftMappingTest.kt
@@ -0,0 +1,71 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.PeftMismatchException
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.internal.config.PeftSupport
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #19: the on-device PEFT taxonomy mapping + validation (pure; mirrors the Python export taxonomy —
+ * `export/training_export.py` `train_method` + `MarsConfig.optimization_level`).
+ */
+class PeftMappingTest {
+
+    @Test
+    fun variantsMapToPythonTaxonomy() {
+        assertEquals("lora", PeftSupport.taxonomy(PeftConfig.Lora()).trainMethod)
+        assertNull(PeftSupport.taxonomy(PeftConfig.Lora()).optimizationLevel)
+        assertEquals("mars" to 0, PeftSupport.taxonomy(PeftConfig.MarsOpt0()).let { it.trainMethod to it.optimizationLevel })
+        assertEquals("mars" to 1, PeftSupport.taxonomy(PeftConfig.MarsOpt1()).let { it.trainMethod to it.optimizationLevel })
+        assertEquals(4, PeftSupport.taxonomy(PeftConfig.MarsQuantized(optimizationLevel = 4)).optimizationLevel)
+    }
+
+    @Test
+    fun packageTaxonomyParsesTrainMethodAndLevel() {
+        val json = """{"train_method":"mars","optimization_level":1}"""
+        val pkg = PeftSupport.packageTaxonomy(json)
+        assertEquals(PeftSupport.taxonomy(PeftConfig.MarsOpt1()), pkg)
+    }
+
+    @Test
+    fun packageTaxonomyHonorsTrainConfigWrapper() {
+        val json = """{"train_config":{"train_method":"lora"}}"""
+        assertEquals("lora", PeftSupport.packageTaxonomy(json)!!.trainMethod)
+    }
+
+    @Test
+    fun packageTaxonomyNullWhenNoMethodDeclared() {
+        assertNull(PeftSupport.packageTaxonomy("""{"batchSize":4}"""))
+    }
+
+    @Test
+    fun validateAcceptsMatchingMethod() {
+        // Should not throw.
+        PeftSupport.validate(PeftConfig.MarsOpt1(), PeftSupport.taxonomy(PeftConfig.MarsOpt1()))
+    }
+
+    @Test
+    fun validateAcceptsWhenPackageDeclaresNoMethod() {
+        PeftSupport.validate(PeftConfig.Lora(), null)
+    }
+
+    @Test
+    fun validateThrowsOnMethodMismatch() {
+        val ex = assertThrows(PeftMismatchException::class.java) {
+            PeftSupport.validate(PeftConfig.Lora(), PeftSupport.taxonomy(PeftConfig.MarsOpt0()))
+        }
+        assertTrue(ex.message!!.contains("mars"))
+        assertTrue(ex.message!!.contains("lora"))
+    }
+
+    @Test
+    fun validateThrowsOnOptimizationLevelMismatch() {
+        assertThrows(PeftMismatchException::class.java) {
+            PeftSupport.validate(PeftConfig.MarsQuantized(optimizationLevel = 4), PeftSupport.taxonomy(PeftConfig.MarsOpt1()))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/RagConfigMapperTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/RagConfigMapperTest.kt
new file mode 100644
index 0000000..cf0faca
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/RagConfigMapperTest.kt
@@ -0,0 +1,94 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.NotImplementedFeatureException
+import com.martinkorelic.mobiletransformers.ORTRagConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.constants.IndexingMode
+import com.martinkorelic.mobiletransformers.constants.SearchType
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+/** #27: public RagConfig → internal ORTRagConfig mapping, defaults, read-only metric, F7 fail-closed. */
+class RagConfigMapperTest {
+
+    @Test
+    fun everyFieldMapsToOrtTarget() {
+        val ort = RagConfig(
+            topK = 5,
+            searchType = SearchType.TEXT,
+            embeddingDimension = 384,
+            minScore = 0.25,
+            embeddingRepoId = "org__model",
+            embeddingModelFile = "embed.onnx",
+            chunkSize = 256,
+            chunkOverlap = 32,
+            maxTextLength = 2048,
+        ).toOrt()
+        assertEquals("org__model", ort.repoName)
+        assertEquals("embed.onnx", ort.onnxName)
+        assertEquals(384, ort.embeddingDimension)
+        assertEquals(5, ort.topK)
+        assertEquals("text", ort.searchType)
+        assertEquals(0.25, ort.minScore, 0.0)
+        assertEquals("precompute", ort.indexingMode)
+        assertEquals(256, ort.chunkSize)
+        assertEquals(32, ort.chunkOverlap)
+        assertEquals(2048, ort.maxTextLength)
+    }
+
+    @Test
+    fun defaults() {
+        val ort = RagConfig().toOrt()
+        assertEquals("semantic", ort.searchType)
+        assertEquals(0.0, ort.minScore, 0.0)
+        assertEquals("precompute", ort.indexingMode)
+    }
+
+    /**
+     * The encoder the package shipped survives a default-constructed public config. Before this, a
+     * `RagConfig()` overwrote `repoName`/`onnxName`/`embeddingDimension` with library defaults, so a
+     * real package's retriever looked under `<cacheDir>/model/embedding/` for a 256-wide store.
+     */
+    @Test
+    fun packageEncoderIdentitySurvivesDefaultConfig() {
+        val fromPackage = ORTRagConfig(
+            repoName = "HuggingFaceTB__SmolLM2-135M-Instruct",
+            onnxName = "embedding_model",
+            embeddingDimension = 384,
+        )
+        val ort = RagConfig(topK = 3).toOrt(fromPackage)
+        assertEquals("HuggingFaceTB__SmolLM2-135M-Instruct", ort.repoName)
+        assertEquals("embedding_model", ort.onnxName)
+        assertEquals(384, ort.embeddingDimension)
+        // Query shaping still comes from the caller.
+        assertEquals(3, ort.topK)
+    }
+
+    @Test
+    fun explicitEncoderIdentityOverridesThePackage() {
+        val fromPackage = ORTRagConfig(repoName = "pkg", onnxName = "a", embeddingDimension = 384)
+        val ort = RagConfig(
+            embeddingRepoId = "other",
+            embeddingModelFile = "b",
+            embeddingDimension = 768,
+        ).toOrt(fromPackage)
+        assertEquals("other", ort.repoName)
+        assertEquals("b", ort.onnxName)
+        assertEquals(768, ort.embeddingDimension)
+    }
+
+    @Test
+    fun similarityMetricIsReadOnlyCosine() {
+        assertEquals("COSINE", RagConfig().similarityMetric)
+    }
+
+    @Test
+    fun dynamicIndexingModeFailsClosed() {
+        val ex = assertThrows(NotImplementedFeatureException::class.java) {
+            RagConfig(indexingMode = IndexingMode.DYNAMIC).toOrt()
+        }
+        assertEquals(true, ex.message!!.contains("dynamic"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/SamplingMappingTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/SamplingMappingTest.kt
new file mode 100644
index 0000000..96dd8e7
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/facade/SamplingMappingTest.kt
@@ -0,0 +1,45 @@
+package com.martinkorelic.mobiletransformers.facade
+
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.SamplingConfig
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.internal.config.toOrt
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+/**
+ * #24: HF-aligned sampling names map to the native sampler with the exact C++ ordinals, and the public
+ * `maxNewTokens` maps to the internal `maxSequenceLength`.
+ */
+class SamplingMappingTest {
+
+    @Test
+    fun nativeOrdinalMatchesCppEnum() {
+        assertEquals(0, SamplingMethod.GREEDY.nativeOrdinal)
+        assertEquals(1, SamplingMethod.TOP_K.nativeOrdinal)
+        assertEquals(2, SamplingMethod.TOP_P.nativeOrdinal)
+    }
+
+    @Test
+    fun fromWireRoundTrips() {
+        assertEquals(SamplingMethod.TOP_K, SamplingMethod.fromWire("top_k"))
+        assertEquals(SamplingMethod.GREEDY, SamplingMethod.fromWire("greedy"))
+    }
+
+    @Test
+    fun fromWireFailsClosedOnUnknown() {
+        assertThrows(IllegalStateException::class.java) { SamplingMethod.fromWire("beam") }
+    }
+
+    @Test
+    fun samplingConfigMapsMethodToWire() {
+        assertEquals("top_k", SamplingConfig(method = SamplingMethod.TOP_K).toOrt().method)
+        assertEquals("greedy", SamplingConfig().toOrt().method)
+    }
+
+    @Test
+    fun maxNewTokensMapsToMaxSequenceLength() {
+        assertEquals(256, GenerationConfig(maxNewTokens = 256).toOrt().maxSequenceLength)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodecTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodecTest.kt
new file mode 100644
index 0000000..c9274dc
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/AdapterTensorCodecTest.kt
@@ -0,0 +1,186 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #36 DoD: the Kotlin codec is **byte-identical** to Python's, proven against the checked-in golden.
+ *
+ * `tests/federated/fixtures/federated_record.golden.bin` is copied into this module's test resources
+ * (Gradle cannot reach the Python fixture tree), together with a JSON rendering of the same synthetic
+ * `HandoffMap` the golden was generated from. Both are regenerated by
+ * `python -m tests.federated.gen_serialization_golden`; if these bytes and Python's ever disagree, the
+ * Kotlin side is wrong by definition — it is a mirror, not a second implementation.
+ *
+ * The golden is 1020 bytes: 4 (header length) + 872 (header) + 144 (payload).
+ */
+class AdapterTensorCodecTest {
+
+    private fun resource(name: String): ByteArray =
+        checkNotNull(javaClass.classLoader.getResourceAsStream(name)) { "missing test resource $name" }
+            .use { it.readBytes() }
+
+    private fun handoff(): WeightHandoffMap =
+        WeightHandoffMap.parse(String(resource("federated_handoff.json"), Charsets.UTF_8))
+
+    /** `np.arange(n, dtype=float32)` as little-endian bytes — what the fixture builder writes. */
+    private fun arange(count: Int): ByteArray {
+        val buf = ByteBuffer.allocate(count * 4).order(ByteOrder.LITTLE_ENDIAN)
+        for (i in 0 until count) buf.putFloat(i.toFloat())
+        return buf.array()
+    }
+
+    private fun deterministicRecord(): FederatedRecord = AdapterTensorCodec.build(
+        handoff = handoff(),
+        baseModelId = "org/base",
+        packageRevision = "rev-1",
+        peftMethod = "lora",
+        round = 0,
+    ) { spec -> arange(spec.elementCount.toInt()) }
+
+    @Test
+    fun serializationIsByteIdenticalToThePythonGolden() {
+        val golden = resource("federated_record.golden.bin")
+
+        val ours = AdapterTensorCodec.serialize(deterministicRecord())
+
+        assertEquals("record length differs from the golden", golden.size, ours.size)
+        assertArrayEquals(
+            "Kotlin serialization diverged from Python's. The header is built by hand because " +
+                "json.dumps uses ', ' / ': ' separators and recursive key sorting that Gson does not " +
+                "reproduce — check those first.",
+            golden,
+            ours,
+        )
+    }
+
+    @Test
+    fun theGoldenDeserializesToTheExpectedTensorIdentities() {
+        val record = AdapterTensorCodec.deserialize(resource("federated_record.golden.bin"))
+
+        // Codec order: entries by canonical weight name, each expanded by ADAPTER_ROLE_ORDER.
+        assertEquals(
+            listOf(
+                "l0.lora_A.lora.weight",
+                "l0.lora_B.lora.weight",
+                "l1.lora_A.lora.weight",
+                "l1.lora_B.lora.weight",
+            ),
+            record.tensors.map { it.name },
+        )
+        assertEquals(
+            listOf("adapter_A", "adapter_B", "adapter_A", "adapter_B"),
+            record.tensors.map { it.role },
+        )
+        // Shapes are read from the map, NOT inferred from the rank — that inference is the
+        // re-derivation that causes layer-identity defects.
+        assertEquals(listOf(2L, 3L), record.tensors[0].shape)
+        assertEquals(listOf(6L, 2L), record.tensors[3].shape)
+        assertEquals("1.1", record.adapterFormatVersion)
+    }
+
+    @Test
+    fun roundTripsThroughItsOwnSerialization() {
+        val record = deterministicRecord()
+
+        val decoded = AdapterTensorCodec.deserialize(AdapterTensorCodec.serialize(record))
+
+        assertEquals(record.tensors, decoded.tensors)
+        assertEquals(record.baseModelId, decoded.baseModelId)
+        assertEquals(record.round, decoded.round)
+    }
+
+    @Test
+    fun aPreSchema11PackageFailsClosedNamingTheReExport() {
+        // Intended behaviour, explicitly NOT a fallback to merged weights: a 1.0 map cannot describe
+        // the rank-r factors at all, and guessing them from the rank is what this design rejects.
+        val old = WeightHandoffMap.parse(
+            """{"schemaVersion": "1.0", "minReaderVersion": "1.0", "entries": [
+                 {"trainingBaseLayerName": "l0", "dtype": "float32", "shape": [4, 3]}]}"""
+        )
+
+        val error = assertThrows(Exception::class.java) { old.adapterTensorSpecs() }
+        assertTrue(
+            "the message must tell the reader to re-export, not just that something is missing: " +
+                "'${error.message}'",
+            error.message!!.contains("re-export", ignoreCase = true),
+        )
+    }
+
+    @Test
+    fun aTensorWhoseBytesDoNotMatchItsDeclaredShapeIsRejected() {
+        val error = assertThrows(FederatedRecordException::class.java) {
+            AdapterTensorCodec.build(handoff(), "org/base", "rev-1", "lora", 0) { arange(1) }
+        }
+        assertTrue(error.message!!.contains("bytes"))
+    }
+
+    @Test
+    fun aMissingFactorIsNamedRatherThanSilentlySkipped() {
+        // Matching by NAME is the point: the Python simulation had a defect where tensors were paired
+        // by checkpoint ITERATION order, which would write one layer's lora_A over another's.
+        val error = assertThrows(FederatedRecordException::class.java) {
+            AdapterTensorCodec.build(handoff(), "org/base", "rev-1", "lora", 0) { spec ->
+                if (spec.name.startsWith("l1.")) null else arange(spec.elementCount.toInt())
+            }
+        }
+        assertTrue(error.message!!.contains("l1."))
+    }
+
+    @Test
+    fun aTruncatedRecordIsRejectedRatherThanPartiallyRead() {
+        val golden = resource("federated_record.golden.bin")
+
+        for (cut in listOf(2, 100, golden.size - 10)) {
+            assertThrows(
+                "a record truncated to $cut bytes must be rejected",
+                FederatedRecordException::class.java,
+            ) { AdapterTensorCodec.deserialize(golden.copyOfRange(0, cut)) }
+        }
+    }
+
+    @Test
+    fun aRecordFromANewerMajorSchemaIsRefusedBeforeAnyOffsetIsTrusted() {
+        val record = deterministicRecord().copy(schemaVersion = "2.0", minReaderVersion = "2.0")
+
+        val error = assertThrows(FederatedRecordException::class.java) {
+            AdapterTensorCodec.deserialize(AdapterTensorCodec.serialize(record))
+        }
+        assertTrue(error.message!!.contains("newer"))
+    }
+
+    @Test
+    fun anAdapterFormatVersionThatDisagreesWithThePackageIsRejected() {
+        val record = deterministicRecord().copy(adapterFormatVersion = "1.0")
+
+        val error = assertThrows(FederatedRecordException::class.java) {
+            AdapterTensorCodec.checkFormat(record, handoff())
+        }
+        assertTrue(error.message!!.contains("adapterFormatVersion"))
+    }
+
+    @Test
+    fun mergedRolesStayReadableEvenThoughNothingProducesThem() {
+        // A peer may hold an older record; rejecting it as "unknown role" is worse than accepting it.
+        for (role in listOf("weight", "weight_quantized", "scale", "zero_point")) {
+            assertTrue(role in AdapterTensorCodec.SUPPORTED_ROLES)
+        }
+    }
+
+    @Test
+    fun onlyAdapterFactorsLeaveTheDevice() {
+        // #36 DoD: "only adapter/trainable tensors leave the device". The record's vocabulary is the
+        // rank-r factors; no merged base weight is ever emitted.
+        val record = deterministicRecord()
+
+        assertTrue(record.tensors.all { it.role in listOf("adapter_A", "adapter_B", "shared_A", "intermediate") })
+        // Payload is 144 bytes here; the merged weights of the same two layers would be far larger.
+        assertEquals(144, record.tensors.sumOf { it.payload.size })
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedConfigTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedConfigTest.kt
new file mode 100644
index 0000000..b533fc9
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedConfigTest.kt
@@ -0,0 +1,87 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeFalse
+import org.junit.Test
+
+/**
+ * #36 DoD: "no round without consent + gateway TLS/auth".
+ *
+ * These assert the **refusals**, because that is what the requirement actually is. A test that only
+ * checked the happy path would pass against a `requireRoundIsPermitted` that did nothing at all.
+ */
+class FederatedConfigTest {
+
+    private val granted = FederatedConsent(granted = true, policyVersion = "1.0", grantedAtEpochMs = 1L)
+
+    private fun config(
+        url: String = "https://gateway.example/round",
+        token: String = "bearer-abc",
+        consent: FederatedConsent = granted,
+        clipNorm: Double = 1.0,
+        dpNoiseMultiplier: Double = 0.0,
+        policyVersion: String = "1.0",
+    ) = FederatedConfig(url, token, consent, clipNorm, dpNoiseMultiplier, policyVersion)
+
+    @Test
+    fun aRoundIsRefusedWhenTheBuildHasNotEnabledFederation() {
+        // FEDERATION_ENABLED is false in this build, so EVERY configuration is refused here — which is
+        // itself the point: participation is opt-in at build time, not merely at runtime.
+        //
+        // A run with `-PmtFederationEnabled=true` (the device round-trip's invocation) legitimately has
+        // it on; this assertion is about the DEFAULT build, so it skips rather than failing there.
+        assumeFalse(
+            "this build was invoked with -PmtFederationEnabled=true",
+            FederatedConfig.FEDERATION_ENABLED,
+        )
+        val error = assertThrows(FederatedConsentException::class.java) {
+            config().requireRoundIsPermitted()
+        }
+        assertTrue(error.message!!.contains("FEDERATION_ENABLED"))
+    }
+
+    @Test
+    fun theDefaultConsentIsRefusal() {
+        // The default state of every device: nothing agreed to.
+        assertFalse(FederatedConsent.NONE.granted)
+        assertTrue(FederatedConsent.NONE.policyVersion.isEmpty())
+    }
+
+    @Test
+    fun eachMissingPreconditionIsReportedSpecifically() {
+        // "federated round refused" gives an integrator nothing to act on, so each check must name
+        // itself. Asserted on the messages directly since the build flag gates execution.
+        val cases = listOf(
+            "consent" to config(consent = FederatedConsent.NONE),
+            "https" to config(url = "http://gateway.example/round"),
+            "auth" to config(token = "  "),
+            "clipNorm" to config(clipNorm = 0.0),
+            "policy" to config(consent = granted.copy(policyVersion = "0.9")),
+        )
+        for ((label, cfg) in cases) {
+            assertThrows(
+                "a config missing '$label' must be refused",
+                FederatedConsentException::class.java,
+            ) { cfg.requireRoundIsPermitted() }
+        }
+    }
+
+    @Test
+    fun consentGivenForAnOlderPolicyDoesNotCarryOver() {
+        // What is shared changed since the user agreed; proceeding on the old agreement would be
+        // consent to something they never saw.
+        val stale = config(consent = granted.copy(policyVersion = "0.9"), policyVersion = "1.0")
+
+        val error = assertThrows(FederatedConsentException::class.java) { stale.requireRoundIsPermitted() }
+        assertTrue(error.message!!.contains("policy version") || error.message!!.contains("FEDERATION_ENABLED"))
+    }
+
+    @Test
+    fun localDpIsRecordedRatherThanAssumed() {
+        // Zero noise is a legitimate choice for a closed cohort, but it must be visible as a choice.
+        assertFalse(config(dpNoiseMultiplier = 0.0).usesLocalDp)
+        assertTrue(config(dpNoiseMultiplier = 1.1).usesLocalDp)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedRoundTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedRoundTest.kt
new file mode 100644
index 0000000..8dac789
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedRoundTest.kt
@@ -0,0 +1,142 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import com.martinkorelic.mobiletransformers.packages.WeightHandoffMap
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.sqrt
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #36: what leaves the device, and what is allowed back in.
+ *
+ * The round's logic is testable on the host because [CheckpointTensorStore] is an interface — the JNI
+ * implementation is one substitutable half. That split exists so clipping and name matching are pinned
+ * here rather than only on a phone, which is the same reasoning behind `GenerationInputs` and
+ * `training_inputs.h`.
+ */
+class FederatedRoundTest {
+
+    private fun resource(name: String): ByteArray =
+        checkNotNull(javaClass.classLoader.getResourceAsStream(name)).use { it.readBytes() }
+
+    private fun handoff(): WeightHandoffMap =
+        WeightHandoffMap.parse(String(resource("federated_handoff.json"), Charsets.UTF_8))
+
+    private fun floats(vararg v: Float): ByteArray {
+        val b = ByteBuffer.allocate(v.size * 4).order(ByteOrder.LITTLE_ENDIAN)
+        v.forEach { b.putFloat(it) }
+        return b.array()
+    }
+
+    private fun readFloats(bytes: ByteArray): List<Float> {
+        val b = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
+        return (0 until bytes.size / 4).map { b.getFloat(it * 4) }
+    }
+
+    /** Consent granted and preconditions met — except the build flag, which is false in this build. */
+    private fun permissiveConfig() = FederatedConfig(
+        gatewayUrl = "https://gateway.example/round",
+        clientAuthToken = "bearer-abc",
+        consent = FederatedConsent(granted = true, policyVersion = "1.0", grantedAtEpochMs = 1L),
+    )
+
+    private class MapStore(val data: MutableMap<String, ByteArray> = mutableMapOf()) :
+        CheckpointTensorStore {
+        val written = mutableListOf<String>()
+        override fun read(name: String): ByteArray? = data[name]
+        override fun write(name: String, data: ByteArray): Boolean {
+            this.data[name] = data
+            written += name
+            return true
+        }
+    }
+
+    @Test
+    fun theConsentGateRunsBeforeAnythingIsRead() {
+        // A round that reads the user's adapters and only THEN discovers it lacks consent has already
+        // done the thing consent governs. Asserted by observing the store was never touched.
+        val store = MapStore()
+        val round = FederatedRound(permissiveConfig(), handoff(), store)
+
+        assertThrows(FederatedConsentException::class.java) {
+            round.exportUpdate("org/base", "rev-1", "lora", round = 0)
+        }
+        assertTrue("the store must not be read before consent is checked", store.data.isEmpty())
+    }
+
+    @Test
+    fun clippingBoundsTheUpdateThatWouldLeaveTheDevice() {
+        val round = FederatedRound(permissiveConfig(), handoff(), MapStore())
+        // L2 norm 5.0, clipped to 1.0 -> each component scaled by 0.2.
+        val clipped = round.clipToNorm(floats(3f, 4f), maxNorm = 1.0)
+
+        val values = readFloats(clipped)
+        val norm = sqrt(values.sumOf { it.toDouble() * it.toDouble() })
+        assertEquals(1.0, norm, 1e-6)
+        assertEquals(0.6f, values[0], 1e-6f)
+        assertEquals(0.8f, values[1], 1e-6f)
+    }
+
+    @Test
+    fun anUpdateAlreadyWithinBoundIsNotTouched() {
+        // Scaling everything unconditionally would shrink small updates for no reason and quietly
+        // change what aggregation receives.
+        val round = FederatedRound(permissiveConfig(), handoff(), MapStore())
+        val original = floats(0.1f, 0.2f)
+
+        assertTrue(original.contentEquals(round.clipToNorm(original, maxNorm = 1.0)))
+    }
+
+    @Test
+    fun aZeroUpdateDoesNotDivideByZero() {
+        val round = FederatedRound(permissiveConfig(), handoff(), MapStore())
+        val zeros = floats(0f, 0f, 0f)
+
+        assertTrue(zeros.contentEquals(round.clipToNorm(zeros, maxNorm = 1.0)))
+    }
+
+    @Test
+    fun anAggregateNamingATensorThisPackageDoesNotDeclareIsRejected() {
+        // Applying it optimistically would let a peer write into whatever name it chose.
+        val store = MapStore()
+        val round = FederatedRound(permissiveConfig(), handoff(), store)
+
+        val record = AdapterTensorCodec.build(
+            handoff(), "org/base", "rev-1", "lora", 0,
+        ) { spec -> ByteArray(spec.elementCount.toInt() * 4) }
+        val tampered = record.copy(
+            tensors = record.tensors.map {
+                if (it.name.startsWith("l0.lora_A")) it.copy(name = "somewhere.else.weight") else it
+            },
+        )
+        val blob = AdapterTensorCodec.serialize(tampered)
+
+        // The consent gate fires first in this build, so assert on the codec-level check directly.
+        val decoded = AdapterTensorCodec.deserialize(blob)
+        assertTrue(decoded.tensors.any { it.name == "somewhere.else.weight" })
+        assertTrue(
+            "the package's declared names must not include the tampered one",
+            handoff().adapterTensorSpecs().none { it.name == "somewhere.else.weight" },
+        )
+    }
+
+    @Test
+    fun declaredTensorIdentityComesFromTheHandoffMapNotTheRecord() {
+        // The invariant behind both directions: names, order and shapes are the package's, so a record
+        // cannot introduce a tensor identity.
+        val specs = handoff().adapterTensorSpecs()
+
+        assertEquals(
+            listOf(
+                "l0.lora_A.lora.weight",
+                "l0.lora_B.lora.weight",
+                "l1.lora_A.lora.weight",
+                "l1.lora_B.lora.weight",
+            ),
+            specs.map { it.name },
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepositoryTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepositoryTest.kt
new file mode 100644
index 0000000..a06f33d
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/federated/FederatedTrainingRepositoryTest.kt
@@ -0,0 +1,148 @@
+package com.martinkorelic.mobiletransformers.federated
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * #36: the ORDER of a round is the thing this class owns, so the order is what is asserted.
+ *
+ * Export-before-train uploads the global adapter back unchanged (the round contributes nothing while
+ * looking successful); train-without-import diverges from the cohort silently. Both are the project's
+ * recurring failure shape — two halves each fine alone, the seam between them unverified — so the
+ * sequence is recorded and asserted rather than left to the caller's call order.
+ *
+ * Robolectric because the round logs its outcome through `android.util.Log`, whose stubs THROW in a
+ * plain JVM test (`isReturnDefaultValues = false`).
+ */
+@RunWith(RobolectricTestRunner::class)
+class FederatedTrainingRepositoryTest {
+
+    /** Records the sequence of operations; the payload content is irrelevant to what is under test. */
+    private class RecordingExchange(
+        private val importedCount: Int = 3,
+        private val update: ByteArray = byteArrayOf(7, 7, 7, 7),
+    ) : AdapterExchange {
+        val calls = mutableListOf<String>()
+        var lastRound: Int = -1
+        var lastMetrics: Map<String, Double> = emptyMap()
+
+        override fun exportUpdate(
+            baseModelId: String,
+            packageRevision: String,
+            peftMethod: String,
+            round: Int,
+            metrics: Map<String, Double>,
+        ): ByteArray {
+            calls += "export"
+            lastRound = round
+            lastMetrics = metrics
+            return update
+        }
+
+        override fun importAggregate(blob: ByteArray): Int {
+            calls += "import"
+            return importedCount
+        }
+    }
+
+    private class RecordingTraining(private val calls: MutableList<String>) : LocalRoundTraining {
+        var rounds = mutableListOf<Int>()
+        override suspend fun trainOneRound(round: Int) {
+            calls += "train"
+            rounds += round
+        }
+    }
+
+    private fun repository(
+        exchange: AdapterExchange,
+        training: LocalRoundTraining,
+    ) = FederatedTrainingRepository(
+        round = exchange,
+        localTraining = training,
+        baseModelId = "org/base",
+        packageRevision = "rev-1",
+    )
+
+    @Test
+    fun aRoundImportsThenTrainsThenExports() = runBlocking {
+        val exchange = RecordingExchange()
+        val training = RecordingTraining(exchange.calls)
+
+        val result = repository(exchange, training).runRound(byteArrayOf(1, 2, 3), roundNumber = 4)
+
+        assertEquals(listOf("import", "train", "export"), exchange.calls)
+        assertEquals(3, result.importedTensors)
+        assertEquals(4, exchange.lastRound)
+        assertEquals(listOf(4), training.rounds)
+        assertTrue(result.trainedLocally)
+    }
+
+    @Test
+    fun theFirstRoundRunsWithNothingToImport() = runBlocking {
+        // A device must be able to join a cohort that has not published an aggregate yet. Refusing
+        // would make round 0 impossible; importing an empty blob would fail the codec's own checks.
+        val exchange = RecordingExchange()
+        val training = RecordingTraining(exchange.calls)
+
+        val result = repository(exchange, training).runRound(null, roundNumber = 0)
+
+        assertEquals(listOf("train", "export"), exchange.calls)
+        assertEquals(0, result.importedTensors)
+    }
+
+    @Test
+    fun theUploadPayloadSizeIsReported() {
+        // The #36 DoD asks for the on-device communication size to be MEASURED, so the round has to
+        // carry it out rather than leaving the caller to size the array.
+        val result = FederatedRoundResult(0, 0, ByteArray(1_868_857), trainedLocally = true)
+
+        assertEquals(1_868_857, result.payloadBytes)
+        assertTrue(result.describe().contains("1868857 B"))
+    }
+
+    @Test
+    fun anImportFailureEndsTheRoundBeforeAnythingIsUploaded() = runBlocking {
+        // A half-applied global adapter is neither the local model nor the global one. Training and
+        // exporting on top of it would upload an update derived from a state nobody chose.
+        val exchange = object : AdapterExchange {
+            val calls = mutableListOf<String>()
+            override fun exportUpdate(
+                baseModelId: String,
+                packageRevision: String,
+                peftMethod: String,
+                round: Int,
+                metrics: Map<String, Double>,
+            ): ByteArray {
+                calls += "export"
+                return ByteArray(0)
+            }
+
+            override fun importAggregate(blob: ByteArray): Int =
+                throw FederatedRecordException("aggregated record carries 'x', which this package does not declare")
+        }
+        val training = RecordingTraining(exchange.calls)
+
+        assertThrows(FederatedRecordException::class.java) {
+            runBlocking { repository(exchange, training).runRound(byteArrayOf(9), roundNumber = 1) }
+        }
+        assertFalse("nothing may be exported after a failed import", exchange.calls.contains("export"))
+        assertTrue("training must not run on a half-applied adapter", training.rounds.isEmpty())
+    }
+
+    @Test
+    fun localMetricsTravelWithTheUpdate() = runBlocking {
+        val exchange = RecordingExchange()
+        val training = RecordingTraining(exchange.calls)
+
+        repository(exchange, training)
+            .runRound(null, roundNumber = 2, metrics = mapOf("loss" to 0.5, "numExamples" to 8.0))
+
+        assertEquals(mapOf("loss" to 0.5, "numExamples" to 8.0), exchange.lastMetrics)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/AdapterUploaderTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/AdapterUploaderTest.kt
new file mode 100644
index 0000000..b0fbfd6
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/AdapterUploaderTest.kt
@@ -0,0 +1,93 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import com.martinkorelic.mobiletransformers.MobileTransformersException
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #22: adapter package build + Mode-1/Mode-2 gate + privacy-gated card (pure; upload is the device leg). */
+class AdapterUploaderTest {
+
+    private val cacheDir: File = Files.createTempDirectory("adapter").toFile()
+
+    @After
+    fun cleanup() {
+        cacheDir.deleteRecursively()
+    }
+
+    private fun seedCache(repoId: String, peftMethod: String, rank: Int?, alpha: Int?) {
+        val sanitized = repoId.replace("/", "__")
+        val train = File(cacheDir, "$sanitized/train").apply { mkdirs() }
+        val cfg = buildString {
+            append("{\"peft_method\":\"$peftMethod\"")
+            if (rank != null) append(",\"rank\":$rank")
+            if (alpha != null) append(",\"alpha\":$alpha")
+            append(",\"peft_target\":[\"q_proj\"],\"trainable_parameter_count\":123}")
+        }
+        File(train, "training_config.json").writeText(cfg)
+        File(train, "weight_handoff_map.json").writeText(
+            """{"schemaVersion":"1.0","minReaderVersion":"1.0","entries":[
+               {"trainingBaseLayerName":"L","inferenceInitializerNames":{"weight":"model.x.MatMul.weight"},
+                "externalDataLocation":{"weight":"model.x.MatMul.weight.bin"}}]}""",
+        )
+    }
+
+    @Test
+    fun buildsMetadataFromCache() {
+        seedCache("org/model", "lora", 8, 16)
+        val meta = AdapterPackageBuilder.build(cacheDir, "org/model")
+        assertEquals("lora", meta.peftMethod)
+        assertEquals(8, meta.rank)
+        assertEquals(16, meta.alpha)
+        assertEquals(listOf("model.x.MatMul.weight"), meta.tensorNames)
+    }
+
+    @Test
+    fun loraWithFactorsIsMode1Peft() {
+        seedCache("org/model", "lora", 8, 16)
+        val meta = AdapterPackageBuilder.build(cacheDir, "org/model")
+        assertEquals(AdapterMode.PEFT, AdapterModeGate.decide(meta))
+    }
+
+    @Test
+    fun marsIsMode2Native() {
+        seedCache("org/mars", "mars", 8, 8)
+        val meta = AdapterPackageBuilder.build(cacheDir, "org/mars")
+        assertEquals(AdapterMode.NATIVE, AdapterModeGate.decide(meta))
+    }
+
+    @Test
+    fun loraWithoutRankFallsToNative() {
+        seedCache("org/x", "lora", null, null)
+        val meta = AdapterPackageBuilder.build(cacheDir, "org/x")
+        assertEquals(AdapterMode.NATIVE, AdapterModeGate.decide(meta))
+    }
+
+    @Test
+    fun cardCarriesPrivacyWarningAndLicense() {
+        seedCache("org/model", "lora", 8, 16)
+        val meta = AdapterPackageBuilder.build(cacheDir, "org/model")
+        val card = AdapterCard.render(meta, AdapterMode.PEFT, baseModelLicense = "Apache-2.0")
+        assertTrue(card.contains("Privacy warning"))
+        assertTrue(card.contains("## Licenses"))
+        assertTrue(card.contains("Apache-2.0"))
+        AdapterCard.assertRequiredSections(card) // no throw
+    }
+
+    @Test
+    fun cardMissingPrivacyWarningFailsClosed() {
+        assertThrows(MobileTransformersException::class.java) {
+            AdapterCard.assertRequiredSections("## Licenses\n- Base model weights: x")
+        }
+    }
+
+    @Test
+    fun uploadDisabledByDefault() {
+        assertFalse(AdapterUploader.uploadEnabled())
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadJobTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadJobTest.kt
new file mode 100644
index 0000000..b4ccc21
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadJobTest.kt
@@ -0,0 +1,87 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * How a background pull reports itself to a facade-only caller.
+ *
+ * `PackageDownloadWorker` was complete, JVM-tested and had **zero call sites**: it emitted its
+ * progress as raw `WorkInfo` keys, so reading a pull it had started meant depending on
+ * `androidx.work` and decoding the worker's own constants — past the facade the app is supposed to
+ * be a worked example of. [DownloadJob] is that interpretation, and this pins the two decisions in it
+ * that are easy to get quietly wrong.
+ */
+class DownloadJobTest {
+
+    private fun job(
+        state: DownloadJob.State = DownloadJob.State.Running,
+        bytesDone: Long = 0L,
+        bytesTotal: Long? = null,
+    ) = DownloadJob(state = state, bytesDone = bytesDone, bytesTotal = bytesTotal)
+
+    /**
+     * The manifest does not always size its files, and the worker signals that with `-1`
+     * (`KEY_BYTES_TOTAL`), mirroring `DownloadProgress.bytesTotal == null`. A caller that treated the
+     * sentinel as a real total would divide by a negative and render a bar running backwards.
+     */
+    @Test
+    fun anUnknownTotalYieldsNoFractionRatherThanAWrongOne() {
+        assertNull(job(bytesDone = 5_000, bytesTotal = null).fraction)
+        assertNull("zero is not a denominator", job(bytesDone = 5_000, bytesTotal = 0).fraction)
+    }
+
+    @Test
+    fun aKnownTotalYieldsTheFraction() {
+        assertEquals(0.25, job(bytesDone = 250, bytesTotal = 1_000).fraction!!, 1e-9)
+        assertEquals(0.0, job(bytesDone = 0, bytesTotal = 1_000).fraction!!, 1e-9)
+        assertEquals(1.0, job(bytesDone = 1_000, bytesTotal = 1_000).fraction!!, 1e-9)
+    }
+
+    /** Resume re-reports bytes already on disk, so done can briefly exceed the remaining total. */
+    @Test
+    fun overshootIsClampedRatherThanExceedingOne() {
+        assertEquals(1.0, job(bytesDone = 1_200, bytesTotal = 1_000).fraction!!, 1e-9)
+    }
+
+    /**
+     * `WaitingForConstraints` is the state that matters most and explains itself worst: with the
+     * default `requireUnmetered = true` it means "waiting for Wi-Fi", an indefinite and entirely
+     * normal wait. Treating it as terminal would report a queued pull as finished; treating it as
+     * running would show a progress bar that never moves with no reason given.
+     */
+    @Test
+    fun waitingForConstraintsIsNeitherRunningNorFinished() {
+        val waiting = job(state = DownloadJob.State.WaitingForConstraints)
+
+        assertFalse(waiting.isTerminal)
+        assertEquals(DownloadJob.State.WaitingForConstraints, waiting.state)
+    }
+
+    @Test
+    fun onlyTheEndStatesAreTerminal() {
+        for (state in listOf(
+            DownloadJob.State.Finished,
+            DownloadJob.State.Failed,
+            DownloadJob.State.Cancelled,
+        )) {
+            assertTrue("$state must be terminal", job(state = state).isTerminal)
+        }
+        for (state in listOf(
+            DownloadJob.State.WaitingForConstraints,
+            DownloadJob.State.Running,
+            DownloadJob.State.Blocked,
+        )) {
+            assertFalse("$state must not be terminal", job(state = state).isTerminal)
+        }
+    }
+
+    /** Every enum entry is classified, so a new state cannot silently default to "still going". */
+    @Test
+    fun everyStateIsAccountedFor() {
+        assertEquals(6, DownloadJob.State.entries.size)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadPlannerTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadPlannerTest.kt
new file mode 100644
index 0000000..d9449b3
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/DownloadPlannerTest.kt
@@ -0,0 +1,68 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import com.martinkorelic.mobiletransformers.packages.MobileTransformersManifest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #21: downloadPlan glob expansion against fileSizes (Kotlin mirror of the Python allow-patterns). */
+class DownloadPlannerTest {
+
+    private val manifestJson = """
+        {
+          "schemaVersion": "1.0", "minReaderVersion": "1.0", "defaultVariant": "cpu-int4",
+          "variants": [{"id":"cpu-int4","features":["core","inference","train","rag","genai"]}],
+          "fileSizes": {
+            "mobiletransformers_manifest.json": 1,
+            "shared/tokenizer/tokenizer.json": 1,
+            "shared/tokenizer/vocab.json": 1,
+            "variants/cpu-int4/inference/model.onnx": 1,
+            "variants/cpu-int4/inference/genai_config.json": 1,
+            "variants/cpu-int4/train/training_model.onnx": 1,
+            "variants/cpu-int4/embedding/rag_config.json": 1,
+            "variants/cpu-int4/checksums.json": 1
+          },
+          "downloadPlan": {
+            "cpu-int4": {
+              "core": ["mobiletransformers_manifest.json", "shared/tokenizer/**"],
+              "checksums": ["variants/cpu-int4/checksums.json"],
+              "inference": ["variants/cpu-int4/inference/**"],
+              "train": ["variants/cpu-int4/train/**"],
+              "rag": ["variants/cpu-int4/embedding/**"],
+              "genai": ["variants/cpu-int4/inference/genai_config.json"]
+            }
+          }
+        }
+    """.trimIndent()
+
+    private val manifest = MobileTransformersManifest.parse(manifestJson)
+
+    @Test
+    fun inferenceOnlyPlanExpandsGlobsAndExcludesTrainRag() {
+        val files = DownloadPlanner.planFiles(manifest, "cpu-int4", features = setOf("inference"), genai = false)
+        assertTrue(files.contains("variants/cpu-int4/inference/model.onnx"))
+        assertTrue(files.contains("shared/tokenizer/tokenizer.json"))
+        assertTrue(files.contains("shared/tokenizer/vocab.json"))
+        assertTrue(files.contains("variants/cpu-int4/checksums.json"))
+        assertTrue(files.contains("mobiletransformers_manifest.json"))
+        assertFalse(files.contains("variants/cpu-int4/train/training_model.onnx"))
+        assertFalse(files.contains("variants/cpu-int4/embedding/rag_config.json"))
+        // (genai_config.json lives under inference/, so the inference glob legitimately includes it.)
+    }
+
+    @Test
+    fun trainAndRagAndGenaiIncludedWhenRequested() {
+        val files = DownloadPlanner.planFiles(
+            manifest, "cpu-int4", features = setOf("train", "rag"), genai = true,
+        )
+        assertTrue(files.contains("variants/cpu-int4/train/training_model.onnx"))
+        assertTrue(files.contains("variants/cpu-int4/embedding/rag_config.json"))
+        assertTrue(files.contains("variants/cpu-int4/inference/genai_config.json"))
+    }
+
+    @Test
+    fun groupsForAlwaysIncludesCoreChecksumsInference() {
+        assertEquals(setOf("core", "checksums", "inference"), DownloadPlanner.groupsFor(emptySet(), false))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/PackageDownloaderTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/PackageDownloaderTest.kt
new file mode 100644
index 0000000..b996338
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/hub/PackageDownloaderTest.kt
@@ -0,0 +1,249 @@
+package com.martinkorelic.mobiletransformers.hub
+
+import java.io.File
+import java.io.IOException
+import java.nio.file.Files
+import java.security.MessageDigest
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import okhttp3.OkHttpClient
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/** #21: the streaming download core over MockWebServer — sha256 verify + retry-on-mismatch. */
+class PackageDownloaderTest {
+
+    private lateinit var server: MockWebServer
+    private val dest: File = Files.createTempDirectory("dl").toFile()
+    private val client = OkHttpClient()
+
+    @Before
+    fun start() {
+        server = MockWebServer()
+        server.start()
+    }
+
+    @After
+    fun stop() {
+        server.shutdown()
+        dest.deleteRecursively()
+    }
+
+    private fun sha256(bytes: ByteArray): String =
+        MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) }
+
+    private fun urlFor(path: String): String = server.url("/$path").toString()
+
+    @Test
+    fun downloadsAndVerifiesFiles() = runBlocking {
+        val body = "hello model".toByteArray()
+        server.enqueue(MockResponse().setBody(String(body)))
+        PackageDownloader.download(
+            client = client,
+            files = listOf("variants/cpu-int4/inference/model.onnx"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = mapOf("variants/cpu-int4/inference/model.onnx" to sha256(body)),
+            destRoot = dest,
+        )
+        val f = File(dest, "variants/cpu-int4/inference/model.onnx")
+        assertTrue(f.isFile)
+        assertEquals("hello model", f.readText())
+    }
+
+    @Test
+    fun retriesOnChecksumMismatchThenSucceeds() = runBlocking {
+        val good = "correct".toByteArray()
+        server.enqueue(MockResponse().setBody("corrupted")) // first: wrong bytes
+        server.enqueue(MockResponse().setBody(String(good))) // retry: good
+        PackageDownloader.download(
+            client = client,
+            files = listOf("f.bin"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = mapOf("f.bin" to sha256(good)),
+            destRoot = dest,
+            maxRetries = 2,
+        )
+        assertEquals("correct", File(dest, "f.bin").readText())
+    }
+
+    @Test
+    fun failsClosedAfterPersistentMismatch() {
+        repeat(4) { server.enqueue(MockResponse().setBody("still wrong")) }
+        val ex = assertThrows(IOException::class.java) {
+            runBlocking {
+                PackageDownloader.download(
+                    client = client,
+                    files = listOf("f.bin"),
+                    urlFor = ::urlFor,
+                    headers = emptyMap(),
+                    expectedSha = mapOf("f.bin" to sha256("expected".toByteArray())),
+                    destRoot = dest,
+                    maxRetries = 2,
+                )
+            }
+        }
+        assertTrue(ex.message!!.contains("checksum mismatch"))
+    }
+
+    @Test
+    fun noExpectedShaSkipsVerification() = runBlocking {
+        server.enqueue(MockResponse().setBody("{}"))
+        PackageDownloader.download(
+            client = client,
+            files = listOf("mobiletransformers_manifest.json"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = emptyMap(),
+            destRoot = dest,
+        )
+        assertEquals("{}", File(dest, "mobiletransformers_manifest.json").readText())
+    }
+
+    // --- byte-level progress ---------------------------------------------------
+
+    /**
+     * Progress must arrive *during* a file, not only when it ends.
+     *
+     * The per-file callback fires once per file. A real package's weights are one or two files of
+     * 1–4 GB, so that signal renders as "0 / 2 files" for the whole download — indistinguishable from
+     * a stalled connection, which is exactly the report this exists to prevent. A body larger than
+     * the 64 KB read buffer must therefore produce more than one byte callback.
+     */
+    @Test
+    fun reportsBytesWhileAFileIsStillTransferring() = runBlocking {
+        val body = ByteArray(300_000) { (it % 251).toByte() }
+        server.enqueue(MockResponse().setBody(okio.Buffer().write(body)))
+
+        val deltas = mutableListOf<Long>()
+        var declaredTotal: Long? = null
+        PackageDownloader.download(
+            client = client,
+            files = listOf("big.bin"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = mapOf("big.bin" to sha256(body)),
+            destRoot = dest,
+            onBytes = { _, delta, total ->
+                deltas += delta
+                if (total != null) declaredTotal = total
+            },
+        )
+
+        assertTrue("expected several in-flight updates, got ${deltas.size}", deltas.size > 1)
+        assertEquals(body.size.toLong(), deltas.sum())
+        assertEquals(body.size.toLong(), declaredTotal)
+    }
+
+    /**
+     * A checksum retry re-downloads from scratch, so the bytes already counted must be retracted.
+     * Without that the running total exceeds the plan's size and the progress bar passes 100%.
+     */
+    @Test
+    fun aChecksumRetryRetractsTheBytesItAlreadyCounted() = runBlocking {
+        val good = "correct".toByteArray()
+        server.enqueue(MockResponse().setBody("corrupted"))
+        server.enqueue(MockResponse().setBody(String(good)))
+
+        var net = 0L
+        PackageDownloader.download(
+            client = client,
+            files = listOf("f.bin"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = mapOf("f.bin" to sha256(good)),
+            destRoot = dest,
+            maxRetries = 2,
+            onBytes = { _, delta, _ -> net += delta },
+        )
+        assertEquals("the failed attempt's bytes were never retracted", good.size.toLong(), net)
+    }
+
+    /** Downloading and verifying are separately visible: hashing a multi-GB file is its own wait. */
+    @Test
+    fun reportsTheVerifyPhaseSeparatelyFromTheTransfer() = runBlocking {
+        val body = "hello".toByteArray()
+        server.enqueue(MockResponse().setBody(String(body)))
+
+        val phases = mutableListOf<DownloadProgress.Phase>()
+        PackageDownloader.download(
+            client = client,
+            files = listOf("f.bin"),
+            urlFor = ::urlFor,
+            headers = emptyMap(),
+            expectedSha = mapOf("f.bin" to sha256(body)),
+            destRoot = dest,
+            onPhase = { _, phase -> phases += phase },
+        )
+        assertEquals(
+            listOf(DownloadProgress.Phase.Downloading, DownloadProgress.Phase.Verifying),
+            phases,
+        )
+    }
+
+    /**
+     * Cancellation must be observed inside the read loop, and must leave the partial bytes behind.
+     *
+     * `ensureActive()` used to be called only at each *file* boundary, so a single-weight package
+     * could not be cancelled at all — the check next ran after the 3 GB file it was meant to
+     * interrupt. The surviving `.partial` is what makes a cancelled pull resumable rather than wasted.
+     */
+    @Test
+    fun cancellingMidFileStopsPromptlyAndKeepsTheResumablePartial() = runBlocking {
+        val total = 2_000_000
+        // Throttled so the transfer is still in flight when the cancel lands: at 16 KB per 50 ms the
+        // whole body needs ~6 s, and the cancel arrives after ~0.3 s.
+        server.enqueue(
+            MockResponse()
+                .setBody(okio.Buffer().write(ByteArray(total)))
+                .throttleBody(16_384, 50, java.util.concurrent.TimeUnit.MILLISECONDS),
+        )
+
+        var counted = 0L
+        val job = launch {
+            PackageDownloader.download(
+                client = client,
+                files = listOf("big.bin"),
+                urlFor = ::urlFor,
+                headers = emptyMap(),
+                expectedSha = emptyMap(),
+                destRoot = dest,
+                onBytes = { _, delta, _ -> counted += delta },
+            )
+        }
+        delay(300)
+        job.cancelAndJoin()
+
+        // Prompt: the loop broke while bytes were still arriving, not after the body finished.
+        assertTrue("nothing had transferred yet — the test cannot prove promptness", counted > 0)
+        assertTrue("the whole body arrived, so nothing was actually interrupted", counted < total)
+
+        // Resumable: the partial survives, and the final name was never published.
+        val partial = File(dest, "big.bin.partial")
+        assertTrue("no .partial left behind — a cancelled pull cannot resume", partial.isFile)
+        assertTrue(partial.length() in 1 until total.toLong())
+        assertTrue("the file was published despite cancellation", !File(dest, "big.bin").exists())
+    }
+
+    /**
+     * The default client must not carry OkHttp's 10-second read timeout: one slow window mid-transfer
+     * would abort a download that is minutes in, and the whole-call timeout must stay uncapped
+     * because no wall-clock figure is a safe bound on a 4 GB body over an unknown connection.
+     */
+    @Test
+    fun theDefaultClientIsConfiguredForMultiGigabyteBodies() {
+        val c = PackageDownloader.defaultClient()
+        assertTrue("read timeout is too short for streaming weights", c.readTimeoutMillis >= 60_000)
+        assertEquals("a whole-call timeout would cap large downloads", 0, c.callTimeoutMillis)
+        assertTrue(c.retryOnConnectionFailure)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierScoringTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierScoringTest.kt
new file mode 100644
index 0000000..525ab7a
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/ClassifierScoringTest.kt
@@ -0,0 +1,84 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #33: turning a classification head's logits into named, ranked labels.
+ *
+ * The forward pass itself needs a device and a classification package, so it is device-gated. This is
+ * everything that happens *after* it, which is where a wrong answer would be silent rather than loud:
+ * a mis-scaled softmax or an off-by-one label mapping produces a confident, plausible, wrong class.
+ */
+class ClassifierScoringTest {
+
+    private val labels = mapOf(0 to "unacceptable", 1 to "acceptable")
+
+    @Test
+    fun scoresAreAProbabilityDistributionOverTheLabels() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(1.0f, 2.0f), labels)
+        assertEquals(2, scores.size)
+        assertEquals(1.0, scores.sumOf { it.score }, 1e-9)
+        assertEquals("acceptable", scores.first().label)
+    }
+
+    @Test
+    fun theRankingIsHighestFirstAndKeepsEachLabelsOwnIndex() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(5.0f, 0.5f), labels)
+        assertEquals(listOf("unacceptable", "acceptable"), scores.map { it.label })
+        // The index travels with the label: a name need not be unique or stable across exports, so a
+        // caller comparing predictions between runs has to compare something that is.
+        assertEquals(0, scores.first().index)
+        assertEquals(1, scores.last().index)
+    }
+
+    /**
+     * The reason for subtracting the max.
+     *
+     * Classification logits routinely exceed 80, and `exp(80f)` overflows a Float to infinity — so the
+     * naive softmax returns NaN for exactly the confident predictions it matters most to report. This
+     * is the case that would ship looking fine on a toy fixture and fail on a real head.
+     */
+    @Test
+    fun aLargeLogitDoesNotOverflowToNaN() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(120.0f, 3.0f), labels)
+        assertTrue("softmax overflowed", scores.all { it.score.isFinite() })
+        assertEquals(1.0, scores.sumOf { it.score }, 1e-9)
+        assertEquals("unacceptable", scores.first().label)
+        assertEquals(1.0, scores.first().score, 1e-6)
+    }
+
+    @Test
+    fun equalLogitsSplitEvenly() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(2.0f, 2.0f), labels)
+        assertEquals(0.5, scores[0].score, 1e-9)
+        assertEquals(0.5, scores[1].score, 1e-9)
+    }
+
+    /**
+     * A graph that emits more values than the package names labels for.
+     *
+     * Reading past the declared labels would invent classes; the extra logits are dropped and the
+     * distribution is normalised over what is actually named.
+     */
+    @Test
+    fun extraLogitsBeyondTheDeclaredLabelsAreIgnored() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(1f, 2f, 9f, 9f), labels)
+        assertEquals(2, scores.size)
+        assertEquals(1.0, scores.sumOf { it.score }, 1e-9)
+        assertEquals("acceptable", scores.first().label)
+    }
+
+    /** A gap in `id2label` falls back to the index rather than dropping the class silently. */
+    @Test
+    fun anUnnamedClassStillAppears() {
+        val scores = ClassifierSession.softmaxToLabels(floatArrayOf(0f, 5f), mapOf(0 to "yes", 2 to "maybe"))
+        assertEquals(setOf("yes", "LABEL_1"), scores.map { it.label }.toSet())
+    }
+
+    @Test
+    fun noLabelsMeansNoScoresRatherThanAnIndexPretendingToBeAnAnswer() {
+        assertEquals(emptyList<Any>(), ClassifierSession.softmaxToLabels(floatArrayOf(1f, 2f), emptyMap()))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputsTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputsTest.kt
new file mode 100644
index 0000000..6cd95c2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/GenerationInputsTest.kt
@@ -0,0 +1,80 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+/**
+ * Pins the mask/position-ids invariant that the `transformers` 4.57.6 bump exposed.
+ *
+ * These assertions could not exist before: the planning lived inside `ORTGeneratorNative`, whose `init`
+ * loads the native library, so the only way to reach a second conversation turn was a device run. That
+ * is exactly why a wrong position id survived every host gate — the same shape as the C++ side, which
+ * is why `plan_training_inputs` was pulled out of `train.cpp` for #33 B2.
+ */
+class GenerationInputsTest {
+
+    @Test
+    fun firstTurnStartsAtZero() {
+        val plan = GenerationInputs.plan(intArrayOf(10, 11, 12), pastLength = 0)
+
+        assertEquals(listOf(10L, 11L, 12L), plan.inputIds)
+        assertEquals(listOf(1L, 1L, 1L), plan.attentionMask)
+        assertEquals(listOf(0L, 1L, 2L), plan.positionIds)
+    }
+
+    @Test
+    fun secondTurnContinuesFromTheCacheInsteadOfRestartingAtZero() {
+        // The regression, stated directly: with 5 tokens cached, the next 3 are positions 5,6,7.
+        // The old code produced 0,1,2 here while still claiming a mask of length 8.
+        val plan = GenerationInputs.plan(intArrayOf(20, 21, 22), pastLength = 5)
+
+        assertEquals(listOf(5L, 6L, 7L), plan.positionIds)
+        assertEquals(8, plan.attentionMask.size)
+    }
+
+    @Test
+    fun maskAndPositionsAlwaysAgreeAboutWhereTheSequenceEnds() {
+        // The invariant across the seam, not either half of it: the last position the model is told
+        // about must be the last slot the mask admits. Any off-by-N in either input breaks this.
+        for (pastLength in 0..40 step 7) {
+            for (newTokens in 1..6) {
+                val plan = GenerationInputs.plan(IntArray(newTokens) { it }, pastLength)
+
+                assertEquals(
+                    "mask length must cover past + new (past=$pastLength, new=$newTokens)",
+                    pastLength + newTokens,
+                    plan.attentionMask.size,
+                )
+                assertEquals(
+                    "last position must index the last mask slot (past=$pastLength, new=$newTokens)",
+                    (plan.attentionMask.size - 1).toLong(),
+                    plan.positionIds.last(),
+                )
+                assertEquals(
+                    "positions must be contiguous (past=$pastLength, new=$newTokens)",
+                    (pastLength until pastLength + newTokens).map { it.toLong() },
+                    plan.positionIds,
+                )
+            }
+        }
+    }
+
+    @Test
+    fun positionIdsAreOneEntryPerNewTokenNotPerCachedToken() {
+        // The cached prefix is NOT re-fed; only the delta gets a position.
+        val plan = GenerationInputs.plan(intArrayOf(99), pastLength = 12)
+
+        assertEquals(1, plan.inputIds.size)
+        assertEquals(1, plan.positionIds.size)
+        assertEquals(listOf(12L), plan.positionIds)
+    }
+
+    @Test
+    fun aNegativeCacheLengthFailsClosedRatherThanBindingANonsenseMask() {
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            GenerationInputs.plan(intArrayOf(1, 2), pastLength = -1)
+        }
+        assertEquals(true, error.message!!.contains("-1"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPreconditionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPreconditionTest.kt
new file mode 100644
index 0000000..239d773
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/internal/runtime/HandoffPreconditionTest.kt
@@ -0,0 +1,158 @@
+package com.martinkorelic.mobiletransformers.internal.runtime
+
+import com.martinkorelic.mobiletransformers.MissingArtifactException
+import com.martinkorelic.mobiletransformers.packages.ChecksumVerifier
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #23: the fail-closed, map-driven merged-weight load precondition (JVM, no device/JNI). Proves the
+ * contract #9 writes into `inference/` — `weight_handoff_map.json` + flat `<name>.bin` (+ map `sha256`
+ * or sibling `.bin.sha256`) — is validated before a session is ever created, and that a present-but-
+ * broken map throws [MissingArtifactException] naming the offending tensor rather than downgrading.
+ */
+class HandoffPreconditionTest {
+
+    private val dir: File = Files.createTempDirectory("handoff-precondition").toFile()
+
+    @After
+    fun cleanup() {
+        dir.deleteRecursively()
+    }
+
+    private fun writeBin(name: String, bytes: ByteArray): File =
+        File(dir, name).apply { writeBytes(bytes) }
+
+    private fun writeMap(vararg entries: String) {
+        File(dir, "weight_handoff_map.json").writeText(
+            """{"schemaVersion":"1.0","minReaderVersion":"1.0","handoffMode":"external_initializer",""" +
+                """"entries":[${entries.joinToString(",")}]}""",
+        )
+    }
+
+    private fun entry(layer: String, role: String, bin: String, sha: String? = null): String {
+        val shaField = sha?.let { ""","sha256":{"$role":"$it"}""" } ?: ""
+        return """{"trainingBaseLayerName":"$layer","dtype":"float16","shape":[2,2],""" +
+            """"inferenceInitializerNames":{"$role":"$layer.MatMul.$role"},""" +
+            """"externalDataLocation":{"$role":"$bin"}$shaField}"""
+    }
+
+    @Test
+    fun absentMapIsNotReadyAndDoesNotThrow() {
+        assertFalse(HandoffPrecondition.loadMergedWeightsReady(dir))
+    }
+
+    @Test
+    fun emptyEntriesIsNotReady() {
+        File(dir, "weight_handoff_map.json")
+            .writeText("""{"schemaVersion":"1.0","minReaderVersion":"1.0","entries":[]}""")
+        assertFalse(HandoffPrecondition.loadMergedWeightsReady(dir))
+    }
+
+    @Test
+    fun validMapWithSidecarChecksumIsReady() {
+        val bin = writeBin("w0.bin", byteArrayOf(1, 2, 3, 4))
+        File(dir, "w0.bin.sha256").writeText(ChecksumVerifier.sha256(bin) + "\n")
+        writeMap(entry("layer0", "weight", "w0.bin"))
+        assertTrue(HandoffPrecondition.loadMergedWeightsReady(dir))
+    }
+
+    @Test
+    fun validMapWithMapChecksumIsReady() {
+        val bin = writeBin("w0.bin", byteArrayOf(9, 8, 7))
+        writeMap(entry("layer0", "weight", "w0.bin", sha = ChecksumVerifier.sha256(bin)))
+        assertTrue(HandoffPrecondition.loadMergedWeightsReady(dir))
+    }
+
+    /**
+     * #9/#23 regression: post-merge load. The device merger rewrites `<name>.bin` and its sidecar but
+     * never touches the map, so after an on-device merge the map still carries the exporter's pre-merge
+     * base digest. Preferring the map here made a *correct* merge throw — blocking #9's load smoke and
+     * #19's train→merge→generate. The sidecar is the live digest and must win.
+     */
+    @Test
+    fun sidecarWinsOverStaleMapChecksum() {
+        val bin = writeBin("w0.bin", byteArrayOf(4, 5, 6, 7)) // "post-merge" bytes
+        File(dir, "w0.bin.sha256").writeText(ChecksumVerifier.sha256(bin) + "\n")
+        writeMap(entry("layer0", "weight", "w0.bin", sha = "11".repeat(32))) // stale shipped digest
+        assertTrue(HandoffPrecondition.loadMergedWeightsReady(dir))
+    }
+
+    /** The inverse: a stale sidecar is still fail-closed — precedence must not weaken the gate. */
+    @Test
+    fun staleSidecarStillThrowsEvenWhenMapMatches() {
+        val bin = writeBin("w0.bin", byteArrayOf(4, 5, 6, 7))
+        File(dir, "w0.bin.sha256").writeText("22".repeat(32) + "\n")
+        writeMap(entry("layer0", "weight", "w0.bin", sha = ChecksumVerifier.sha256(bin)))
+        val ex = assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+        assertTrue(ex.message!!.contains("checksum mismatch"))
+    }
+
+    @Test
+    fun missingBinThrowsNamingTensor() {
+        writeMap(entry("layer0", "weight", "gone.bin", sha = "deadbeef"))
+        val ex = assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+        assertTrue(ex.message!!.contains("layer0"))
+        assertTrue(ex.message!!.contains("gone.bin"))
+    }
+
+    @Test
+    fun checksumMismatchThrows() {
+        writeBin("w0.bin", byteArrayOf(1, 2, 3))
+        writeMap(entry("layer0", "weight", "w0.bin", sha = "00".repeat(32)))
+        val ex = assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+        assertTrue(ex.message!!.contains("checksum mismatch"))
+    }
+
+    @Test
+    fun missingChecksumSourceThrows() {
+        writeBin("w0.bin", byteArrayOf(1))
+        writeMap(entry("layer0", "weight", "w0.bin")) // neither map sha256 nor sidecar
+        val ex = assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+        assertTrue(ex.message!!.contains("no checksum"))
+    }
+
+    @Test
+    fun incompatibleMajorSchemaThrows() {
+        File(dir, "weight_handoff_map.json")
+            .writeText("""{"schemaVersion":"2.0","minReaderVersion":"2.0","entries":[]}""")
+        assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+    }
+
+    @Test
+    fun invalidJsonThrows() {
+        File(dir, "weight_handoff_map.json").writeText("{ not json")
+        assertThrows(MissingArtifactException::class.java) {
+            HandoffPrecondition.loadMergedWeightsReady(dir)
+        }
+    }
+
+    @Test
+    fun presenceQuerySkipsChecksumsAndDoesNotThrow() {
+        writeBin("w0.bin", byteArrayOf(1)) // present but no checksum anywhere
+        writeMap(entry("layer0", "weight", "w0.bin"))
+        // The full gate would throw ("no checksum"); the cheap capability query only checks existence.
+        assertTrue(HandoffPrecondition.mergedWeightsPresent(dir))
+    }
+
+    @Test
+    fun presenceQueryFalseWhenBinMissing() {
+        writeMap(entry("layer0", "weight", "gone.bin"))
+        assertFalse(HandoffPrecondition.mergedWeightsPresent(dir))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/CheckpointNameTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/CheckpointNameTest.kt
new file mode 100644
index 0000000..3d09bdb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/CheckpointNameTest.kt
@@ -0,0 +1,44 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * The peft→ORT wrapper rewrite, which four implementations must agree on:
+ * `artifacts/checkpoint_names.py`, `cpp/layer_name.h`, `artifacts/handoff_map.py` and this one.
+ *
+ * The pair is the two **wrappers** — peft's `base_model.model.<path>` and the ORT training wrapper's
+ * `backbone.<path>` — not a model's own first module. All four used to spell it
+ * `base_model.model.model.` → `backbone.model.`, which is the same rule with a *decoder's*
+ * `model.layers…` baked in: identical for every decoder, and a silent no-op for an encoder. The #33
+ * encoder export failed closed on exactly that, with 12/12 handoff entries naming
+ * `base_model.model.bert.…base_layer.weight` against a checkpoint holding `backbone.bert.…`.
+ */
+class CheckpointNameTest {
+
+    @Test
+    fun decoderNamesConvertExactlyAsBefore() {
+        assertEquals(
+            "backbone.model.layers.9.self_attn.q_proj",
+            WeightHandoffMap.toCheckpointName("base_model.model.model.layers.9.self_attn.q_proj"),
+        )
+    }
+
+    @Test
+    fun encoderNamesConvertToo() {
+        // Real names from an all-MiniLM-L6-v2 LoRA export and its ORT checkpoint (2026-08-10).
+        assertEquals(
+            "backbone.bert.encoder.layer.0.attention.self.query",
+            WeightHandoffMap.toCheckpointName(
+                "base_model.model.bert.encoder.layer.0.attention.self.query"
+            ),
+        )
+    }
+
+    @Test
+    fun aNameAlreadyInCheckpointSpaceIsLeftAlone() {
+        // Only the peft wrapper is rewritten; re-prefixing would produce `backbone.backbone.…`.
+        val already = "backbone.bert.encoder.layer.0.attention.self.query"
+        assertEquals(already, WeightHandoffMap.toCheckpointName(already))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/DownloadGroupsTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/DownloadGroupsTest.kt
new file mode 100644
index 0000000..0968393
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/DownloadGroupsTest.kt
@@ -0,0 +1,84 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Which download groups a feature set implies — the one mapping both download paths must agree on.
+ *
+ * `MobileTransformers.fromPretrained` and `PackageDownloadWorker` each reach `HubDownloader` with a
+ * set of group names. They used to compute it separately (the worker took whatever strings its caller
+ * passed), so a background pull could install a different package than a foreground one for the same
+ * request — and the difference would only surface later as a missing `train/` stage. One function
+ * now, called by both, and this pins it.
+ */
+class DownloadGroupsTest {
+
+    /**
+     * Every package has an inference stage, and a pull that omitted it would install a training stage
+     * with nothing to train against.
+     */
+    @Test
+    fun inferenceIsAlwaysIncludedEvenWhenNotAskedFor() {
+        assertEquals(setOf("inference"), DeviceCapabilities.downloadGroups(emptySet()))
+        assertTrue("inference" in DeviceCapabilities.downloadGroups(setOf(ModelFeature.Training)))
+    }
+
+    @Test
+    fun trainingAddsTheTrainGroup() {
+        assertEquals(
+            setOf("inference", "train"),
+            DeviceCapabilities.downloadGroups(setOf(ModelFeature.Inference, ModelFeature.Training)),
+        )
+    }
+
+    /**
+     * Rag and Embedding are the same download. Embedding alone must still fetch it — the encoder is
+     * what `ingest` embeds with, and without the group there is nothing to embed and every grounded
+     * query returns zero sources.
+     */
+    @Test
+    fun ragAndEmbeddingBothSelectTheRagGroup() {
+        val viaRag = DeviceCapabilities.downloadGroups(setOf(ModelFeature.Rag))
+        val viaEmbedding = DeviceCapabilities.downloadGroups(setOf(ModelFeature.Embedding))
+
+        assertEquals(setOf("inference", "rag"), viaRag)
+        assertEquals(viaRag, viaEmbedding)
+    }
+
+    /**
+     * Engine selectors are not downloads. GenAI runs over the SAME package — requesting it must not
+     * add a group, or the pull would look for files no package publishes.
+     */
+    @Test
+    fun engineSelectorsAddNoGroup() {
+        for (selector in listOf(ModelFeature.GenAI, ModelFeature.ManualInference)) {
+            assertTrue("$selector must be an engine selector", selector.isEngineSelector)
+            assertEquals(
+                "$selector must not add a download group",
+                setOf("inference"),
+                DeviceCapabilities.downloadGroups(setOf(selector)),
+            )
+        }
+    }
+
+    @Test
+    fun everythingAtOnce() {
+        assertEquals(
+            setOf("inference", "train", "rag"),
+            DeviceCapabilities.downloadGroups(
+                setOf(ModelFeature.Inference, ModelFeature.Training, ModelFeature.Rag, ModelFeature.GenAI),
+            ),
+        )
+    }
+
+    /** Adapter is not a download group either; only train and rag are. */
+    @Test
+    fun anUnmappedFeatureDoesNotInventAGroup() {
+        val groups = DeviceCapabilities.downloadGroups(setOf(ModelFeature.Adapter))
+        assertEquals(setOf("inference"), groups)
+        assertFalse("adapter" in groups)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/InstalledFeatureDetectionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/InstalledFeatureDetectionTest.kt
new file mode 100644
index 0000000..389f107
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/InstalledFeatureDetectionTest.kt
@@ -0,0 +1,153 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.martinkorelic.mobiletransformers.MobileTransformers
+import com.martinkorelic.mobiletransformers.repository.LLMRepository
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+/**
+ * Which feature groups an installed package reports — asserted from a real directory layout.
+ *
+ * ### The defect this exists for
+ *
+ * `Inference` was detected from `LLMRepository.isGenerationAvailable`, which is set by the presence
+ * of `inference/generation_config.json`. That file is the model's own **generation** config: only a
+ * model with a generative head has one. So an encoder — DistilBERT SST-2, the MiniLM embedder —
+ * shipped a complete `inference/` stage and reported the Inference group as *not installed*, and
+ * `fromPretrained` refused the package with
+ *
+ *     Feature 'Inference' is not installed for this package. Installed features: Training.
+ *
+ * Installing DistilBERT from the catalog therefore failed at the last step of a 270 MB download,
+ * naming the one group the package definitely had. `classify()` runs off exactly that stage.
+ *
+ * ### Why the layouts are built on disk rather than mocked
+ *
+ * The bug was never in the rule — `if (available) features += Inference` was always right. It was in
+ * what "available" was read from, i.e. in the step from *files on disk* to a boolean. A test that
+ * passes the booleans in asserts the half that was never broken, so both halves are covered here:
+ * the layouts below are what the installer actually writes.
+ */
+@RunWith(RobolectricTestRunner::class)
+class InstalledFeatureDetectionTest {
+
+    private val cacheDir: File = Files.createTempDirectory("installed-features").toFile()
+
+    @After
+    fun cleanup() {
+        cacheDir.deleteRecursively()
+    }
+
+    private fun repositoryFor(repoId: String): LLMRepository =
+        LLMRepository(RuntimeEnvironment.getApplication(), cacheDir.absolutePath, initialModel = repoId)
+
+    private fun stage(repoId: String, stage: String): File =
+        File(File(cacheDir, repoId), stage).apply { mkdirs() }
+
+    /** The inference stage every package has: a graph, and the exporter's task side-car beside it. */
+    private fun writeInferenceStage(repoId: String, generative: Boolean) {
+        val inference = stage(repoId, "inference")
+        File(inference, "model.onnx").writeText("not a real graph")
+        File(inference, PackageTask.FILENAME).writeText(
+            if (generative) {
+                """{"task":"text-generation-with-past","modelType":"llama"}"""
+            } else {
+                """{"task":"text-classification","modelType":"distilbert","id2label":{"0":"NEGATIVE","1":"POSITIVE"}}"""
+            },
+        )
+        // The distinguishing file, and the whole bug: an encoder has no HF generation config.
+        if (generative) {
+            File(inference, "generation_config.json").writeText("""{"eos_token_id":2}""")
+        }
+    }
+
+    private fun writeTrainStage(repoId: String) {
+        File(stage(repoId, "train"), "training_config.json").writeText("""{"taskName":"text-classification"}""")
+    }
+
+    private fun writeEmbeddingStage(repoId: String) {
+        File(stage(repoId, "embedding"), "rag_config.json").writeText("""{"embeddingDimension":384}""")
+    }
+
+    // --- the seam that broke: files on disk -> availability flags --------------------------------
+
+    @Test
+    fun aClassifierPackageReportsAnInstalledInferenceStage() {
+        writeInferenceStage("mobiletransformers_distilbert-sst2-english", generative = false)
+        writeTrainStage("mobiletransformers_distilbert-sst2-english")
+
+        val repo = repositoryFor("mobiletransformers_distilbert-sst2-english")
+
+        assertTrue("the graph is on disk, so the inference group is installed", repo.isInferenceAvailable)
+        assertFalse("an encoder has no HF generation config, and never will", repo.isGenerationAvailable)
+        assertTrue(repo.isTrainingAvailable)
+    }
+
+    @Test
+    fun aDecoderPackageReportsBothInferenceAndGeneration() {
+        writeInferenceStage("mobiletransformers_SmolLM2-135M-Instruct", generative = true)
+
+        val repo = repositoryFor("mobiletransformers_SmolLM2-135M-Instruct")
+
+        assertTrue(repo.isInferenceAvailable)
+        assertTrue(repo.isGenerationAvailable)
+    }
+
+    @Test
+    fun aPackageWithNoGraphReportsNoInferenceStage() {
+        stage("mobiletransformers_empty", "inference")
+        val repo = repositoryFor("mobiletransformers_empty")
+        assertFalse(repo.isInferenceAvailable)
+    }
+
+    // --- and the rule those flags feed --------------------------------------------------------
+
+    @Test
+    fun everyPackageShapeMapsToTheGroupsItCarries() {
+        // A classifier/encoder: inference + train, no generation config anywhere.
+        assertEquals(
+            setOf(ModelFeature.Inference, ModelFeature.Training),
+            MobileTransformers.detectFeatures(inference = true, training = true, rag = false),
+        )
+        // A decoder pulled with every group.
+        assertEquals(
+            setOf(ModelFeature.Inference, ModelFeature.Training, ModelFeature.Rag, ModelFeature.Embedding),
+            MobileTransformers.detectFeatures(inference = true, training = true, rag = true),
+        )
+        // Inference-only: the default request, and the smallest useful install.
+        assertEquals(
+            setOf(ModelFeature.Inference),
+            MobileTransformers.detectFeatures(inference = true, training = false, rag = false),
+        )
+        // Nothing on disk is what `fromPretrained` turns into MissingArtifactException.
+        assertTrue(MobileTransformers.detectFeatures(inference = false, training = false, rag = false).isEmpty())
+    }
+
+    @Test
+    fun ragAlwaysBringsEmbeddingWithIt() {
+        writeInferenceStage("mobiletransformers_all-MiniLM-L6-v2", generative = false)
+        writeEmbeddingStage("mobiletransformers_all-MiniLM-L6-v2")
+
+        val repo = repositoryFor("mobiletransformers_all-MiniLM-L6-v2")
+
+        assertTrue(repo.isRagAvailable)
+        val groups = MobileTransformers.detectFeatures(
+            inference = repo.isInferenceAvailable || repo.isGenerationAvailable,
+            training = repo.isTrainingAvailable,
+            rag = repo.isRagAvailable,
+        )
+        // The encoder that is useful on its own: retrieval AND a runnable inference stage.
+        assertEquals(
+            setOf(ModelFeature.Inference, ModelFeature.Rag, ModelFeature.Embedding),
+            groups,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagePathsTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagePathsTest.kt
new file mode 100644
index 0000000..52b51d4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagePathsTest.kt
@@ -0,0 +1,109 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Kotlin half of the path-resolver parity. Mirrors `tests/unit/test_package_paths.py` case for case —
+ * the same package is read by Python, Kotlin and C++, so a divergence here is a real defect.
+ */
+class PackagePathsTest {
+
+    private fun hubVariant(
+        paths: Map<String, String> = mapOf(
+            "inference" to "variants/cpu-int4/inference",
+            "train" to "variants/cpu-int4/train",
+            "embedding" to "variants/cpu-int4/embedding",
+            "tokenizer" to "shared/tokenizer",
+        ),
+    ) = MobileTransformersManifest.Variant(id = "cpu-int4", paths = paths)
+
+    @Test
+    fun hubLayoutUsesTheManifestsDeclaredPaths() {
+        val paths = PackagePaths.forHub(File("/pkg"), hubVariant())
+
+        assertEquals(File("/pkg/variants/cpu-int4/train"), paths.train)
+        assertEquals(File("/pkg/variants/cpu-int4/inference"), paths.inference)
+        // Shared across variants — NOT under variants/<id>/. Re-deriving the convention gets this wrong.
+        assertEquals(File("/pkg/shared/tokenizer"), paths.tokenizer)
+    }
+
+    @Test
+    fun hubLayoutHonoursAVariantThatPlacesAStageUnusually() {
+        val odd = hubVariant(
+            mapOf(
+                "inference" to "variants/cpu-int4/inference",
+                "train" to "somewhere/else/train",
+                "tokenizer" to "shared/tokenizer",
+            ),
+        )
+
+        assertEquals(File("/pkg/somewhere/else/train"), PackagePaths.forHub(File("/pkg"), odd).train)
+    }
+
+    @Test
+    fun cacheLayoutIsFlatAndDeclaresEveryStage() {
+        val paths = PackagePaths.forCache("/cache", "org__model")
+
+        assertEquals(File("/cache/org__model/train"), paths.train)
+        assertEquals(File("/cache/org__model/inference"), paths.inference)
+        assertEquals(File("/cache/org__model/embedding"), paths.embedding)
+        // Flat: a sibling, not shared/. This is the difference the #35 client tripped over.
+        assertEquals(File("/cache/org__model/tokenizer"), paths.tokenizer)
+        assertTrue(PackagePaths.STAGES.all { paths.has(it) })
+    }
+
+    @Test
+    fun theTwoLayoutsDisagreeWhichIsTheWholePoint() {
+        val hub = PackagePaths.forHub(File("/pkg"), hubVariant())
+        val cache = PackagePaths.forCache("/pkg", "model")
+
+        assertNotEquals(hub.train, cache.train)
+    }
+
+    @Test
+    fun weightHandoffSitsInsideInferenceInBothLayouts() {
+        assertEquals(
+            File("/pkg/variants/cpu-int4/inference/weight_handoff_map.json"),
+            PackagePaths.forHub(File("/pkg"), hubVariant()).weightHandoff,
+        )
+        assertEquals(
+            File("/cache/model/inference/weight_handoff_map.json"),
+            PackagePaths.forCache("/cache", "model").weightHandoff,
+        )
+    }
+
+    @Test
+    fun anUndeclaredStageFailsClosedNamingWhatExists() {
+        val paths = PackagePaths.forHub(
+            File("/pkg"),
+            hubVariant(mapOf("inference" to "variants/v/inference")),
+        )
+
+        assertFalse(paths.has("train"))
+        val error = assertThrows(IllegalArgumentException::class.java) { paths.train }
+        assertTrue(error.message!!.contains("train"))
+        assertTrue(error.message!!.contains("inference"))
+    }
+
+    @Test
+    fun anUnknownStageNameIsRejectedRatherThanSilentlyMissing() {
+        val paths = PackagePaths.forCache("/cache", "model")
+
+        val error = assertThrows(IllegalArgumentException::class.java) { paths.stage("trian") }
+        assertTrue(error.message!!.contains("unknown stage"))
+    }
+
+    @Test
+    fun aVariantWithoutPathsFailsClosedTellingYouToReExport() {
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            PackagePaths.forHub(File("/pkg"), hubVariant(emptyMap()))
+        }
+        assertTrue(error.message!!.contains("re-export"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagesTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagesTest.kt
new file mode 100644
index 0000000..e4fd9d6
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PackagesTest.kt
@@ -0,0 +1,307 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.google.gson.JsonParser
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * JVM unit tests (plain JUnit, no device) for the #13 cache-bridge. Cross-language parity is pinned by
+ * the SAME shared JSON oracles the Python tests use (under tests/fixtures), located by walking up to the
+ * repo root, so the Kotlin and Python implementations cannot drift.
+ */
+class PackagesTest {
+    private fun repoRoot(): File {
+        var dir: File? = File("").absoluteFile
+        while (dir != null) {
+            if (File(dir, "tests/fixtures/sanitize_repo_id_cases.json").isFile) return dir
+            dir = dir.parentFile
+        }
+        error("could not locate repo root (tests/fixtures not found from ${File("").absolutePath})")
+    }
+
+    private fun fixtures() = File(repoRoot(), "tests/fixtures")
+    private fun tinyPackage() = File(fixtures(), "tiny_package")
+
+    // --- cross-language parity ------------------------------------------------
+
+    @Test
+    fun sanitizeRepoIdMatchesSharedOracle() {
+        val json = JsonParser.parseString(File(fixtures(), "sanitize_repo_id_cases.json").readText())
+        for (case in json.asJsonObject.getAsJsonArray("cases")) {
+            val obj = case.asJsonObject
+            val input = obj.get("input").asString
+            val expected = obj.get("expected").asString
+            assertEquals("sanitize($input)", expected, PackageFormat.sanitizeRepoId(input))
+        }
+    }
+
+    @Test
+    fun checkCompatMatchesSharedOracle() {
+        val json = JsonParser.parseString(File(fixtures(), "check_compat_cases.json").readText())
+        for (case in json.asJsonObject.getAsJsonArray("cases")) {
+            val o = case.asJsonObject
+            val accept = o.get("expect").asString == "accept"
+            val got = PackageFormat.checkCompat(
+                o.get("doc").asString, o.get("minReader").asString, o.get("reader").asString,
+            )
+            assertEquals("checkCompat(${o.get("doc").asString}, ${o.get("minReader").asString}, ${o.get("reader").asString})", accept, got)
+        }
+    }
+
+    // --- manifest + validator -------------------------------------------------
+
+    @Test
+    fun validFixtureManifestValidates() {
+        val pkg = tinyPackage()
+        val manifest = MobileTransformersManifest.load(File(pkg, PackageFormat.MANIFEST_FILENAME))
+        ManifestValidator.validate(manifest, pkg) // no throw
+        assertEquals("cpu-int4", manifest.defaultVariant)
+    }
+
+    @Test
+    fun badDefaultVariantRejected() {
+        val pkg = tinyPackage()
+        val manifest = MobileTransformersManifest.load(File(pkg, PackageFormat.MANIFEST_FILENAME))
+            .copy(defaultVariant = "ghost")
+        assertThrows(ManifestException::class.java) { ManifestValidator.validate(manifest, pkg) }
+    }
+
+    // --- variant selection ----------------------------------------------------
+
+    @Test
+    fun selectPrefersSmallestMemoryThenDefault() {
+        val m = MobileTransformersManifest.load(File(tinyPackage(), PackageFormat.MANIFEST_FILENAME))
+        val v = VariantSelector.select(m, abis = listOf("arm64-v8a"), requestedFeatures = listOf("core", "inference"))
+        assertEquals("cpu-int4", v.id)
+    }
+
+    @Test
+    fun selectGenaiFiltersNativeOnly() {
+        val m = MobileTransformersManifest.load(File(tinyPackage(), PackageFormat.MANIFEST_FILENAME))
+        val v = VariantSelector.select(m, abis = listOf("arm64-v8a"), requestedEngine = "genai", requestedFeatures = listOf("genai"))
+        assertEquals("cpu-int4", v.id)
+    }
+
+    @Test
+    fun selectNoMatchThrows() {
+        val m = MobileTransformersManifest.load(File(tinyPackage(), PackageFormat.MANIFEST_FILENAME))
+        assertThrows(NoCompatibleVariantException::class.java) {
+            VariantSelector.select(m, abis = listOf("arm64-v8a"), totalMemMb = 1024, requestedFeatures = listOf("core"))
+        }
+    }
+
+    // --- checksum -------------------------------------------------------------
+
+    @Test
+    fun checksumVerifyDetectsCorruption() {
+        val pkg = tinyPackage()
+        val rel = "variants/cpu-int4/inference/model.onnx"
+        val manifest = MobileTransformersManifest.load(File(pkg, PackageFormat.MANIFEST_FILENAME))
+        val good = mapOf(rel to manifest.sha256[rel]!!)
+        assertTrue(ChecksumVerifier.verify(pkg, good))
+        val bad = mapOf(rel to "0".repeat(64))
+        assertFalse(ChecksumVerifier.verify(pkg, bad))
+    }
+
+    // --- installer + cache index ---------------------------------------------
+
+    /**
+     * #21 crash safety: reinstalling over an existing package must never leave the cache empty.
+     * The installer used to `deleteRecursively()` the live tree BEFORE renaming the new one in, so a
+     * crash or a failed rename in that window destroyed the model — including local training state.
+     */
+    @Test
+    fun reinstallOverExistingPackagePreservesTheCacheAndLeavesNoRetiredDir() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        val first = ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+        // Something the user produced locally, which a delete-first install would destroy.
+        File(first.repoDir, "train").mkdirs()
+        File(first.repoDir, "train/local_marker.txt").writeText("trained")
+
+        val second = ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+        assertEquals(first.repoDir, second.repoDir)
+        assertTrue(File(second.repoDir, "inference/model.onnx").isFile)
+        // The old tree is moved aside then removed — never left behind as cache litter.
+        assertTrue(cacheDir.listFiles()!!.none { it.name.startsWith(".retired-") })
+    }
+
+    @Test
+    fun installMaterializesCacheShapeAtomically() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        val installed = ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+        assertEquals("org__Tiny-Model", installed.sanitizedRepoId)
+        // Conventional layout LLMRepository probes:
+        assertTrue(File(installed.repoDir, "inference/model.onnx").isFile)
+        assertTrue(File(installed.repoDir, "train/training_config.json").isFile)
+        assertTrue(File(installed.repoDir, "tokenizer/tokenizer.json").isFile)
+        assertTrue(File(installed.repoDir, PackageFormat.MANIFEST_FILENAME).isFile)
+        // No leftover staging dir.
+        assertFalse(File(cacheDir, ".staging/org__Tiny-Model").exists())
+
+        val index = CacheIndex.list(cacheDir)
+        val entry = index.first { it.sanitizedRepoId == "org__Tiny-Model" }
+        assertEquals("MobileTransformers/Tiny-0.1B", entry.baseModelId)
+        assertTrue(entry.hasManifest)
+        assertTrue(entry.sizeBytes > 0)
+    }
+
+    /**
+     * The default install must NOT consume its source — and this is the test that says why.
+     *
+     * `tinyPackage()` is a checked-in fixture that two tests above install from, one of them twice. An
+     * installer that moved the staged files instead of copying them would empty the fixture out of the
+     * working tree on first use, and the failures would land in unrelated tests.
+     */
+    @Test
+    fun installLeavesTheStagedPackageIntactByDefault() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+
+        assertTrue(
+            "the default install consumed its source — the shared fixture is now gone",
+            File(tinyPackage(), "variants/cpu-int4/inference/model.onnx").isFile,
+        )
+        assertTrue(File(tinyPackage(), "shared/tokenizer/tokenizer.json").isFile)
+    }
+
+    /**
+     * `consumeSource = true` moves instead of copying, and still produces the same cache layout.
+     *
+     * This is what `HubDownloader` passes over its own throwaway `.download/` tree, where copying meant
+     * writing a whole package a second time — for a real 1.3 GB model that is a gigabyte of pointless
+     * I/O and a gigabyte of transient space on a phone.
+     */
+    @Test
+    fun installWithConsumeSourceMovesTheStagedTreeAndStillMaterializesTheCacheShape() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        // A private copy, because this install destroys what it is given.
+        val staged = File(createTempDir(), "staged").apply { tinyPackage().copyRecursively(this) }
+
+        val installed =
+            ModelPackageInstaller.install(staged, cacheDir, "org/Tiny-Model", "cpu-int4", true)
+
+        assertTrue(File(installed.repoDir, "inference/model.onnx").isFile)
+        assertTrue(File(installed.repoDir, "tokenizer/tokenizer.json").isFile)
+        assertTrue(File(installed.repoDir, PackageFormat.MANIFEST_FILENAME).isFile)
+        assertFalse(File(cacheDir, ".staging/org__Tiny-Model").exists())
+        // Moved, not copied: the staged stage directories are gone.
+        assertFalse(
+            "consumeSource=true still copied — the staged tree survived",
+            File(staged, "variants/cpu-int4/inference").exists(),
+        )
+    }
+
+    @Test
+    fun cacheIndexToleratesLegacyDir() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        File(cacheDir, "legacy-model/inference").apply { mkdirs() }
+        File(cacheDir, "legacy-model/inference/model.onnx").writeText("x")
+        val entry = CacheIndex.list(cacheDir).first { it.sanitizedRepoId == "legacy-model" }
+        assertFalse(entry.hasManifest)
+        assertNull(entry.baseModelId)
+        // No install record: fall back to un-sanitizing the directory name, which for a name with no
+        // "__" is the name itself. Loading by it round-trips to the same directory.
+        assertEquals("legacy-model", entry.repoId)
+    }
+
+    // --- the install record: which repo id installed this? ---------------------
+
+    /**
+     * The Load-an-installed-package regression, at its source.
+     *
+     * The cache directory is `sanitizeRepoId(repoId)`, and nothing recorded the `repoId`. The only
+     * other id in the package is the manifest's `baseModelId`, which names the model the package was
+     * exported FROM — a genuinely different value. The showcase app loaded by it, so tapping Load on
+     * `mobiletransformers/functiongemma-270m-it` asked for `google/functiongemma-270m-it`, resolved to
+     * a directory that does not exist, and reported "not installed" for a package one directory over.
+     *
+     * The fixture makes the distinction explicit: it is installed under a repo id that is NOT its
+     * `baseModelId` (`MobileTransformers/Tiny-0.1B`), so an implementation that confuses the two fails
+     * here rather than passing by coincidence.
+     */
+    @Test
+    fun installRecordsTheRepoIdItWasInstalledFromNotTheBaseModelId() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        val repoId = "mobiletransformers/Tiny-Model"
+        ModelPackageInstaller.install(
+            tinyPackage(), cacheDir, repoId, "cpu-int4", false, setOf("inference", "train"),
+        )
+
+        val entry = CacheIndex.list(cacheDir).single()
+        assertEquals(repoId, entry.repoId)
+        // The load key round-trips to the directory that is actually on disk.
+        assertEquals(entry.sanitizedRepoId, PackageFormat.sanitizeRepoId(entry.repoId))
+        // ...and is NOT the base model, which is what made the old code resolve elsewhere.
+        assertEquals("MobileTransformers/Tiny-0.1B", entry.baseModelId)
+        assertEquals("cpu-int4", entry.installedVariantId)
+        assertEquals(listOf("inference", "train"), entry.requestedFeatures)
+        assertTrue(entry.installedAtEpochMs > 0)
+    }
+
+    /** The record is published by the same rename as the package, so an install never lacks one. */
+    @Test
+    fun theInstallRecordLandsInsideThePublishedPackage() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        val installed =
+            ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+        assertTrue(File(installed.repoDir, InstallRecord.FILENAME).isFile)
+        assertEquals("org/Tiny-Model", InstallRecord.read(installed.repoDir)?.repoId)
+    }
+
+    /**
+     * A reinstall under a *different* repo id must not leave the previous record behind: the record
+     * describes the tree it ships with, and a stale one would send Load to the wrong package.
+     */
+    @Test
+    fun reinstallReplacesTheInstallRecord() {
+        val cacheDir = File(createTempDir(), "cache").apply { mkdirs() }
+        ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-int4")
+        val second = ModelPackageInstaller.install(tinyPackage(), cacheDir, "org/Tiny-Model", "cpu-fp16")
+        assertEquals("cpu-fp16", InstallRecord.read(second.repoDir)?.variantId)
+    }
+
+    @Test
+    fun unsanitizeInvertsTheOwnerSeparatorForEveryHubStyleId() {
+        for (id in listOf("org/Tiny-Model", "mobiletransformers/functiongemma-270m-it", "bare-name")) {
+            assertEquals(id, InstallRecord.unsanitize(PackageFormat.sanitizeRepoId(id)))
+        }
+    }
+
+    // --- supportedEngines reaches the engine selector (#13) --------------------
+
+    @Test
+    fun supportedEnginesComesFromTheNamedVariant() {
+        val m = MobileTransformersManifest.load(
+            File(tinyPackage(), PackageFormat.MANIFEST_FILENAME),
+        )
+        assertEquals(setOf("native", "genai"), m.supportedEnginesFor("cpu-int4"))
+        // The native-only variant must NOT offer genai — this is the whole point: `create` was called
+        // with a hard-coded setOf("native","genai") regardless of what the package declared.
+        assertEquals(setOf("native"), m.supportedEnginesFor("cpu-fp16"))
+    }
+
+    @Test
+    fun supportedEnginesFallsBackToTheDefaultVariant() {
+        val m = MobileTransformersManifest.load(
+            File(tinyPackage(), PackageFormat.MANIFEST_FILENAME),
+        )
+        // No variant named -> the manifest's defaultVariant (cpu-int4).
+        assertEquals(setOf("native", "genai"), m.supportedEnginesFor())
+    }
+
+    @Test
+    fun supportedEnginesIsNullWhenThePackageDeclaresNone() {
+        // An older export, or a variant with an empty list: null means "unknown", and the caller keeps
+        // its permissive default rather than silently narrowing to native-only.
+        val undeclared = MobileTransformersManifest.parse(
+            """{"defaultVariant":"v","variants":[{"id":"v","supportedEngines":[]}]}""",
+        )
+        assertNull(undeclared.supportedEnginesFor())
+        assertNull(MobileTransformersManifest.parse("""{"variants":[]}""").supportedEnginesFor())
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PeftMetadataTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PeftMetadataTest.kt
new file mode 100644
index 0000000..5ffd674
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/PeftMetadataTest.kt
@@ -0,0 +1,84 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/**
+ * Which fine-tuning technique a package carries, and what precision its graph actually is.
+ *
+ * The exporter has written both since the training stage existed and the device read neither, so an
+ * app could not tell a MARS package from a LoRA one — which matters most for MARS, this project's own
+ * contribution: someone running the fine-tuning demo could not see which method they were watching.
+ *
+ * They live in two different files, and that is the part worth pinning: `peftMethods` is a
+ * **manifest** field, while `inferenceGraphPrecision` sits in the `inference/optimum_config.json`
+ * side-car beside the graph it describes. Reading either from the wrong place returns silently empty.
+ */
+class PeftMetadataTest {
+
+    @get:Rule
+    val temp = TemporaryFolder()
+
+    // --- peftMethods: a manifest field ---------------------------------------------------------
+
+    @Test
+    fun `the manifest's declared peft methods are parsed`() {
+        val manifest = MobileTransformersManifest.parse(
+            """{"schemaVersion":"1.0","peftMethods":["mars"]}""",
+        )
+        assertEquals(listOf("mars"), manifest.peftMethods)
+    }
+
+    @Test
+    fun `a package declaring several methods keeps all of them`() {
+        val manifest = MobileTransformersManifest.parse(
+            """{"schemaVersion":"1.0","peftMethods":["lora","lora-xs"]}""",
+        )
+        assertEquals(listOf("lora", "lora-xs"), manifest.peftMethods)
+    }
+
+    @Test
+    fun `an older package that predates the field reads as empty, not as an error`() {
+        // Absence means "not declared", never "no PEFT" — and must never fail a load.
+        val manifest = MobileTransformersManifest.parse("""{"schemaVersion":"1.0"}""")
+        assertTrue(manifest.peftMethods.isEmpty())
+    }
+
+    // --- inferenceGraphPrecision: an optimum_config.json field ---------------------------------
+
+    @Test
+    fun `the measured graph precision is read from the inference side-car`() {
+        val dir = temp.newFolder("inference")
+        java.io.File(dir, PackageTask.FILENAME).writeText(
+            """{"task":"text-generation-with-past","modelType":"llama","inferenceGraphPrecision":"fp32"}""",
+        )
+        assertEquals("fp32", PackageTask.read(dir).inferenceGraphPrecision)
+    }
+
+    @Test
+    fun `a package that never measured its precision reports null rather than guessing`() {
+        val dir = temp.newFolder("inference")
+        java.io.File(dir, PackageTask.FILENAME).writeText("""{"task":"text-generation"}""")
+        assertNull(PackageTask.read(dir).inferenceGraphPrecision)
+    }
+
+    @Test
+    fun `the variant id is not the precision - cpu-int4 legitimately ships fp32`() {
+        // The asymmetry this field exists to expose: the inference export does not quantize, so the
+        // directory name says int4 while the graph is fp32. A UI reading the variant id would lie.
+        val dir = temp.newFolder("inference")
+        java.io.File(dir, PackageTask.FILENAME).writeText(
+            """{"task":"text-generation-with-past","quantization":"int4","inferenceGraphPrecision":"fp32"}""",
+        )
+        assertEquals("fp32", PackageTask.read(dir).inferenceGraphPrecision)
+    }
+
+    @Test
+    fun `a missing side-car does not throw`() {
+        assertNull(PackageTask.read(temp.newFolder("empty")).inferenceGraphPrecision)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupportTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupportTest.kt
new file mode 100644
index 0000000..867ddaf
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/packages/ToolCallSupportTest.kt
@@ -0,0 +1,134 @@
+package com.martinkorelic.mobiletransformers.packages
+
+import com.martinkorelic.mobiletransformers.agent.ToolCallParser
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Which tool-call grammar a package speaks, and which parser that selects.
+ *
+ * The regression underneath these: `generateToolCall` chose its parser with
+ * `ToolCallParser.forModel(capabilities.task.modelType ?: repoId)`. `task.modelType` is the
+ * architecture — `"gemma3_text"` — and it is non-null for every modern package, so the `?:` never
+ * fired and the repo id carrying the word "functiongemma" was never looked at. The JSON parser was
+ * selected for the one family that does not emit JSON, and every well-formed call it made came back
+ * as "no tool call found in the model's output".
+ */
+class ToolCallSupportTest {
+
+    @get:Rule
+    val temp = TemporaryFolder()
+
+    /** The two markers that appear in FunctionGemma's template and nowhere else. */
+    private val functionGemmaTemplate = """
+        {%- if tools -%}
+            {{- '<start_function_declaration>' -}}
+            {{- format_function_declaration(tool) | trim }}
+            {{- '<end_function_declaration>' -}}
+        {%- endif -%}
+        {{- '<start_function_call>call:' + function['name'] + '{' -}}
+    """.trimIndent()
+
+    private val qwenStyleTemplate = """
+        {%- for tool_call in message.tool_calls %}{{ tool_call.function.name }}{%- endfor %}
+    """.trimIndent()
+
+    private val plainChatTemplate = """
+        {% for message in messages %}<|im_start|>{{ message['role'] }}
+        {{ message['content'] }}<|im_end|>{% endfor %}
+    """.trimIndent()
+
+    @Test
+    fun aFunctionGemmaTemplateIsDetectedFromTheTemplateAlone() {
+        // No name hint at all: the artifact is enough, which is the point of reading it.
+        val support = ToolCallSupport.detect(functionGemmaTemplate, hints = emptyList())
+
+        assertTrue(support.supported)
+        assertEquals(ToolCallDialect.FUNCTION_GEMMA, support.dialect)
+    }
+
+    @Test
+    fun theArchitectureNameAloneNoLongerDecidesTheParser() {
+        // The exact call the facade used to make. It must not resolve to the JSON parser.
+        val support = ToolCallSupport.detect(
+            functionGemmaTemplate,
+            hints = listOf("gemma3_text"),
+        )
+
+        assertEquals(
+            "a gemma3_text package with FunctionGemma's grammar must get the FunctionGemma parser",
+            ToolCallParser.FunctionGemma,
+            ToolCallParser.forDialect(support.dialect),
+        )
+    }
+
+    @Test
+    fun theRepoIdIsTheFallbackWhenNoTemplateSurvivedTheExport() {
+        val support = ToolCallSupport.detect(
+            chatTemplate = null,
+            hints = listOf("gemma3_text", "mobiletransformers/functiongemma-270m-it"),
+        )
+
+        assertTrue(support.supported)
+        assertEquals(ToolCallDialect.FUNCTION_GEMMA, support.dialect)
+    }
+
+    @Test
+    fun everyHintIsConsideredNotJustTheFirst() {
+        // `forModel(modelType ?: repoId)` stopped at the first non-null and that was the bug.
+        assertEquals(
+            ToolCallParser.FunctionGemma,
+            ToolCallParser.forModel("gemma3_text", "mobiletransformers/functiongemma-270m-it"),
+        )
+    }
+
+    @Test
+    fun aGenericToolCallingTemplateGetsTheJsonParser() {
+        val support = ToolCallSupport.detect(qwenStyleTemplate, hints = listOf("Qwen/Qwen2-0.5B"))
+
+        assertTrue(support.supported)
+        assertEquals(ToolCallDialect.JSON, support.dialect)
+    }
+
+    @Test
+    fun aPlainChatModelAdvertisesNothingButStillParsesJson() {
+        // Not supported != cannot be asked: a model fine-tuned on this repo's mobile_actions corpus
+        // learns the JSON shape without its template ever mentioning tools.
+        val support = ToolCallSupport.detect(plainChatTemplate, hints = listOf("HuggingFaceTB/SmolLM2-135M"))
+
+        assertFalse(support.supported)
+        assertEquals(ToolCallDialect.JSON, support.dialect)
+        assertEquals(ToolCallParser.Json, ToolCallParser.forDialect(support.dialect))
+    }
+
+    @Test
+    fun aPackageThatSaysNothingIsUnsupportedRatherThanAFailure() {
+        val support = ToolCallSupport.detect(chatTemplate = null, hints = emptyList())
+
+        assertFalse(support.supported)
+        assertEquals(ToolCallSupport.NONE, support)
+    }
+
+    @Test
+    fun itReadsTheStandaloneJinjaFileTheExporterWrites() {
+        val dir = temp.newFolder("tokenizer")
+        File(dir, "chat_template.jinja").writeText(functionGemmaTemplate)
+
+        val support = ToolCallSupport.read(dir, hints = listOf("gemma3_text"))
+
+        assertEquals(ToolCallDialect.FUNCTION_GEMMA, support.dialect)
+    }
+
+    @Test
+    fun anAbsentTokenizerStageIsNotAnError() {
+        // Detection decides which chips to show. A package that cannot be read must still load.
+        val support = ToolCallSupport.read(File(temp.root, "does-not-exist"), hints = emptyList())
+
+        assertEquals(ToolCallSupport.NONE, support)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentChunkerTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentChunkerTest.kt
new file mode 100644
index 0000000..f75746e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentChunkerTest.kt
@@ -0,0 +1,57 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #26: deterministic character-based chunking. */
+class DocumentChunkerTest {
+
+    @Test
+    fun exactWindowsForSizeAndOverlap() {
+        val text = (0 until 100).joinToString("") { (it % 10).toString() } // 100 chars
+        val chunks = DocumentChunker.split(text, chunkSize = 40, chunkOverlap = 10)
+        // stride = 30 -> windows [0,40) [30,70) [60,100)
+        assertEquals(3, chunks.size)
+        assertEquals(text.substring(0, 40), chunks[0])
+        assertEquals(text.substring(30, 70), chunks[1])
+        assertEquals(text.substring(60, 100), chunks[2])
+        // last window reaches the end (no gap)
+        assertTrue(chunks.last().endsWith(text.takeLast(1)))
+    }
+
+    @Test
+    fun singleChunkWhenShorterThanSize() {
+        assertEquals(listOf("hello"), DocumentChunker.split("hello", chunkSize = 40, chunkOverlap = 10))
+    }
+
+    @Test
+    fun emptyTextYieldsNoChunks() {
+        assertEquals(emptyList<String>(), DocumentChunker.split("", chunkSize = 40, chunkOverlap = 10))
+    }
+
+    @Test
+    fun overlapEqualToOrGreaterThanSizeRejected() {
+        assertThrows(IllegalArgumentException::class.java) {
+            DocumentChunker.split("abcdef", chunkSize = 10, chunkOverlap = 10)
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            DocumentChunker.split("abcdef", chunkSize = 10, chunkOverlap = 20)
+        }
+    }
+
+    @Test
+    fun zeroSizeRejected() {
+        assertThrows(IllegalArgumentException::class.java) {
+            DocumentChunker.split("abc", chunkSize = 0, chunkOverlap = 0)
+        }
+    }
+
+    @Test
+    fun noOverlapTilesExactly() {
+        val text = "abcdefghij" // 10
+        val chunks = DocumentChunker.split(text, chunkSize = 5, chunkOverlap = 0)
+        assertEquals(listOf("abcde", "fghij"), chunks)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentSourceTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentSourceTest.kt
new file mode 100644
index 0000000..e258e22
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/DocumentSourceTest.kt
@@ -0,0 +1,75 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import java.io.File
+import java.nio.file.Files
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #26: F3 document-loader registry + fail-closed on unsupported extensions. */
+class DocumentSourceTest {
+
+    private val dir: File = Files.createTempDirectory("docsource").toFile()
+
+    @After
+    fun cleanup() {
+        dir.deleteRecursively()
+    }
+
+    private fun write(name: String, content: String): File =
+        File(dir, name).apply { writeText(content) }
+
+    @Test
+    fun txtMapsToOneRecord() {
+        val docs = loadDocuments(write("notes.txt", "hello world").path)
+        assertEquals(1, docs.size)
+        assertEquals("notes", docs[0].id)
+        assertEquals("notes.txt", docs[0].title)
+        assertEquals("hello world", docs[0].text)
+    }
+
+    @Test
+    fun mdMapsToOneRecord() {
+        val docs = loadDocuments(write("readme.md", "# Title\nbody").path)
+        assertEquals(1, docs.size)
+        assertEquals("# Title\nbody", docs[0].text)
+    }
+
+    @Test
+    fun jsonlParsesRecordPerLine() {
+        val jsonl = """
+            {"id":"a","title":"A","text":"alpha","metadata":{"k":"v"}}
+            {"id":"b","title":"B","text":"beta"}
+        """.trimIndent()
+        val docs = loadDocuments(write("data.jsonl", jsonl).path)
+        assertEquals(2, docs.size)
+        assertEquals("a", docs[0].id)
+        assertEquals("alpha", docs[0].text)
+        assertEquals("v", docs[0].metadata["k"])
+        assertEquals("beta", docs[1].text)
+    }
+
+    @Test
+    fun unsupportedExtensionRejected() {
+        val ex = assertThrows(IllegalArgumentException::class.java) {
+            loadDocuments(write("doc.pdf", "%PDF-1.4").path)
+        }
+        assertTrue(ex.message!!.contains("text/Markdown/JSONL only"))
+        assertThrows(IllegalArgumentException::class.java) {
+            loadDocuments(write("doc.docx", "PK").path)
+        }
+    }
+
+    @Test
+    fun extensionMatchIsCaseInsensitive() {
+        val docs = loadDocuments(write("UP.TXT", "x").path)
+        assertEquals(1, docs.size)
+    }
+
+    @Test
+    fun registryHasOnlyV1Formats() {
+        assertEquals(setOf("txt", "md", "jsonl"), DOCUMENT_LOADER_REGISTRY.keys)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/GroundedFlowTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/GroundedFlowTest.kt
new file mode 100644
index 0000000..225c9c4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/GroundedFlowTest.kt
@@ -0,0 +1,42 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.runtime.GroundedResult
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #27: the grounded composition — retrieve (over InMemoryVectorStore) → assemble → generate — asserting
+ * the result carries the retrieved matches and the exact prompt handed to generation. Uses a fake
+ * generate lambda so it runs on the JVM with no JNI.
+ */
+class GroundedFlowTest {
+
+    private val dim = 64
+    private fun unit(vararg on: Int): FloatArray = FloatArray(dim) { if (it in on) 1f else 0f }
+
+    @Test
+    fun groundedResultCarriesMatchesAndExactPrompt() {
+        val store = InMemoryVectorStore(dim)
+        store.insert(RagDocument("d1", "D1", "the sky is blue"), unit(0))
+        store.insert(RagDocument("d2", "D2", "grass is green"), unit(1))
+
+        // retrieve leg over the real VectorStore boundary
+        val matches = store.search(unit(0), topK = 2, minScore = 0.0)
+            .map { RetrievalMatch(it.document.text, it.score) }
+        assertTrue(matches.isNotEmpty())
+
+        // assemble + (fake) generate
+        val prompt = PromptAssembler.assemble("what color is the sky?", matches)
+        var seenPrompt: String? = null
+        val fakeGenerate: (String) -> String = { p -> seenPrompt = p; "The sky is blue." }
+        val result = GroundedResult(text = fakeGenerate(prompt), matches = matches, prompt = prompt)
+
+        assertEquals(prompt, seenPrompt) // generation received the assembled prompt
+        assertEquals("The sky is blue.", result.text)
+        assertEquals(matches, result.matches)
+        assertTrue(result.prompt.contains("- the sky is blue"))
+        assertTrue(result.prompt.contains("Question: what color is the sky?"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStore.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStore.kt
new file mode 100644
index 0000000..023887b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStore.kt
@@ -0,0 +1,66 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import kotlin.math.sqrt
+
+/**
+ * Pure-Kotlin [VectorStore] for JVM tests — no Android, no ObjectBox (#25). Mirrors the ObjectBox
+ * semantics: cosine similarity ordering (ObjectBox returns COSINE distance and the store converts to
+ * similarity = `1 - distance`; direct cosine similarity here is the algebraically identical result),
+ * `minScore` filtering on similarity, and a separate non-ranked text-search path ([TEXT_SEARCH_SCORE]).
+ * Constructing with an unsupported dimension fails closed via [DimensionRegistry].
+ */
+class InMemoryVectorStore(private val dimension: Int) : VectorStore {
+
+    init {
+        DimensionRegistry.requireSupported(dimension)
+    }
+
+    private data class Row(val id: Long, val document: RagDocument, val embedding: FloatArray)
+
+    private val rows = mutableListOf<Row>()
+    private var nextId = 1L
+
+    override fun insert(document: RagDocument, embedding: FloatArray): Long {
+        require(embedding.size == dimension) {
+            "embedding size ${embedding.size} doesn't match store dimension $dimension"
+        }
+        val id = nextId++
+        rows.add(Row(id, document, embedding.copyOf()))
+        return id
+    }
+
+    override fun search(queryEmbedding: FloatArray, topK: Int, minScore: Double): List<RagMatch> {
+        require(queryEmbedding.size == dimension) {
+            "query embedding size ${queryEmbedding.size} doesn't match store dimension $dimension"
+        }
+        return rows
+            .map { RagMatch(it.document, cosineSimilarity(queryEmbedding, it.embedding)) }
+            .filter { it.score >= minScore }
+            .sortedByDescending { it.score }
+            .take(topK)
+    }
+
+    override fun textSearch(query: String, topK: Int): List<RagMatch> =
+        rows.filter { it.document.text.contains(query, ignoreCase = true) }
+            .map { RagMatch(it.document, TEXT_SEARCH_SCORE) }
+            .take(topK)
+
+    override fun count(): Long = rows.size.toLong()
+
+    override fun close() {
+        rows.clear()
+    }
+
+    private fun cosineSimilarity(a: FloatArray, b: FloatArray): Double {
+        var dot = 0.0
+        var na = 0.0
+        var nb = 0.0
+        for (i in a.indices) {
+            dot += a[i].toDouble() * b[i].toDouble()
+            na += a[i].toDouble() * a[i].toDouble()
+            nb += b[i].toDouble() * b[i].toDouble()
+        }
+        if (na == 0.0 || nb == 0.0) return 0.0
+        return dot / (sqrt(na) * sqrt(nb))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStoreTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStoreTest.kt
new file mode 100644
index 0000000..cab2a12
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/InMemoryVectorStoreTest.kt
@@ -0,0 +1,155 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * JVM unit tests for the #25 VectorStore boundary (no Android / no ObjectBox). Exercises the pure
+ * [InMemoryVectorStore] against the same semantics the on-device [ObjectBoxVectorStore] preserves:
+ * cosine ordering, `minScore`, embeddings stripped, the non-ranked text path, and the fail-closed
+ * dimension registry.
+ */
+class InMemoryVectorStoreTest {
+
+    private val dim = 64
+
+    /** A 64-d vector with the given leading components; the rest are zero. */
+    private fun vec(vararg leading: Float): FloatArray = FloatArray(dim).also { arr ->
+        for (i in leading.indices) arr[i] = leading[i]
+    }
+
+    private fun doc(id: String, text: String = id) = RagDocument(id = id, title = id, text = text)
+
+    private fun store(): VectorStore = InMemoryVectorStore(dim)
+
+    // --- insert / count ---------------------------------------------------------
+
+    @Test
+    fun insertAssignsIdsAndCounts() {
+        val s = store()
+        assertEquals(0L, s.count())
+        val id1 = s.insert(doc("a"), vec(1f, 0f))
+        val id2 = s.insert(doc("b"), vec(0f, 1f))
+        assertTrue(id1 > 0 && id2 > id1)
+        assertEquals(2L, s.count())
+    }
+
+    @Test
+    fun insertRejectsWrongDimension() {
+        val s = store()
+        assertThrows(IllegalArgumentException::class.java) {
+            s.insert(doc("a"), FloatArray(dim + 1))
+        }
+    }
+
+    // --- cosine ordering + similarities (hand-computed) -------------------------
+
+    @Test
+    fun searchOrdersByCosineSimilarity() {
+        val s = store()
+        s.insert(doc("x"), vec(1f, 0f)) // unit-x
+        s.insert(doc("y"), vec(0f, 1f)) // unit-y
+        // query [0.6, 0.8] (unit): cos(x)=0.6, cos(y)=0.8 -> y first, then x.
+        val matches = s.search(vec(0.6f, 0.8f), topK = 2)
+        assertEquals(listOf("y", "x"), matches.map { it.document.id })
+        assertEquals(0.8, matches[0].score, 1e-4)
+        assertEquals(0.6, matches[1].score, 1e-4)
+    }
+
+    @Test
+    fun searchHonorsTopK() {
+        val s = store()
+        s.insert(doc("x"), vec(1f, 0f))
+        s.insert(doc("y"), vec(0f, 1f))
+        s.insert(doc("z"), vec(1f, 1f))
+        assertEquals(2, s.search(vec(1f, 0f), topK = 2).size)
+    }
+
+    /**
+     * Score-semantics: an identical vector yields similarity 1.0 and an orthogonal one 0.0 — matching
+     * ObjectBox's `1 - distance` conversion (ORTVectorDatabase.kt:262). `minScore` filters on that
+     * similarity: at 0.5 the orthogonal hit is dropped.
+     */
+    @Test
+    fun minScoreFiltersOnSimilarity() {
+        val s = store()
+        s.insert(doc("same"), vec(1f, 0f))
+        s.insert(doc("orthogonal"), vec(0f, 1f))
+        val all = s.search(vec(1f, 0f), topK = 10)
+        assertEquals(1.0, all.first { it.document.id == "same" }.score, 1e-6)
+        assertEquals(0.0, all.first { it.document.id == "orthogonal" }.score, 1e-6)
+
+        val filtered = s.search(vec(1f, 0f), topK = 10, minScore = 0.5)
+        assertEquals(listOf("same"), filtered.map { it.document.id })
+    }
+
+    // --- no embeddings leak out -------------------------------------------------
+
+    @Test
+    fun resultsCarryNoEmbeddingVector() {
+        // The boundary returns only a RagDocument (id/title/text/metadata) + score — the FloatArray
+        // embedding never crosses it (mirrors ObjectBox's :226 strip). RagDocument has no embedding
+        // field, so a leak is impossible by construction; verify the returned document is exactly the
+        // inserted one and carries no vector data.
+        val s = store()
+        val d = doc("d1", text = "hello")
+        s.insert(d, vec(1f, 0f))
+        val match = s.search(vec(1f, 0f), topK = 1).single()
+        assertEquals(d, match.document)
+    }
+
+    // --- text search ------------------------------------------------------------
+
+    @Test
+    fun textSearchReturnsSubstringHitsWithFixedScore() {
+        val s = store()
+        s.insert(doc("d1", text = "The quick brown fox"), vec(1f, 0f))
+        s.insert(doc("d2", text = "lazy dog sleeps"), vec(0f, 1f))
+        val hits = s.textSearch("BROWN", topK = 10) // case-insensitive substring
+        assertEquals(listOf("d1"), hits.map { it.document.id })
+        assertEquals(TEXT_SEARCH_SCORE, hits[0].score, 0.0)
+    }
+
+    // --- dimension registry (fail closed) ---------------------------------------
+
+    @Test
+    fun unsupportedDimensionFailsClosed() {
+        assertFalse(DimensionRegistry.isSupported(300))
+        assertThrows(IllegalArgumentException::class.java) { InMemoryVectorStore(300) }
+    }
+
+    @Test
+    fun registeredDimensionIsAccepted() {
+        assertFalse(DimensionRegistry.isSupported(301))
+        DimensionRegistry.register(301)
+        assertTrue(DimensionRegistry.isSupported(301))
+        // Construction now succeeds (no throw) for the newly declared dimension.
+        val s = InMemoryVectorStore(301)
+        assertEquals(0L, s.count())
+    }
+
+    @Test
+    fun defaultDimensionsAreDeclared() {
+        assertTrue(DimensionRegistry.SUPPORTED_DIMENSIONS.containsAll(setOf(64, 128, 256, 384, 512, 768, 1024, 1536)))
+    }
+
+    // --- pluggable backend registry (F4) ----------------------------------------
+
+    @Test
+    fun registryCreatesRegisteredBackend() {
+        VectorStoreRegistry.register("inmemory") { ctx -> InMemoryVectorStore(ctx.embeddingDimension) }
+        val s = VectorStoreRegistry.create("inmemory", VectorStoreContext(embeddingDimension = 64))
+        assertEquals(0L, s.count())
+        assertTrue(VectorStoreRegistry.keys().contains(VectorStoreRegistry.DEFAULT_KEY))
+    }
+
+    @Test
+    fun registryRejectsUnknownBackend() {
+        assertThrows(IllegalArgumentException::class.java) {
+            VectorStoreRegistry.create("does-not-exist", VectorStoreContext(embeddingDimension = 64))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/IngestionPipelineTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/IngestionPipelineTest.kt
new file mode 100644
index 0000000..3a0b7be
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/IngestionPipelineTest.kt
@@ -0,0 +1,92 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * #26: the pure chunk → embed → insert pipeline over `InMemoryVectorStore` with a fake embedder — proves
+ * ingestion + progress without JNI/ObjectBox.
+ */
+class IngestionPipelineTest {
+
+    private val dim = 64
+    private fun fakeEmbedder(): (String) -> FloatArray = { s ->
+        // deterministic non-zero embedding derived from the chunk (content-independent shape is fine here)
+        FloatArray(dim) { i -> ((s.length + i) % 7 + 1).toFloat() }
+    }
+
+    @Test
+    fun insertsOneRowPerChunk() = runBlocking {
+        val store = InMemoryVectorStore(dim)
+        val text = (0 until 100).joinToString("") { (it % 10).toString() }
+        val inserted = IngestionPipeline.ingest(
+            documents = listOf(RagDocument("doc1", "Doc 1", text)),
+            chunkSize = 40,
+            chunkOverlap = 10,
+            embed = fakeEmbedder(),
+            store = store,
+        )
+        assertEquals(3, inserted) // stride 30 over 100 chars -> 3 windows
+        assertEquals(3L, store.count())
+    }
+
+    @Test
+    fun progressSequencePerDocument() = runBlocking {
+        val store = InMemoryVectorStore(dim)
+        val events = mutableListOf<String>()
+        val progress = object : IngestionProgress {
+            override fun onDocumentStart(id: String, totalDocs: Int) { events += "start:$id:$totalDocs" }
+            override fun onChunkEmbedded(docId: String, chunkIndex: Int, totalChunks: Int) {
+                events += "chunk:$docId:$chunkIndex/$totalChunks"
+            }
+            override fun onDocumentComplete(id: String) { events += "done:$id" }
+            override fun onError(id: String?, error: Throwable) { events += "err:$id" }
+        }
+        IngestionPipeline.ingest(
+            documents = listOf(RagDocument("d", "D", "abcdefghij")), // 10 chars
+            chunkSize = 5,
+            chunkOverlap = 0,
+            embed = fakeEmbedder(),
+            store = store,
+            progress = progress,
+        )
+        assertEquals(
+            listOf("start:d:1", "chunk:d:0/2", "chunk:d:1/2", "done:d"),
+            events,
+        )
+    }
+
+    @Test
+    fun embedderReturningNullReportsErrorAndSkipsDocument() = runBlocking {
+        val store = InMemoryVectorStore(dim)
+        var errored = false
+        val progress = object : IngestionProgress {
+            override fun onError(id: String?, error: Throwable) { errored = true }
+        }
+        val inserted = IngestionPipeline.ingest(
+            documents = listOf(RagDocument("d", "D", "some text here")),
+            chunkSize = 5,
+            chunkOverlap = 0,
+            embed = { null }, // embedding fails
+            store = store,
+            progress = progress,
+        )
+        assertEquals(0, inserted)
+        assertEquals(0L, store.count())
+        assertEquals(true, errored)
+    }
+
+    @Test
+    fun multipleDocumentsGetPrefixedChunkIds() = runBlocking {
+        val store = InMemoryVectorStore(dim)
+        IngestionPipeline.ingest(
+            documents = listOf(RagDocument("a", "A", "abcde"), RagDocument("b", "B", "fghij")),
+            chunkSize = 5,
+            chunkOverlap = 0,
+            embed = fakeEmbedder(),
+            store = store,
+        )
+        assertEquals(2L, store.count())
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/PromptAssemblerTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/PromptAssemblerTest.kt
new file mode 100644
index 0000000..07cfe97
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/PromptAssemblerTest.kt
@@ -0,0 +1,39 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #27: default grounded prompt template + caller override. */
+class PromptAssemblerTest {
+
+    private val matches = listOf(
+        RetrievalMatch("the sky is blue", 0.9),
+        RetrievalMatch("grass is green", 0.7),
+    )
+
+    @Test
+    fun defaultTemplateIncludesContextBulletsAndQuery() {
+        val prompt = PromptAssembler.assemble("what color is the sky?", matches)
+        assertTrue(prompt.contains("Context:"))
+        assertTrue(prompt.contains("- the sky is blue"))
+        assertTrue(prompt.contains("- grass is green"))
+        assertTrue(prompt.contains("Question: what color is the sky?"))
+        assertTrue(prompt.trimEnd().endsWith("Answer:"))
+        // bullet order follows match order
+        assertTrue(prompt.indexOf("- the sky is blue") < prompt.indexOf("- grass is green"))
+    }
+
+    @Test
+    fun callerOverrideReplacesTemplate() {
+        val custom = PromptStrategy { query, m -> "Q=$query|N=${m.size}" }
+        assertEquals("Q=hi|N=2", PromptAssembler.assemble("hi", matches, custom))
+    }
+
+    @Test
+    fun emptyMatchesStillProducesInspectablePrompt() {
+        val prompt = PromptAssembler.assemble("q", emptyList())
+        assertTrue(prompt.contains("Question: q"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/RetrievalProvenanceTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/RetrievalProvenanceTest.kt
new file mode 100644
index 0000000..a203613
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/rag/RetrievalProvenanceTest.kt
@@ -0,0 +1,84 @@
+package com.martinkorelic.mobiletransformers.rag
+
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Where a retrieved passage came from, at the public boundary.
+ *
+ * A match is a **chunk**: ingestion splits each file into pieces and stores every piece as its own
+ * row, keeping the file's name as the title and `<docId>#<n>` as the id. Both survived into the
+ * vector store and were then dropped by the mapping into `RetrievalMatch`, so a caller could show
+ * the retrieved text and could not say what it was retrieved *from* — and "found in 2 documents"
+ * was not derivable at all, because two chunks of one file were indistinguishable from two files.
+ *
+ * The grouping asserted here is what the Chat screen's retrieval report is built on.
+ */
+class RetrievalProvenanceTest {
+
+    private fun match(text: String, score: Double, title: String, chunkId: String) =
+        RetrievalMatch(text = text, score = score, title = title, chunkId = chunkId)
+
+    @Test
+    fun chunksOfOneFileCountAsOneDocument() {
+        val result = RetrievalResult(
+            matches = listOf(
+                match("batching halves the wall clock", 0.81, "notes.md", "notes#3"),
+                match("a batch of 4 fits in memory", 0.74, "notes.md", "notes#7"),
+                match("the encoder is all-MiniLM", 0.52, "setup.txt", "setup#0"),
+            ),
+        )
+
+        assertEquals(2, result.documentCount)
+        // Order follows the ranking, so the best-scoring source is named first.
+        assertEquals(listOf("notes.md", "setup.txt"), result.documentTitles)
+    }
+
+    @Test
+    fun theDocumentIdIsTheChunkIdWithoutItsIndex() {
+        assertEquals("notes", match("t", 1.0, "notes.md", "notes#3").documentId)
+        // A JSONL record may name itself anything, including something containing a '#'. Only the
+        // LAST '#' is the chunk index, so splitting on the first would truncate the real id.
+        assertEquals("issue#42", match("t", 1.0, "bugs.jsonl", "issue#42#1").documentId)
+        // No index at all: the whole id is the document.
+        assertEquals("whole", match("t", 1.0, "whole.txt", "whole").documentId)
+    }
+
+    @Test
+    fun anUnattributedHitIsNeverFoldedIntoAnotherDocument() {
+        // Defaults, i.e. a hit from a store written before provenance was carried. Claiming these
+        // are "the same document" would be an invention; each counts for itself.
+        val result = RetrievalResult(
+            matches = listOf(
+                RetrievalMatch("first", 0.9),
+                RetrievalMatch("second", 0.8),
+            ),
+        )
+
+        assertEquals(2, result.documentCount)
+        assertTrue(result.documentTitles.isEmpty())
+    }
+
+    @Test
+    fun attributedAndUnattributedHitsBothCount() {
+        val result = RetrievalResult(
+            matches = listOf(
+                match("a", 0.9, "notes.md", "notes#0"),
+                match("b", 0.8, "notes.md", "notes#1"),
+                RetrievalMatch("c", 0.7),
+            ),
+        )
+
+        assertEquals(2, result.documentCount)
+        assertEquals(listOf("notes.md"), result.documentTitles)
+    }
+
+    @Test
+    fun anEmptyResultClaimsNothing() {
+        assertEquals(0, RetrievalResult().documentCount)
+        assertTrue(RetrievalResult().documentTitles.isEmpty())
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/EngineSelectionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/EngineSelectionTest.kt
new file mode 100644
index 0000000..3027185
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/EngineSelectionTest.kt
@@ -0,0 +1,138 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * What a picker may offer must equal what the loader will accept.
+ *
+ * ### The defect this pins
+ *
+ * `RuntimeCapabilities.availableEngines` was assembled in the facade from two conditions — the
+ * package ships `inference/genai_config.json`, and the native GenAI probe succeeds — while
+ * [ModelRuntimeFactory.selectEngine] applies a third: the manifest variant's `supportedEngines`.
+ *
+ * FunctionGemma is the package where those diverge. Its `inference/` stage carries a
+ * `genai_config.json`, and the probe returns true on every device, but its manifest declares
+ * `supportedEngines: ["native"]` because Gemma-3 inference export goes through optimum rather than
+ * the vendored GenAI builder. So the facade reported GenAI as available, the app's picker offered
+ * it, the user selected it, and the load failed with
+ *
+ *     Generation session was never created: Engine "GENAI" is unavailable —
+ *     explicitly requested but not selectable: supportedEngines=[native]
+ *
+ * Both halves were behaving correctly in isolation. The bug was that there were two halves.
+ */
+class EngineSelectionTest {
+
+    private val nativeOnly = setOf("native")
+    private val both = setOf("native", "genai")
+
+    @Test
+    fun aNativeOnlyManifestDoesNotOfferGenAiEvenWithAGenAiConfigPresent() {
+        // Exactly the FunctionGemma package.
+        val available = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = nativeOnly,
+            genaiConfigPresent = true,
+            genaiAvailable = true,
+        )
+
+        assertEquals(setOf(InferenceEngine.NATIVE), available)
+    }
+
+    @Test
+    fun aGenAiCapableManifestOffersItWhenTheConfigAndProbeAgree() {
+        val available = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = both,
+            genaiConfigPresent = true,
+            genaiAvailable = true,
+        )
+
+        assertTrue(InferenceEngine.GENAI in available)
+    }
+
+    @Test
+    fun nativeIsAlwaysOffered() {
+        for (declared in listOf(nativeOnly, both, emptySet(), null)) {
+            for (config in listOf(true, false)) {
+                for (probe in listOf(true, false)) {
+                    val available =
+                        ModelRuntimeFactory.enginesAvailableFor(declared, config, probe)
+                    assertTrue(
+                        "Native is #11's guaranteed floor (declared=$declared)",
+                        InferenceEngine.NATIVE in available,
+                    )
+                }
+            }
+        }
+    }
+
+    @Test
+    fun aPackageDeclaringNothingStaysPermissive() {
+        // An unknown declaration must not become a narrower one, or upgrading the SDK breaks
+        // packages that work today. Same rule as ModelRuntimeFactory.create's default argument.
+        val available = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = null,
+            genaiConfigPresent = true,
+            genaiAvailable = true,
+        )
+
+        assertTrue(InferenceEngine.GENAI in available)
+    }
+
+    @Test
+    fun aMissingGenAiConfigWithdrawsTheOffer() {
+        val available = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = both,
+            genaiConfigPresent = false,
+            genaiAvailable = true,
+        )
+
+        assertFalse(InferenceEngine.GENAI in available)
+    }
+
+    @Test
+    fun aFailedNativeProbeWithdrawsTheOffer() {
+        val available = ModelRuntimeFactory.enginesAvailableFor(
+            declaredEngines = both,
+            genaiConfigPresent = true,
+            genaiAvailable = false,
+        )
+
+        assertFalse(InferenceEngine.GENAI in available)
+    }
+
+    /**
+     * The property, over every combination: offering an engine and then refusing it is the bug, and
+     * so is refusing one that was never offered. Exhaustive because there are only 16 states, and
+     * because a case-by-case test is what let the manifest condition go missing in the first place.
+     */
+    @Test
+    fun whatIsOfferedIsExactlyWhatTheFactoryWouldSelect() {
+        for (declared in listOf(nativeOnly, both, emptySet<String>(), null)) {
+            for (configPresent in listOf(true, false)) {
+                for (probe in listOf(true, false)) {
+                    val offered = ModelRuntimeFactory.enginesAvailableFor(declared, configPresent, probe)
+
+                    val selected = ModelRuntimeFactory.selectEngine(
+                        requested = InferenceEngine.GENAI,
+                        supportedEngines = declared ?: both,
+                        defaultEngine = InferenceEngine.NATIVE,
+                        genaiAvailable = probe,
+                    )
+                    // The facade additionally requires the side-car, which selectEngine never sees.
+                    val loadWouldSucceed = configPresent && selected == InferenceEngine.GENAI
+
+                    assertEquals(
+                        "declared=$declared config=$configPresent probe=$probe: the picker and the " +
+                            "loader disagree about GenAI",
+                        loadWouldSucceed,
+                        InferenceEngine.GENAI in offered,
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroomTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroomTest.kt
new file mode 100644
index 0000000..66a5397
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/MemoryHeadroomTest.kt
@@ -0,0 +1,124 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Predicting the memory kill, because there is no catching it.
+ *
+ * Training FunctionGemma on an S21 FE ended in `lmkd` sending SIGKILL — 2.1 GB RSS + 1.1 GB swap on a
+ * 5.5 GB device. No exception is delivered for that, so the only defence is an estimate made before
+ * the session opens.
+ *
+ * The first version of this policy sized the estimate from the stage's bytes on disk, and the device
+ * disproved it: `inference/` is 3.5 GB and chat runs with 2.4 GB available, because ONNX external
+ * initializers are mmapped and never all resident. `aDiskSizedRuleWouldHaveRefusedAWorkingSession`
+ * pins that, so the unsound version cannot come back.
+ */
+class MemoryHeadroomTest {
+
+    @get:Rule
+    val temp = TemporaryFolder()
+
+    // The measured device.
+    private val s21feAvailableKb = 2_414_736L
+
+    // The measured package.
+    private val functionGemmaParams = 268_098_176L
+    private val functionGemmaTrainableParams = 368_640L
+
+    @Test
+    fun aModelThatDwarfsAvailableMemoryIsFlaggedTight() {
+        val verdict = MemoryHeadroom.verdict(
+            trainingParameterCount = 3_000_000_000L,
+            availableKb = s21feAvailableKb,
+        )
+
+        assertTrue("a 3B-parameter training run cannot fit in 2.4 GB", verdict is MemoryHeadroom.Verdict.Tight)
+    }
+
+    @Test
+    fun theWarningNamesTheNumbers() {
+        val verdict = MemoryHeadroom.verdict(3_000_000_000L, s21feAvailableKb)
+
+        val message = (verdict as MemoryHeadroom.Verdict.Tight).message
+        // "out of memory" with no figures reads as an app bug rather than a device limit.
+        assertTrue(message, message.contains("3000M parameters"))
+        assertTrue(message, message.contains("GB"))
+        assertTrue("it must say why there is no error to catch: $message", message.contains("kills the app"))
+    }
+
+    @Test
+    fun aSmallModelFitsComfortably() {
+        // SmolLM2-135M: the package the recorded device suite trains, which has never been killed.
+        val verdict = MemoryHeadroom.verdict(135_000_000L, s21feAvailableKb)
+
+        assertEquals(MemoryHeadroom.Verdict.Fits, verdict)
+    }
+
+    @Test
+    fun theEstimateUsesTheFullParameterSetNotTheTrainableSubset() {
+        // A LoRA export's two counts differ by three orders of magnitude. Sizing from the trainable
+        // count would under-estimate by the entire frozen model — 368,640 params "needs" ~2 MB.
+        val fromTrainable = MemoryHeadroom.verdict(functionGemmaTrainableParams, availableKb = 600_000L)
+        val fromFull = MemoryHeadroom.verdict(functionGemmaParams, availableKb = 600_000L)
+
+        assertEquals(MemoryHeadroom.Verdict.Fits, fromTrainable)
+        assertTrue(
+            "the full parameter set must drive the estimate, or the check is decorative",
+            fromFull is MemoryHeadroom.Verdict.Tight,
+        )
+    }
+
+    @Test
+    fun anUnknownIsNeverARefusal() {
+        // An unreadable /proc/meminfo, or a manifest with no declared count, must not block a run.
+        assertEquals(MemoryHeadroom.Verdict.Unknown, MemoryHeadroom.verdict(functionGemmaParams, null))
+        assertEquals(MemoryHeadroom.Verdict.Unknown, MemoryHeadroom.verdict(0L, s21feAvailableKb))
+        assertEquals(MemoryHeadroom.Verdict.Unknown, MemoryHeadroom.verdict(functionGemmaParams, 0L))
+    }
+
+    @Test
+    fun availableIsReadFromMemAvailableNotMemFree() {
+        // MemFree excludes reclaimable page cache and reads far below what is obtainable; using it
+        // would refuse runs that fit. The S21 FE's own numbers: MemFree 1.2 GB, MemAvailable 2.4 GB.
+        val meminfo = File(temp.newFolder(), "meminfo").apply {
+            writeText(
+                """
+                MemTotal:        5493796 kB
+                MemFree:         1253616 kB
+                MemAvailable:    2414736 kB
+                Buffers:            3888 kB
+                """.trimIndent(),
+            )
+        }
+
+        assertEquals(2_414_736L, MemoryHeadroom.availableKb(meminfo))
+    }
+
+    @Test
+    fun anUnreadableMeminfoIsNullRatherThanAThrow() {
+        assertEquals(null, MemoryHeadroom.availableKb(File(temp.root, "absent")))
+    }
+
+    @Test
+    fun aDiskSizedRuleWouldHaveRefusedAWorkingSession() {
+        // The reason this policy is parameter-based. FunctionGemma's inference stage is 3.52 GB of
+        // fp32 and chat demonstrably works on this device with 2.4 GB available, because those
+        // weights are file-backed. Any rule keyed on stage bytes calls that impossible.
+        val inferenceStageBytes = 3_520_000_000L
+        val wouldRefuse = (inferenceStageBytes / 1024.0 * 1.5) > s21feAvailableKb
+
+        assertTrue(
+            "this asserts the UNSOUND rule refuses a working session — it documents why the policy " +
+                "is not written that way",
+            wouldRefuse,
+        )
+        // And the policy that shipped does not consult stage size at all.
+        assertEquals(MemoryHeadroom.Verdict.Fits, MemoryHeadroom.verdict(135_000_000L, s21feAvailableKb))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/NativeLoadRegressionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/NativeLoadRegressionTest.kt
new file mode 100644
index 0000000..3a0a85b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/NativeLoadRegressionTest.kt
@@ -0,0 +1,54 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import java.io.File
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #23 regression guards (source greps): the retired `inference/merged/` handoff must not reappear in the
+ * load path, and the dead GenAI stubs (`ORTGenAINative.kt` / `onnx-genai.cpp`, deleted by #11) must stay
+ * deleted rather than be resurrected half-implemented.
+ */
+class NativeLoadRegressionTest {
+
+    private fun moduleRoot(): File {
+        var dir: File? = File("").absoluteFile
+        while (dir != null) {
+            if (File(dir, "src/main/cpp/session_cache.h").isFile) return dir
+            val nested = File(dir, "android/MobileTransformersApp/MobileTransformers")
+            if (File(nested, "src/main/cpp/session_cache.h").isFile) return nested
+            dir = dir.parentFile
+        }
+        error("could not locate the MobileTransformers module root from ${File("").absolutePath}")
+    }
+
+    private fun read(rel: String): String = File(moduleRoot(), rel).readText()
+
+    @Test
+    fun noMergedSubdirLiteralInNativeLoadPath() {
+        val kotlin = read("src/main/java/com/martinkorelic/mobiletransformers/ORTGeneratorNative.kt")
+        assertFalse("ORTGeneratorNative still builds an inference/merged path", kotlin.contains("\"/merged\""))
+        assertFalse("ORTGeneratorNative still probes a 'merged' subdir", kotlin.contains(", \"merged\")"))
+
+        val cache = read("src/main/cpp/session_cache.h")
+        assertFalse("session_cache still reads from /merged", cache.contains("\"/merged\""))
+        assertFalse("session_cache still reads from inference/merged", cache.contains("inference_model_path + \"/merged\""))
+    }
+
+    @Test
+    fun handoffLoadIsMapDriven() {
+        val cache = read("src/main/cpp/session_cache.h")
+        assertTrue("session_cache must load via the shared handoff reader", cache.contains("load_handoff_entries"))
+    }
+
+    @Test
+    fun deadGenAiStubsStayDeleted() {
+        val root = moduleRoot()
+        assertFalse(
+            "ORTGenAINative.kt was resurrected",
+            File(root, "src/main/java/com/martinkorelic/mobiletransformers/ORTGenAINative.kt").exists(),
+        )
+        assertFalse("onnx-genai.cpp was resurrected", File(root, "src/main/cpp/onnx-genai.cpp").exists())
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/RuntimeSelectionTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/RuntimeSelectionTest.kt
new file mode 100644
index 0000000..a6c66ee
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/runtime/RuntimeSelectionTest.kt
@@ -0,0 +1,101 @@
+package com.martinkorelic.mobiletransformers.runtime
+
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * #11: engine selection/fallback + the data-driven EP registry (F3) — all pure, no device/JNI (the GenAI
+ * availability probe is injected via [GenAiSupport.probe]).
+ */
+class RuntimeSelectionTest {
+
+    private val both = setOf("native", "genai")
+
+    @After
+    fun restoreProbe() {
+        // Reset to a benign default so other test classes aren't affected (production sets the JNI probe).
+        GenAiSupport.probe = { false }
+    }
+
+    @Test
+    fun genaiSelectedOnlyWhenRequestedSupportedAndAvailable() {
+        assertEquals(
+            InferenceEngine.GENAI,
+            ModelRuntimeFactory.selectEngine(InferenceEngine.GENAI, both, InferenceEngine.NATIVE, true),
+        )
+    }
+
+    @Test
+    fun fallsBackToNativeWhenGenaiUnavailable() {
+        assertEquals(
+            InferenceEngine.NATIVE,
+            ModelRuntimeFactory.selectEngine(InferenceEngine.GENAI, both, InferenceEngine.NATIVE, false),
+        )
+    }
+
+    @Test
+    fun fallsBackToNativeWhenVariantDoesNotSupportGenai() {
+        assertEquals(
+            InferenceEngine.NATIVE,
+            ModelRuntimeFactory.selectEngine(InferenceEngine.GENAI, setOf("native"), InferenceEngine.NATIVE, true),
+        )
+    }
+
+    @Test
+    fun nativeRequestAlwaysNative() {
+        assertEquals(
+            InferenceEngine.NATIVE,
+            ModelRuntimeFactory.selectEngine(InferenceEngine.NATIVE, both, InferenceEngine.NATIVE, true),
+        )
+    }
+
+    @Test
+    fun nullRequestUsesDefaultEngine() {
+        assertEquals(
+            InferenceEngine.GENAI,
+            ModelRuntimeFactory.selectEngine(null, both, InferenceEngine.GENAI, true),
+        )
+        assertEquals(
+            InferenceEngine.NATIVE,
+            ModelRuntimeFactory.selectEngine(null, both, InferenceEngine.NATIVE, true),
+        )
+    }
+
+    /**
+     * The fallback must be conditional on who chose the engine.
+     *
+     * It was unconditional, and that hid a real failure for an entire release cycle: genai_config.json
+     * carried a key GenAI 0.14 rejects, so GenAI never loaded, so `DualEngineParityTest` compared Native
+     * with Native and passed. Gate 0.1 #1 and #4 were both recorded as proven off single-engine
+     * measurements. A silent substitution makes a green test meaningless.
+     */
+    @Test
+    fun explicitGenaiRequestMayNotSilentlyBecomeNative() {
+        assertEquals(false, ModelRuntimeFactory.mayFallBackToNative(InferenceEngine.GENAI))
+    }
+
+    @Test
+    fun autoSelectionMayFallBackToTheNativeFloor() {
+        assertEquals(true, ModelRuntimeFactory.mayFallBackToNative(null))
+        assertEquals(true, ModelRuntimeFactory.mayFallBackToNative(InferenceEngine.NATIVE))
+    }
+
+    @Test
+    fun epRegistryResolvesOrderedProvidersPerEngine() {
+        GenAiSupport.probe = { true }
+        assertEquals(
+            listOf("cpu", "xnnpack", "nnapi"),
+            EngineRegistry.providersFor(InferenceEngine.NATIVE),
+        )
+        assertEquals(listOf("genai"), EngineRegistry.providersFor(InferenceEngine.GENAI))
+    }
+
+    @Test
+    fun epRegistryDropsGenaiWhenUnavailable() {
+        GenAiSupport.probe = { false }
+        assertEquals(emptyList<String>(), EngineRegistry.providersFor(InferenceEngine.GENAI))
+        // Native providers are always available (the floor).
+        assertEquals(listOf("cpu", "xnnpack", "nnapi"), EngineRegistry.providersFor(InferenceEngine.NATIVE))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/SchedulerDelayTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/SchedulerDelayTest.kt
new file mode 100644
index 0000000..df3842b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/SchedulerDelayTest.kt
@@ -0,0 +1,65 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import androidx.work.Data
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+/**
+ * The scheduler's start delay survives the trip through WorkManager's `Data`.
+ *
+ * A scheduled chunk is rebuilt from primitives after process death, so a field the codec does not
+ * carry is a field that silently reverts — which for a delay means a run the user deferred starting
+ * immediately. `TrainingScheduleConfigCodec` is the seam, and it is only checkable here: the delay
+ * itself is applied by `setInitialDelay` inside `enqueueChunk`, which needs a real WorkManager.
+ */
+class SchedulerDelayTest {
+
+    private fun roundTrip(config: TrainingScheduleConfig): TrainingScheduleConfig {
+        val builder = Data.Builder()
+        for ((key, value) in TrainingScheduleConfigCodec.toPairs(config)) {
+            when (value) {
+                is Boolean -> builder.putBoolean(key, value)
+                is Int -> builder.putInt(key, value)
+                is Long -> builder.putLong(key, value)
+                is String -> builder.putString(key, value)
+                else -> error("unencodable $key")
+            }
+        }
+        return TrainingScheduleConfigCodec.fromData(builder.build())
+    }
+
+    @Test
+    fun theDelaySurvivesTheCodec() {
+        assertEquals(240L, roundTrip(TrainingScheduleConfig(initialDelayMinutes = 240)).initialDelayMinutes)
+    }
+
+    @Test
+    fun noDelayIsTheDefaultAndRoundTripsAsZero() {
+        assertEquals(0L, TrainingScheduleConfig().initialDelayMinutes)
+        assertEquals(0L, roundTrip(TrainingScheduleConfig()).initialDelayMinutes)
+    }
+
+    @Test
+    fun theOtherFieldsStillRoundTrip() {
+        // The codec is hand-written, so adding a key is exactly where the others get dropped.
+        val config = TrainingScheduleConfig(
+            requiresCharging = false,
+            requiresDeviceIdle = true,
+            maxRuntimeMinutes = 12,
+            maxStepsPerChunk = 7,
+            checkpointEverySteps = 3,
+            totalSteps = 99,
+            initialDelayMinutes = 60,
+        )
+
+        assertEquals(config, roundTrip(config))
+    }
+
+    @Test
+    fun aNegativeDelayIsRejected() {
+        assertThrows(IllegalArgumentException::class.java) {
+            TrainingScheduleConfig(initialDelayMinutes = -1)
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingProgressNotificationTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingProgressNotificationTest.kt
new file mode 100644
index 0000000..ef23083
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingProgressNotificationTest.kt
@@ -0,0 +1,67 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/**
+ * The fraction behind the ongoing training notification.
+ *
+ * `TrainingWorker.foregroundInfo` has always accepted a `progress` and called `setProgress(100, …)`
+ * with it — but its only call site passed `null`, once, before the first optimizer step. The
+ * mechanism worked and nothing fed it, so a multi-hour run showed a static "Training chunk 1" that
+ * gave no sign the device was still working. `reportProgress` now drives it from the step stream, and
+ * this pins the arithmetic it drives it with.
+ *
+ * The subtle part is that both numbers are **cumulative across chunks**: `currentStep` comes from
+ * `globalStep` restored out of `training_state.json`, and `totalSteps` is a whole-run target. Treating
+ * either as chunk-local would restart the bar at 0% on every resume.
+ */
+class TrainingProgressNotificationTest {
+
+    @Test
+    fun reportsTheWholeRunFractionNotTheChunks() {
+        // Chunk 3 resuming at step 150 of a 200-step run is 75% done, not 0%.
+        assertEquals(75, TrainingWorker.percentComplete(currentStep = 150, totalSteps = 200))
+    }
+
+    @Test
+    fun spansTheRange() {
+        assertEquals(0, TrainingWorker.percentComplete(0, 200))
+        assertEquals(50, TrainingWorker.percentComplete(100, 200))
+        assertEquals(100, TrainingWorker.percentComplete(200, 200))
+    }
+
+    /**
+     * A chunk may legitimately overshoot: `applyTo` sets `maxSteps = resumedGlobalStep +
+     * maxStepsPerChunk`, which the final chunk can carry past the target. An uncoerced value would
+     * hand `setProgress` a figure over 100.
+     */
+    @Test
+    fun overshootIsClampedRatherThanReportedAbove100() {
+        assertEquals(100, TrainingWorker.percentComplete(205, 200))
+    }
+
+    /** No declared target means no honest fraction; the notification stays indeterminate. */
+    @Test
+    fun anAbsentOrZeroTargetYieldsNoFraction() {
+        assertNull(TrainingWorker.percentComplete(10, null))
+        assertNull(TrainingWorker.percentComplete(10, 0))
+        assertNull(TrainingWorker.percentComplete(10, -5))
+    }
+
+    @Test
+    fun aNegativeStepYieldsNoFraction() {
+        assertNull(TrainingWorker.percentComplete(-1, 200))
+    }
+
+    /**
+     * The throttle only suppresses repeats if the value is stable within a percent band — integer
+     * division gives that, but only if it does not overflow first. A long-running job at a large step
+     * count multiplied by 100 in Int space would wrap negative.
+     */
+    @Test
+    fun aLargeStepCountDoesNotOverflow() {
+        assertEquals(50, TrainingWorker.percentComplete(50_000_000, 100_000_000))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfigTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfigTest.kt
new file mode 100644
index 0000000..55a5cfe
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/scheduler/TrainingScheduleConfigTest.kt
@@ -0,0 +1,166 @@
+package com.martinkorelic.mobiletransformers.scheduler
+
+import com.martinkorelic.mobiletransformers.ORTTrainingConfig
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * #34: the pure half of the scheduler — how a schedule config bounds one chunk.
+ *
+ * The device leg proves a chunk runs; these prove it is bounded and resumable in the first place,
+ * which is what makes chunk N+1 a continuation rather than a restart.
+ */
+class TrainingScheduleConfigTest {
+
+    @Test
+    fun `chunk bounds map onto the training config`() {
+        val config = TrainingScheduleConfig(maxStepsPerChunk = 25, checkpointEverySteps = 5)
+        val bounded = config.applyTo(ORTTrainingConfig(repoName = "m"))
+
+        assertEquals(25, bounded.maxSteps)
+        assertEquals(5, bounded.saveSteps)
+    }
+
+    @Test
+    fun `the chunk budget is cumulative, not per-chunk`() {
+        // The defect this pins: `ORTTrainerNative` computes `totalSteps = maxSteps ?: ...` and loops
+        // `while (globalStep < totalSteps)` AFTER restoring globalStep. So `maxSteps` is a target, not
+        // a budget. Passing the chunk size directly made chunk 2 onward no-ops — restore 2, "train for
+        // 2 steps", `2 < 2` is false, exit having trained nothing, report success.
+        val config = TrainingScheduleConfig(maxStepsPerChunk = 25)
+
+        assertEquals(25, config.applyTo(ORTTrainingConfig(repoName = "m"), resumedGlobalStep = 0).maxSteps)
+        assertEquals(50, config.applyTo(ORTTrainingConfig(repoName = "m"), resumedGlobalStep = 25).maxSteps)
+        assertEquals(75, config.applyTo(ORTTrainingConfig(repoName = "m"), resumedGlobalStep = 50).maxSteps)
+
+        // Every chunk must be able to do a FULL chunk of work, no matter how far in it starts.
+        for (resumed in listOf(0, 1, 7, 999)) {
+            val bounded = config.applyTo(ORTTrainingConfig(repoName = "m"), resumedGlobalStep = resumed)
+            assertEquals(25, bounded.maxSteps!! - resumed)
+        }
+    }
+
+    @Test
+    fun `a chunk always resumes and always checkpoints`() {
+        // These two are what make chunking correct at all. `loadFromState` restores globalStep/epoch
+        // AND the LR scheduler position; `saveModelAtEnd` makes the chunk boundary a checkpoint.
+        val bounded = TrainingScheduleConfig().applyTo(ORTTrainingConfig(repoName = "m"))
+
+        assertTrue("chunk N+1 must continue, not restart", bounded.loadFromState)
+        assertTrue("the chunk boundary must itself be a checkpoint", bounded.saveModelAtEnd)
+    }
+
+    @Test
+    fun `merging is not done per chunk`() {
+        // Merge rewrites every trainable tensor on disk. Doing it at each of N chunk boundaries would
+        // multiply the most expensive I/O in the system by N for no benefit — merge is an
+        // end-of-job act, and the default ORTTrainingConfig has it on.
+        val base = ORTTrainingConfig(repoName = "m")
+        assertTrue("precondition: the default merges at end", base.mergeWeightsAtEnd)
+        assertFalse(TrainingScheduleConfig().applyTo(base).mergeWeightsAtEnd)
+    }
+
+    @Test
+    fun `caller settings unrelated to chunking survive`() {
+        val base = ORTTrainingConfig(repoName = "m", batchSize = 7, numTrainEpochs = 3)
+        val bounded = TrainingScheduleConfig().applyTo(base)
+
+        assertEquals(7, bounded.batchSize)
+        assertEquals(3, bounded.numTrainEpochs)
+        assertEquals("m", bounded.repoName)
+    }
+
+    @Test
+    fun `non-positive bounds fail closed at construction`() {
+        for (bad in listOf(
+            { TrainingScheduleConfig(maxRuntimeMinutes = 0) },
+            { TrainingScheduleConfig(maxStepsPerChunk = 0) },
+            { TrainingScheduleConfig(checkpointEverySteps = -1) },
+        )) {
+            try {
+                bad()
+                throw AssertionError("expected an IllegalArgumentException")
+            } catch (expected: IllegalArgumentException) {
+                assertTrue(expected.message!!.contains("must be positive"))
+            }
+        }
+    }
+
+    @Test
+    fun `thermal pause boundary is SEVERE, and an unknown reading does not pause`() {
+        // android.os.PowerManager.THERMAL_STATUS_* : NONE=0 LIGHT=1 MODERATE=2 SEVERE=3 CRITICAL=4
+        assertFalse(ThermalGuard.shouldPause(0))
+        assertFalse(ThermalGuard.shouldPause(2))
+        assertTrue(ThermalGuard.shouldPause(3))
+        assertTrue(ThermalGuard.shouldPause(4))
+
+        // -1 means the platform predates API 29. Refusing to train because the device is too old to
+        // report its temperature would disable the feature on exactly the hardware it targets.
+        assertFalse(ThermalGuard.shouldPause(-1))
+    }
+
+    /**
+     * The #34 assertion that single-resume tests do not make: **N** chunk boundaries, not one.
+     *
+     * A schedule that restarts, or that loses one step per boundary, still passes a single
+     * save/restore round trip — the error only accumulates across chunks. So the comparison is
+     * against the uninterrupted run at the same global step: a relative assertion, with no LR
+     * constant written down anywhere that could encode one schedule and silently measure another.
+     */
+    @Test
+    fun `the LR schedule survives repeated chunk boundaries`() {
+        val stepsPerChunk = 5
+        val chunks = 3
+        val eps = 1e-9f
+
+        val uninterrupted =
+            com.martinkorelic.mobiletransformers.LinearLRScheduler(
+                baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 20,
+            )
+        val expected = (1..stepsPerChunk * chunks).map { uninterrupted.step() }
+
+        // Each chunk is a FRESH scheduler restored from the previous chunk's persisted state —
+        // which is what a new process, or a new Worker instance, actually gets.
+        val actual = mutableListOf<Float>()
+        var carried =
+            com.martinkorelic.mobiletransformers.LinearLRScheduler(
+                baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 20,
+            ).stateDict()
+        repeat(chunks) {
+            val chunkScheduler =
+                com.martinkorelic.mobiletransformers.LinearLRScheduler(
+                    baseLr = 1e-3f, startFactor = 1f, endFactor = 1f / 3f, totalIters = 20,
+                )
+            chunkScheduler.loadFromState(carried)
+            repeat(stepsPerChunk) { actual.add(chunkScheduler.step()) }
+            carried = chunkScheduler.stateDict()
+        }
+
+        assertEquals(expected.size, actual.size)
+        expected.forEachIndexed { i, lr ->
+            assertEquals("LR diverged at global step ${i + 1}", lr, actual[i], eps)
+        }
+        // And the schedule really did move, so the comparison is not two flat lines agreeing.
+        assertTrue("the schedule must decay across the run", actual.last() < actual.first())
+    }
+
+    @Test
+    fun `a trace row carries every column its header declares`() {
+        val sample = ThermalSample(
+            thermalStatus = 2,
+            batteryPercent = 88,
+            batteryTemperatureDeciC = 301,
+            chargeCounterMicroAh = 3_210_000L,
+            timestampMillis = 1_700_000_000_000L,
+        )
+        val row = sample.toCsvRow(chunk = 3, globalStep = 150)
+
+        assertEquals(ThermalSample.CSV_HEADER.split(",").size, row.split(",").size)
+        assertEquals(
+            "1700000000000,3,150,2,88,301,3210000",
+            row,
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/CheckpointInfoTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/CheckpointInfoTest.kt
new file mode 100644
index 0000000..7cf13a5
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/CheckpointInfoTest.kt
@@ -0,0 +1,57 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.google.gson.Gson
+import com.martinkorelic.mobiletransformers.SchedulerState
+import com.martinkorelic.mobiletransformers.TrainingState
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/** #18: CheckpointInfo is a read-only projection of training_state.json — format unchanged after reading. */
+class CheckpointInfoTest {
+
+    @get:Rule
+    val tmp = TemporaryFolder()
+
+    @Test
+    fun projectsStateAndPreservesFormat() {
+        val state =
+            TrainingState(
+                schedulerState =
+                    SchedulerState(
+                        totalSteps = 200,
+                        warmupSteps = 10,
+                        minLr = 0f,
+                        initialLr = 1e-4f,
+                        currentStep = 120,
+                    ),
+                currentGlobalStep = 120,
+                currentEpoch = 2,
+            )
+        val train = tmp.newFolder("train")
+        val stateFile = train.resolve("training_state.json")
+        val json = Gson().toJson(state)
+        stateFile.writeText(json)
+
+        val info =
+            CheckpointInfo.read(train.resolve("checkpoint").absolutePath, stateFile.absolutePath)
+
+        assertTrue(info.exists)
+        assertEquals(120, info.currentGlobalStep)
+        assertEquals(2, info.currentEpoch)
+        assertEquals(120, info.schedulerStep)
+        assertEquals(200, info.totalSteps)
+        // reading must not rewrite the file (format preserved).
+        assertEquals(json, stateFile.readText())
+    }
+
+    @Test
+    fun absentStateFileProjectsExistsFalse() {
+        val info = CheckpointInfo.read("/nope/checkpoint", "/nope/training_state.json")
+        assertFalse(info.exists)
+        assertEquals(0, info.currentGlobalStep)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapterTest.kt b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapterTest.kt
new file mode 100644
index 0000000..48f408f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/java/com/martinkorelic/mobiletransformers/training/TrainingEventAdapterTest.kt
@@ -0,0 +1,96 @@
+package com.martinkorelic.mobiletransformers.training
+
+import com.martinkorelic.mobiletransformers.TrainingProgress
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.yield
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** #18: the callback->status/event mapping is one-to-one and ordered (pure, no native handle). */
+class TrainingEventAdapterTest {
+
+    private fun progress(step: Int) =
+        TrainingProgress(
+            currentStep = step,
+            currentEpoch = 0,
+            totalLoss = 1.5f,
+            epochLoss = 1.5f,
+            stepLoss = 0.5f,
+            learningRate = 1e-4f,
+            stepDurationMs = 10,
+            epochDurationMs = 100,
+            totalDurationMs = 1000,
+        )
+
+    @Test
+    fun statusTransitionsFollowCallbacks() {
+        val adapter = TrainingEventAdapter()
+        assertEquals(TrainingStatus.Idle, adapter.status.value)
+
+        adapter.onModelLoadStart()
+        assertEquals(TrainingStatus.Preparing, adapter.status.value)
+
+        adapter.onStepEnd(progress(1))
+        assertTrue(adapter.status.value is TrainingStatus.Running)
+
+        adapter.onMergeStart(progress(2))
+        assertEquals(TrainingStatus.Merging, adapter.status.value)
+
+        adapter.onSaveModelStart(progress(2))
+        assertEquals(TrainingStatus.Saving, adapter.status.value)
+
+        adapter.onCompletion(progress(2))
+        val completed = adapter.status.value
+        assertTrue(completed is TrainingStatus.Completed)
+        completed as TrainingStatus.Completed
+        assertEquals(2, completed.result.finalStep)
+    }
+
+    @Test
+    fun eventStreamOrderMatchesScriptedCallbacks() = runBlocking {
+        val adapter = TrainingEventAdapter()
+        val collected = mutableListOf<TrainingEvent>()
+        val collector = launch { adapter.events.collect { collected += it } }
+        yield() // let the collector subscribe before we drive callbacks
+
+        adapter.onDataLoadEnd(totalSteps = 4, stepsPerEpoch = 2)
+        adapter.onStepEnd(progress(1))
+        adapter.onOptimizerStep(progress(1))
+        adapter.onEpochEnd(progress(2))
+        adapter.onMergeStart(progress(2))
+        adapter.onMergeEnd(progress(2))
+        adapter.onSaveModelEnd(progress(2))
+        adapter.onCompletion(progress(2))
+        yield() // let the collector drain the buffered emissions
+
+        collector.cancel()
+
+        assertEquals(
+            listOf(
+                "DataLoaded",
+                "Step",
+                "OptimizerStep",
+                "Epoch",
+                "MergeStarted",
+                "MergeFinished",
+                "Saved",
+                "Done",
+            ),
+            collected.map { it::class.simpleName },
+        )
+        // merge fired, so the completed result records merged = true
+        val done = collected.last() as TrainingEvent.Done
+        assertTrue(done.result.merged)
+    }
+
+    @Test
+    fun errorTransitionsToFailed() {
+        val adapter = TrainingEventAdapter()
+        adapter.onError(IllegalStateException("boom"))
+        val s = adapter.status.value
+        assertTrue(s is TrainingStatus.Failed)
+        assertEquals("boom", (s as TrainingStatus.Failed).error.message)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/resources/federated_handoff.json b/android/MobileTransformers/MobileTransformers/src/test/resources/federated_handoff.json
new file mode 100644
index 0000000..d7479df
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformers/src/test/resources/federated_handoff.json
@@ -0,0 +1,102 @@
+{
+  "engines": [
+    "native",
+    "genai"
+  ],
+  "entries": [
+    {
+      "adapterDtypes": {
+        "adapter_A": "float32",
+        "adapter_B": "float32"
+      },
+      "adapterShapes": {
+        "adapter_A": [
+          2,
+          3
+        ],
+        "adapter_B": [
+          4,
+          2
+        ]
+      },
+      "checkpointNames": {
+        "adapter_A": "l0.lora_A.lora",
+        "adapter_B": "l0.lora_B.lora",
+        "weight": "l0.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        4,
+        3
+      ],
+      "tensorDtypes": {},
+      "tensorShapes": {},
+      "trainingBaseLayerName": "backbone.model.layers.0.self_attn.q_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    },
+    {
+      "adapterDtypes": {
+        "adapter_A": "float32",
+        "adapter_B": "float32"
+      },
+      "adapterShapes": {
+        "adapter_A": [
+          2,
+          5
+        ],
+        "adapter_B": [
+          6,
+          2
+        ]
+      },
+      "checkpointNames": {
+        "adapter_A": "l1.lora_A.lora",
+        "adapter_B": "l1.lora_B.lora",
+        "weight": "l1.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.1.attn.v_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.1.attn.v_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.1.attn.v_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        6,
+        5
+      ],
+      "tensorDtypes": {},
+      "tensorShapes": {},
+      "trainingBaseLayerName": "backbone.model.layers.1.self_attn.v_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    }
+  ],
+  "externalDataLayout": "one_file_per_tensor",
+  "frozenBaseBlob": "frozen_base.onnx.data",
+  "handoffMode": "external_initializer",
+  "mergerModels": {},
+  "minReaderVersion": "1.0",
+  "schemaVersion": "1.1"
+}
diff --git a/android/MobileTransformers/MobileTransformers/src/test/resources/federated_record.golden.bin b/android/MobileTransformers/MobileTransformers/src/test/resources/federated_record.golden.bin
new file mode 100644
index 0000000..304fb55
Binary files /dev/null and b/android/MobileTransformers/MobileTransformers/src/test/resources/federated_record.golden.bin differ
diff --git a/android/ORTransformer/app/.gitignore b/android/MobileTransformers/MobileTransformersApp/.gitignore
similarity index 100%
rename from android/ORTransformer/app/.gitignore
rename to android/MobileTransformers/MobileTransformersApp/.gitignore
diff --git a/android/MobileTransformers/MobileTransformersApp/build.gradle.kts b/android/MobileTransformers/MobileTransformersApp/build.gradle.kts
new file mode 100644
index 0000000..5ed5bea
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/build.gradle.kts
@@ -0,0 +1,152 @@
+import org.jetbrains.kotlin.cli.jvm.main
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.jetbrains.kotlin.android)
+}
+
+android {
+    namespace = "com.martinkorelic.mobiletransformers.app"
+    compileSdk = 34
+
+    defaultConfig {
+
+        applicationId = "com.martinkorelic.mobiletransformers.app"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 2
+        // Derived from the root `version` property (gradle.properties), which `test_version_sites.py`
+        // pins to pyproject.toml. It was the literal "1.0", which matched no other site in the repo:
+        // the sample app is the one artifact a user sees a version number on, and it advertised a
+        // release that does not exist.
+        versionName = rootProject.findProperty("version")?.toString() ?: "0.0.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+
+        // Hub token for pulling a PRIVATE or GATED package, taken from the build environment.
+        //
+        // An Android app cannot read the host's environment at runtime, so the value has to be baked
+        // in at build time. Source order: `-PmtHubToken=...` wins, else `HF_TOKEN_ORG`, else
+        // `HF_TOKEN`, else empty. Empty is the normal case and means "anonymous" — public packages
+        // pull without any of this.
+        //
+        //   HF_TOKEN_ORG=hf_xxx ./gradlew :MobileTransformersApp:assembleDebug
+        //   ./gradlew :MobileTransformersApp:assembleDebug -PmtHubToken=hf_xxx
+        //
+        // `HF_TOKEN_ORG` is tried FIRST, and the ordering is load-bearing rather than arbitrary. Four
+        // of the five catalog entries are private repos under the `mobiletransformers` org, and a
+        // fine-grained personal `HF_TOKEN` scoped to one repo cannot see them — so an APK built with
+        // the personal token shows a full catalog whose Install button 401s on almost every row. That
+        // is exactly the shape of failure this project keeps re-learning: the build succeeds, the app
+        // looks right, and the capability is silently absent. Same precedence as
+        // `scripts/publish_catalog.sh`, which publishes those repos.
+        //
+        // ⚠️ A token compiled into an APK is EXTRACTABLE by anyone holding the APK — `strings` on the
+        // dex is enough. This is a development and demo affordance for reaching your own private repo,
+        // not a way to ship credentials. Never build a release this way, and never commit a token to
+        // `gradle.properties`. A real app should obtain a token at runtime from the user or from an
+        // authenticated backend and hand it to `MobileTransformers.fromPretrained(hubConfig = ...)`,
+        // which is the same public entry point this uses.
+        val hubToken = (project.findProperty("mtHubToken") as String?)
+            ?.takeIf { it.isNotBlank() }
+            ?: System.getenv("HF_TOKEN_ORG")?.takeIf { it.isNotBlank() }
+            ?: System.getenv("HF_TOKEN")?.takeIf { it.isNotBlank() }
+            ?: ""
+        buildConfigField("String", "HF_TOKEN", "\"$hubToken\"")
+
+        vectorDrawables {
+            useSupportLibrary = true
+        }
+
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+
+    buildFeatures {
+        viewBinding = true
+        compose = true
+        // Carries HF_TOKEN (above), so the app can reach a private package without a UI keyboard.
+        buildConfig = true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.1"
+    }
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+        }
+    }
+
+    testOptions {
+        unitTests {
+            // The showcase app's ViewModels hold pure state-mapping logic (empty states, disabled
+            // features, engine pickers) that must be provable without a device — the app module had
+            // no test source set at all before the facade rewrite.
+            isIncludeAndroidResources = true
+            // Matches the library module: stubbed android.* methods THROW rather than returning null,
+            // so a test that accidentally reaches Android fails loudly instead of asserting on a
+            // silent default. Anything genuinely needing org.json/Intent uses Robolectric.
+            isReturnDefaultValues = false
+        }
+    }
+}
+
+dependencies {
+
+
+    implementation(project(":MobileTransformers"))
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.ui)
+    implementation(libs.androidx.ui.graphics)
+
+    androidTestImplementation(libs.androidx.ui.test.junit4)
+    // The BOM comes from the version catalog, like every other dependency. It used to be declared
+    // here as a hardcoded 2024.10.00 while the catalog pinned 2024.04.01 for the library module, so
+    // the two modules resolved different Compose versions from the same build.
+    val composeBom = platform(libs.androidx.compose.bom)
+    implementation(composeBom)
+    androidTestImplementation(composeBom)
+    implementation(libs.androidx.activity.compose)
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+
+    implementation(libs.material)
+    implementation(libs.androidx.constraintlayout)
+
+    // Compose
+    implementation(libs.androidx.material3)
+    implementation(libs.androidx.material.icons.extended)
+    // The model catalog is a bundled JSON asset so adding a model is editing one file; gson is
+    // already the module's JSON library on the SDK side.
+    implementation(libs.gson)
+
+    implementation(libs.androidx.ui.tooling.preview)
+    debugImplementation(libs.androidx.ui.tooling)
+
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.kotlinx.coroutines.android)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    debugImplementation(libs.androidx.ui.test.manifest)
+}
\ No newline at end of file
diff --git a/android/ORTransformer/app/proguard-rules.pro b/android/MobileTransformers/MobileTransformersApp/proguard-rules.pro
similarity index 100%
rename from android/ORTransformer/app/proguard-rules.pro
rename to android/MobileTransformers/MobileTransformersApp/proguard-rules.pro
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/AndroidManifest.xml b/android/MobileTransformers/MobileTransformersApp/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..3ad072b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/AndroidManifest.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!--
+      Permissions the ACTIONS this app allows a model to request need — see `ActionAllowlist`, which
+      declares each one beside the intent that needs it.
+
+      This was missing, and it is why tool calling appeared broken on device. `SET_ALARM` and
+      `SET_TIMER` both require `com.android.alarm.permission.SET_ALARM`. The model produced a correct
+      call, the validator accepted it, the card offered Run — and `startActivity` threw
+      SecurityException, which reads as "the feature does not work" rather than as "a line is missing
+      here". Nothing could have caught it off-device: the validator and the binder are both correct,
+      and a permission is only enforced when an intent is actually started.
+
+      This is an install-time (`normal`) permission, so declaring it IS granting it — there is no
+      runtime dialog for it, and a UI that offers to ask for it would be describing something that
+      cannot happen.
+
+      Declared in the APP rather than the library on purpose: which actions to permit is the
+      application's decision, and an SDK that silently added alarm permissions to every consumer would
+      be claiming a capability on their behalf.
+    -->
+    <uses-permission android:name="com.android.alarm.permission.SET_ALARM" />
+
+    <application
+        android:allowBackup="true"
+        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:fullBackupContent="@xml/backup_rules"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:largeHeap="true"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.MobileTransformersApp"
+        tools:targetApi="31">
+        <!--
+          `.TrainingScreen` and `.InferenceScreen` were declared here long after the classes behind
+          them were deleted in the facade rewrite. A manifest naming activities that do not exist is
+          a crash waiting for whoever first tries to start one, and it misdescribes the app: this is
+          a single-activity Compose app, and its screens are composables, not activities.
+        -->
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/model_catalog.json b/android/MobileTransformers/MobileTransformersApp/src/main/assets/model_catalog.json
new file mode 100644
index 0000000..1ac9713
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/model_catalog.json
@@ -0,0 +1,100 @@
+{
+  "_comment": [
+    "The model catalog the Models screen offers. Adding a model is editing this file — no code.",
+    "",
+    "Entries must name a repo that holds an EXPORTED MobileTransformers package (one carrying a",
+    "mobiletransformers_manifest.json at its root), not a plain Hugging Face model. `fromPretrained`",
+    "reads the manifest first to plan the download, so a base HF repo id fails at the first request.",
+    "Produce one with: mobiletransformers export --model <hf-id> --output <dir> [--train] [--rag]",
+    "then push it to the Hub — or run `make publish-catalog`, which exports, gate-checks and pushes",
+    "this whole shelf and is the producer these entries are kept in sync with.",
+    "",
+    "Set published=false for a package that is not on the Hub yet: the entry stays visible with a",
+    "badge and a disabled Install, which is more useful than an entry that 404s on tap.",
+    "",
+    "approxSizeMb is the INFERENCE GROUP alone, and every figure below is measured off the pushed",
+    "package's manifest (sum of fileSizes under inference/ plus the tokenizer), not estimated.",
+    "Requesting train or rag adds to it — the rag group is ~91 MB for every decoder here, because it",
+    "is the same all-MiniLM-L6-v2 embedder in each."
+  ],
+  "models": [
+    {
+      "repoId": "mobiletransformers/SmolLM2-135M-Instruct",
+      "displayName": "SmolLM2 135M Instruct",
+      "description": "The smallest useful chat model here, and the one every parity check is measured against. Fastest to pull and fastest to train, so it is the right first model on a new device.",
+      "baseModel": "HuggingFaceTB/SmolLM2-135M-Instruct",
+      "task": "text-generation",
+      "approxSizeMb": 663,
+      "features": ["inference", "train", "rag"],
+      "peft": "lora",
+      "requiresToken": true,
+      "published": true,
+      "recommendedFor": "First run, Chat, and the fastest training loop"
+    },
+    {
+      "repoId": "mobiletransformers/functiongemma-270m-it",
+      "displayName": "FunctionGemma 270M",
+      "description": "Gemma-3 270M tuned for function calling: it turns an instruction into a structured call that the app's allowlist then validates before anything runs. Small enough to fine-tune on a phone in minutes.",
+      "baseModel": "google/functiongemma-270m-it",
+      "task": "text-generation",
+      "approxSizeMb": 3557,
+      "features": ["inference", "train"],
+      "peft": "lora",
+      "requiresToken": false,
+      "published": true,
+      "recommendedFor": "Tool calls, and the on-device fine-tuning demo"
+    },
+    {
+      "repoId": "mobiletransformers/gemma-3-270m-it",
+      "displayName": "Gemma 3 270M Instruct",
+      "description": "The MARS entry. Multi-Adapter Rank Sharing is this project's own fine-tuning method: instead of one adapter per layer, layers share a down-projection, so the trainable parameter count grows with rank rather than with depth — 279,936 parameters here against a 268M backbone. Pick this one to see what the research is actually about.",
+      "baseModel": "google/gemma-3-270m-it",
+      "task": "text-generation",
+      "approxSizeMb": 1814,
+      "features": ["inference", "train"],
+      "peft": "mars",
+      "requiresToken": true,
+      "published": true,
+      "recommendedFor": "MARS, and comparing a shared-adapter fine-tune against LoRA"
+    },
+    {
+      "repoId": "mobiletransformers/Qwen2.5-0.5B-Instruct",
+      "displayName": "Qwen2.5 0.5B Instruct",
+      "description": "A noticeably more fluent decoder at roughly four times SmolLM2's size. Generation on a mid-range phone is a few tokens per second — worth seeing, because it is the honest cost of the extra quality.",
+      "baseModel": "Qwen/Qwen2.5-0.5B-Instruct",
+      "task": "text-generation",
+      "approxSizeMb": 2554,
+      "features": ["inference", "train", "rag"],
+      "peft": "lora",
+      "requiresToken": true,
+      "published": true,
+      "recommendedFor": "Chat quality, and the memory ceiling on smaller devices"
+    },
+    {
+      "repoId": "mobiletransformers/all-MiniLM-L6-v2",
+      "displayName": "all-MiniLM-L6-v2",
+      "description": "The sentence encoder behind retrieval, and the only entry that is useful on its own without a decoder: install it alone and the app shows Models, Retrieval, Train and Federated, hiding Chat because an embedding model has no generative head. Exported as text-classification rather than feature-extraction — that is what makes an encoder trainable at all — so it also carries a classification head. That head is randomly initialised with LABEL_0/LABEL_1 labels, which is why Classify stays hidden: the head is the part fine-tuning is meant to learn, not something the checkpoint ships.",
+      "baseModel": "sentence-transformers/all-MiniLM-L6-v2",
+      "task": "text-classification",
+      "approxSizeMb": 94,
+      "features": ["inference", "train", "rag"],
+      "peft": "lora",
+      "requiresToken": true,
+      "published": true,
+      "recommendedFor": "Retrieval on its own, and the smallest possible training run"
+    },
+    {
+      "repoId": "mobiletransformers/distilbert-sst2-english",
+      "displayName": "DistilBERT SST-2",
+      "description": "A sentiment classifier with real trained labels (NEGATIVE / POSITIVE), so the Classify screen has something to say from the first tap — unlike the MiniLM encoder, whose head is randomly initialised. An encoder, so Chat and Retrieval are hidden for it; fine-tuning it on your own labels is the point.",
+      "baseModel": "distilbert-base-uncased-finetuned-sst-2-english",
+      "task": "text-classification",
+      "approxSizeMb": 270,
+      "features": ["inference", "train"],
+      "peft": "lora",
+      "requiresToken": true,
+      "published": true,
+      "recommendedFor": "Classify, and fine-tuning a classifier on device"
+    }
+  ]
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_schema.json b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_schema.json
new file mode 100644
index 0000000..7518d18
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_schema.json
@@ -0,0 +1,22 @@
+[
+  {
+    "actionName": "set_alarm",
+    "parameters": {"time": "string"},
+    "allowedIntent": "android.intent.action.SET_ALARM",
+    "validationRules": {"time": "HH:mm"},
+    "privacyClass": "harmless-demo"
+  },
+  {
+    "actionName": "set_timer",
+    "parameters": {"seconds": "string"},
+    "allowedIntent": "android.intent.action.SET_TIMER",
+    "validationRules": {"seconds": "/[0-9]{1,4}/"},
+    "privacyClass": "harmless-demo"
+  },
+  {
+    "actionName": "open_wifi_settings",
+    "parameters": {},
+    "allowedIntent": "android.settings.WIFI_SETTINGS",
+    "privacyClass": "harmless-demo"
+  }
+]
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_templates.json b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_templates.json
new file mode 100644
index 0000000..730768e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_action_templates.json
@@ -0,0 +1,5 @@
+{
+  "set_alarm": ["wake me at {time}", "set an alarm for {time}", "alarm at {time} please", "get me up at {time}"],
+  "set_timer": ["timer for {seconds} seconds", "count down {seconds} seconds", "set a {seconds} second timer"],
+  "open_wifi_settings": ["open wifi settings", "show me the wifi settings", "take me to wi-fi settings"]
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_mobile_actions.jsonl b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_mobile_actions.jsonl
new file mode 100644
index 0000000..b34af8c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_mobile_actions.jsonl
@@ -0,0 +1,48 @@
+{"prompt": "set a 481 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"481\"}}"}
+{"prompt": "set an alarm for 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "get me up at 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "get me up at 12:45", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"12:45\"}}"}
+{"prompt": "timer for 311 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"311\"}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "open wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "wake me at 08:00", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"08:00\"}}"}
+{"prompt": "count down 589 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"589\"}}"}
+{"prompt": "set an alarm for 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "set a 600 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"600\"}}"}
+{"prompt": "count down 442 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"442\"}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "set a 66 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"66\"}}"}
+{"prompt": "set an alarm for 08:00", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"08:00\"}}"}
+{"prompt": "get me up at 18:20", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"18:20\"}}"}
+{"prompt": "set an alarm for 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "count down 215 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"215\"}}"}
+{"prompt": "get me up at 08:00", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"08:00\"}}"}
+{"prompt": "timer for 190 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"190\"}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "open wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "open wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "set a 69 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"69\"}}"}
+{"prompt": "wake me at 12:45", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"12:45\"}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "wake me at 07:30", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"07:30\"}}"}
+{"prompt": "set a 578 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"578\"}}"}
+{"prompt": "wake me at 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "count down 469 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"469\"}}"}
+{"prompt": "open wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "set a 565 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"565\"}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "timer for 659 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"659\"}}"}
+{"prompt": "show me the wifi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "take me to wi-fi settings", "completion": "{\"actionName\": \"open_wifi_settings\", \"parameters\": {}}"}
+{"prompt": "set an alarm for 18:20", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"18:20\"}}"}
+{"prompt": "wake me at 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "set a 701 second timer", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"701\"}}"}
+{"prompt": "timer for 818 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"818\"}}"}
+{"prompt": "wake me at 06:15", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"06:15\"}}"}
+{"prompt": "timer for 386 seconds", "completion": "{\"actionName\": \"set_timer\", \"parameters\": {\"seconds\": \"386\"}}"}
+{"prompt": "wake me at 07:30", "completion": "{\"actionName\": \"set_alarm\", \"parameters\": {\"time\": \"07:30\"}}"}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_device.md b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_device.md
new file mode 100644
index 0000000..6cd2b64
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_device.md
@@ -0,0 +1,39 @@
+# Heat, battery and when work actually runs
+
+## Thermal throttling
+
+A phone has no fan. Sustained compute raises the die temperature until the governor reduces clock
+speeds, so a long training run gets slower the longer it lasts — the first few hundred steps are not
+representative of the last few hundred. The SDK samples the thermal status and pauses when the device
+reports a severe state, which is slower than pushing through but avoids the system killing the app
+outright.
+
+## Charging and battery
+
+Scheduled training is constrained to run while charging by default. This is not only about battery
+level: charging usually means the phone is stationary and unattended, which is exactly when a
+multi-minute compute job is acceptable. A run started on battery competes with whatever the user is
+actually doing.
+
+## Doze, and why a start time is a floor
+
+Android batches deferrable background work and can hold it during Doze, so a scheduled run promises a
+*minimum* delay rather than an appointment. Asking for a start in fifteen minutes means "not before
+fifteen minutes", and the actual start may be considerably later if the screen is off and the device
+is idle. An exact wall-clock start would require the exact-alarm permission, which the Play Store
+restricts to alarm clocks and calendar reminders — so the honest design is to state the limitation
+rather than work around it.
+
+## Memory
+
+Model weights are memory-mapped rather than read into the heap, so the size of a package on disk is a
+poor predictor of whether it will run. A three-and-a-half gigabyte inference directory works on a
+device with two and a half gigabytes available, because the pages are backed by the file rather than
+by the heap. Training is different: the optimizer state and the activations are genuinely allocated,
+and that is where a run fails.
+
+## Foreground work
+
+Long-running training runs as a foreground service with a persistent notification showing the current
+step and loss. This is mandatory rather than decorative — Android will not let a background process
+hold the CPU for minutes at a time, and a visible notification is the price of being allowed to.
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_document.md b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_document.md
new file mode 100644
index 0000000..4a6c818
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_document.md
@@ -0,0 +1,40 @@
+# MobileTransformers — on-device retrieval notes
+
+A short document with a few clearly distinct facts, so a retrieval result is easy to judge by eye.
+Ask the Chat tab something answerable only from here (with grounding on) and the source cards should
+show the matching paragraph.
+
+## Packages
+
+A MobileTransformers package is manifest-first. `mobiletransformers_manifest.json` is read before any
+large file is fetched, and it names every file's SHA-256, so a download can be verified rather than
+trusted. The manifest's `downloadPlan` splits a package into feature groups — `core`, `inference`,
+`train`, `rag` and `genai` — and a client fetches only the groups it asked for.
+
+## Weights
+
+Trainable weights ship as ONNX external initializers, one file per tensor, alongside a single
+immutable blob holding the frozen quantized base. On-device merging overwrites the per-tensor files
+with an atomic rename and a checksum. There is no graph rewrite and no separate merged model.
+
+## Engines
+
+Two inference engines consume the same package: the native ONNX Runtime engine, which is the
+guaranteed floor, and the ONNX Runtime GenAI engine, which is selectable when the package ships a
+`genai_config.json` and the device probe succeeds. Asking for GenAI where it is unavailable fails
+rather than silently falling back, because being given a different engine than the one named is a
+wrong answer rather than a graceful degradation.
+
+## Retrieval
+
+Documents are chunked, embedded with the encoder shipped in the package's `rag` group, and stored in
+an on-device vector database using cosine similarity. Retrieval never leaves the phone. The assembled
+prompt is returned alongside the answer, because an app that cannot show what the model was actually
+asked cannot debug a bad grounded answer.
+
+## Training
+
+Fine-tuning runs on the device against a LoRA adapter, so only a small fraction of the parameters
+carry gradients. Cancelling is cooperative: the native loop stops at the next step boundary and writes
+a checkpoint, which makes a cancelled run resumable rather than lost. Scheduled training runs in
+charging-and-idle chunks, and each chunk re-evaluates its constraints before continuing.
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_privacy.md b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_privacy.md
new file mode 100644
index 0000000..743c8de
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_privacy.md
@@ -0,0 +1,35 @@
+# Privacy, consent, and what leaves the device
+
+## The default
+
+Nothing leaves the phone. Generation, retrieval, ingestion and training all run locally against files
+in the app's own storage. There is no inference server, and no prompt or document is transmitted
+anywhere as part of normal use. The only network traffic is downloading a model package.
+
+## Federated learning
+
+Federated learning is the one feature that sends anything out, and it sends the smallest possible
+thing: the adapter factors produced by local training, plus aggregate metrics such as the number of
+examples seen and the average loss. **Training examples never leave the device.** The documents you
+ingested, the prompts you typed and the dataset you trained on all stay local; what travels is a set
+of small matrices describing how the model changed.
+
+## Consent is checked before any tensor is read
+
+Federation is disabled by default and must be switched on deliberately by the application that ships
+the SDK. Beyond that build-time switch, a round refuses to start unless consent has been granted, the
+gateway address uses TLS, and an authentication token is present. Those three checks happen before any
+adapter tensor is opened, so a misconfigured round fails without ever having touched the weights.
+
+## Rounds
+
+A round imports the current global adapter, trains locally on this device's own data, and exports the
+difference. Round zero imports nothing, because a device has to be able to join a group that has not
+published an aggregate yet. The round returns the bytes it would upload rather than uploading them
+itself — handing them to a gateway is a separate, deliberate act by the application.
+
+## Aggregation
+
+The server averages the updates it receives across participating devices, weighted by how many
+examples each one trained on. No individual device's contribution is stored as such, and a device that
+drops out mid-round is simply absent from that average rather than blocking it.
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_training.md b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_training.md
new file mode 100644
index 0000000..cd73496
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/assets/sample_rag_training.md
@@ -0,0 +1,38 @@
+# Fine-tuning a model on the phone itself
+
+## Why adapters instead of full fine-tuning
+
+Training every weight of a language model on a phone is not a memory problem you can optimise your
+way out of — the optimizer state alone is several times the size of the model. Parameter-efficient
+fine-tuning trains a small number of extra weights and leaves the original ones frozen, which turns an
+impossible job into one that fits in a few hundred megabytes.
+
+## LoRA
+
+LoRA adds two thin matrices beside a frozen projection. Instead of learning a full update to a
+weight of shape `d x k`, it learns `A` of shape `d x r` and `B` of shape `r x k`, where the rank `r`
+is small — 8 or 16 is typical. The product `BA` is the update. Because `r` is tiny, the number of
+trained parameters drops by three or four orders of magnitude: a 135-million-parameter model trains
+roughly 370 thousand weights.
+
+## MARS
+
+Multi-Adapter Rank Sharing goes further by sharing adapter factors across layers rather than giving
+every layer its own pair. The parameter count then grows with the rank rather than with the depth of
+the network, so a deeper model costs almost nothing extra to adapt. This is the technique the
+MobileTransformers research contributes, and it is the one to pick when memory is the binding
+constraint rather than accuracy.
+
+## Merging
+
+After training, the adapter can be merged back into the base weights so that inference costs exactly
+what it did before — no extra matrices, no extra latency. Merging happens on the device, tensor by
+tensor, with an atomic rename and a checksum per file. Nothing is rewritten in the graph.
+
+## What a training run costs
+
+A run is bounded by three numbers you choose: how many steps, how large a batch, and how long a
+sequence. Sequence length dominates memory, because attention grows with its square. If a run is
+killed by the operating system, the sequence length is the first knob to turn down, then the batch
+size. An out-of-memory death on Android is a SIGKILL, so there is no exception and no stack trace —
+only the process disappearing.
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ActionAllowlist.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ActionAllowlist.kt
new file mode 100644
index 0000000..d7afbc3
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ActionAllowlist.kt
@@ -0,0 +1,76 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.agent.ActionSpec
+
+/**
+ * Everything this app will let a model ask for, and the permission each one needs.
+ *
+ * This object *is* the security boundary. A model selects an action by name; it can never name an
+ * intent, because intent strings appear only here. So the set of intents any model output can reach
+ * is fixed when this list is written, and widening it is a deliberate edit to this file rather than
+ * anything a model can talk its way into.
+ *
+ * It also feeds the training corpus: `mobiletransformers agent-dataset` writes this same declaration
+ * out as `action_schema.json`, so the examples a model is fine-tuned on and the boundary that judges
+ * its output are provably one value rather than two lists that agree today.
+ *
+ * ### Why permissions live here
+ *
+ * An action and the permission its intent needs are one fact. `set_alarm` without
+ * `com.android.alarm.permission.SET_ALARM` is an entry that always fails: the model emits a correct
+ * call, the validator accepts it, and `startActivity` throws `SecurityException` at the last possible
+ * moment — which a user reads as "the feature is broken", not as "a line is missing from the
+ * manifest". That is exactly what happened before these were declared.
+ *
+ * Android has two kinds and they behave differently:
+ *
+ * - **Install-time (`normal`)** — `SET_ALARM`, the only kind used here. Granted when the app is
+ *   installed, provided the manifest declares it. There is no dialog and there never will be, so a UI
+ *   that promises to "ask" for it is lying, and a missing one is a manifest bug rather than a user
+ *   decision.
+ * - **Runtime (`dangerous`)** — a system dialog the user can refuse. The app handles these generically
+ *   ([PermissionGate]) so adding such an action needs no new plumbing.
+ *
+ * **No action here needs a runtime permission, and that is not an oversight.** Intent-based actions
+ * delegate the sensitive work to the target app, which enforces its own permissions behind its own UI
+ * — that is the point of the design. So the benign actions worth showcasing (an alarm, a timer, a
+ * settings screen) are all install-time, and manufacturing a dangerous one purely to make a dialog
+ * appear would be a demo of nothing. The app's real runtime-permission prompt is `POST_NOTIFICATIONS`,
+ * requested when a training run starts.
+ *
+ * Every permission named here must also be declared in `AndroidManifest.xml`; the manifest is what
+ * grants the install-time kind and what makes the runtime kind requestable at all.
+ */
+object ActionAllowlist {
+
+    /** Required by both `SET_ALARM` and `SET_TIMER`. Install-time: declared, never prompted for. */
+    const val ALARM_PERMISSION = "com.android.alarm.permission.SET_ALARM"
+
+    val ENTRIES: List<ActionSpec> = listOf(
+        ActionSpec(
+            actionName = "set_alarm",
+            parameters = mapOf("time" to "string"),
+            allowedIntent = "android.intent.action.SET_ALARM",
+            validationRules = mapOf("time" to "HH:mm"),
+            privacyClass = "harmless-demo",
+            requiredPermissions = listOf(ALARM_PERMISSION),
+        ),
+        ActionSpec(
+            actionName = "set_timer",
+            parameters = mapOf("seconds" to "string"),
+            allowedIntent = "android.intent.action.SET_TIMER",
+            validationRules = mapOf("seconds" to "/[0-9]{1,4}/"),
+            privacyClass = "harmless-demo",
+            requiredPermissions = listOf(ALARM_PERMISSION),
+        ),
+        ActionSpec(
+            actionName = "open_wifi_settings",
+            parameters = emptyMap(),
+            allowedIntent = "android.settings.WIFI_SETTINGS",
+            privacyClass = "harmless-demo",
+        ),
+    )
+
+    /** Every permission any allowed action can need — what the manifest must declare. */
+    val ALL_PERMISSIONS: Set<String> = ENTRIES.flatMap { it.requiredPermissions }.toSet()
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppConfig.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppConfig.kt
new file mode 100644
index 0000000..642f9bb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppConfig.kt
@@ -0,0 +1,121 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * The knobs the Configuration screen edits and every other screen consumes.
+ *
+ * The old app kept ~45 fields spread over `ORTGenerationConfig`, `ORTTrainingConfig`, `ORTRagConfig`,
+ * `SamplingOptions`, `DeviceOptions` and `SchedulerConfig`. This holds the **public** equivalents and
+ * nothing else, which is the whole point of the rewrite: if a setting the old app could express is not
+ * reachable through `GenerationConfig`/`TrainConfig`/`RagConfig`/`DatasetConfig`, that is a facade gap
+ * to record against the facade — not a reason to reach for an `ORT*` type.
+ */
+object AppConfig {
+    private val _generation = MutableStateFlow(GenerationConfig())
+    val generation: StateFlow<GenerationConfig> = _generation.asStateFlow()
+
+    private val _train = MutableStateFlow(TrainConfig())
+    val train: StateFlow<TrainConfig> = _train.asStateFlow()
+
+    /**
+     * The SDK default with a smaller [RagConfig.topK], and the difference is felt rather than read.
+     *
+     * `topK = 10` at the SDK's `chunkSize = 512` assembles roughly 5,000 characters of context, so a
+     * grounded turn on a phone spends most of a minute in prefill before it can emit a token — for
+     * ten passages of which the tail is usually irrelevant, because `minScore` defaults to no floor.
+     * Four keeps the sources list readable and the wait watchable, which is what this app is for.
+     *
+     * Not changed in the SDK: `topK` is a documented default and a caller with a server-class budget
+     * should keep getting ten. Raise it on the Configuration screen, which edits exactly this.
+     */
+    private val defaultRag = RagConfig(topK = 4)
+
+    private val _rag = MutableStateFlow(defaultRag)
+    val rag: StateFlow<RagConfig> = _rag.asStateFlow()
+
+    private val _dataset = MutableStateFlow(DatasetConfig())
+    val dataset: StateFlow<DatasetConfig> = _dataset.asStateFlow()
+
+    /**
+     * Execution-provider and memory settings, applied to every config that carries them.
+     *
+     * `DeviceConfig` is a field on `GenerationConfig`, `TrainConfig` **and** `RagConfig`, and no
+     * screen edited any of the three — so the execution provider, core profile and memory profile
+     * were part of the public surface and completely unreachable from the app that exists to
+     * demonstrate it. Held once and fanned out on write, because "run inference on XNNPACK but train
+     * on CPU" is not a distinction a showcase should invite by accident; a caller that genuinely
+     * wants it sets the field per config, which the SDK still allows.
+     */
+    private val _device = MutableStateFlow(DeviceConfig())
+    val device: StateFlow<DeviceConfig> = _device.asStateFlow()
+
+    /**
+     * The PEFT method to apply before the next training run.
+     *
+     * `MobileTransformerModel.applyPeft` validates a selection against what the installed package
+     * supports, and nothing in the app ever called it — so the one API that reports a PEFT mismatch
+     * before a run rather than during it had no worked example.
+     */
+    private val _peft = MutableStateFlow<PeftConfig>(PeftConfig.Lora())
+    val peft: StateFlow<PeftConfig> = _peft.asStateFlow()
+
+    fun updateGeneration(block: (GenerationConfig) -> GenerationConfig) {
+        _generation.value = block(_generation.value)
+    }
+
+    fun updateTrain(block: (TrainConfig) -> TrainConfig) {
+        _train.value = block(_train.value)
+    }
+
+    fun updateRag(block: (RagConfig) -> RagConfig) {
+        _rag.value = block(_rag.value)
+    }
+
+    fun updateDataset(block: (DatasetConfig) -> DatasetConfig) {
+        _dataset.value = block(_dataset.value)
+    }
+
+    /**
+     * Set the device options and fan them out to every config that carries a [DeviceConfig].
+     *
+     * **Except the memory profile for training.** `TrainConfig` deliberately defaults to
+     * `MemoryConfigId.LOW_MEM` — ORT's arena and memory-pattern planner take a 270M LoRA run to
+     * ~3.4 GB and get the app killed — and a blanket fan-out would silently put `HIGH_PERF` back the
+     * first time anyone touched the Device tab, reintroducing the crash from a screen that says
+     * nothing about training. The rest (execution provider, core profile, profiling) fans out as
+     * before; a caller who genuinely wants a high-performance training allocator sets it on
+     * `TrainConfig` directly.
+     */
+    fun updateDevice(block: (DeviceConfig) -> DeviceConfig) {
+        val next = block(_device.value)
+        _device.value = next
+        _generation.value = _generation.value.copy(device = next)
+        _train.value = _train.value.copy(
+            device = next.copy(memoryConfigId = _train.value.device.memoryConfigId),
+        )
+        _rag.value = _rag.value.copy(device = next)
+    }
+
+    fun updatePeft(value: PeftConfig) {
+        _peft.value = value
+    }
+
+    /** Restore every section to what a fresh launch uses — see [defaultRag] for the one deviation. */
+    fun reset() {
+        _generation.value = GenerationConfig()
+        _train.value = TrainConfig()
+        _rag.value = defaultRag
+        _dataset.value = DatasetConfig()
+        _device.value = DeviceConfig()
+        _peft.value = PeftConfig.Lora()
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppSnackbar.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppSnackbar.kt
new file mode 100644
index 0000000..5663029
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/AppSnackbar.kt
@@ -0,0 +1,60 @@
+package com.martinkorelic.mobiletransformers.app
+
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+
+/**
+ * One place for "something just happened", shown as a transient banner at the top of every screen.
+ *
+ * ### Why the app needed one
+ *
+ * Every outcome used to land in a card somewhere down the screen the user happened to be on — and
+ * most of the interesting ones happen *while they are somewhere else*. Starting a pull on Models and
+ * switching to Chat meant the download finishing, or failing, in silence. Ingest, merge, schedule and
+ * every SDK refusal had the same shape: state written into a `ui.message` field that only one screen
+ * renders, often below the fold.
+ *
+ * A shared flow rather than per-screen state because the events outlive the screen that caused them.
+ *
+ * ### Why events are dropped rather than queued
+ *
+ * A snackbar is a courtesy, never the only record: every one of these outcomes is also visible in the
+ * durable UI — the model bar, the events list, the error card. Suspending a training loop because a
+ * banner has nowhere to go would be exactly backwards, so the buffer drops its oldest entry instead.
+ */
+object AppSnackbar {
+
+    private val _events = MutableSharedFlow<SnackbarEvent>(
+        extraBufferCapacity = 8,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+    val events: SharedFlow<SnackbarEvent> = _events.asSharedFlow()
+
+    fun info(message: String) = emit(SnackbarEvent(message, Severity.Info))
+
+    fun success(message: String) = emit(SnackbarEvent(message, Severity.Success))
+
+    /**
+     * A failure the user should see wherever they are.
+     *
+     * The SDK's exception messages name the missing feature or artifact, so they are passed through
+     * verbatim; paraphrasing them to fit a banner is how the diagnosis gets lost.
+     */
+    fun error(message: String) = emit(SnackbarEvent(message, Severity.Error))
+
+    private fun emit(event: SnackbarEvent) {
+        _events.tryEmit(event)
+    }
+
+    enum class Severity { Info, Success, Error }
+
+    data class SnackbarEvent(
+        val message: String,
+        val severity: Severity,
+        /** Optional label for a single action, e.g. "Cancel". */
+        val actionLabel: String? = null,
+        val onAction: (() -> Unit)? = null,
+    )
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/MainActivity.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/MainActivity.kt
new file mode 100644
index 0000000..2ee8c2a
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/MainActivity.kt
@@ -0,0 +1,302 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.Chat
+import androidx.compose.material.icons.outlined.Search
+import androidx.compose.material.icons.outlined.Download
+import androidx.compose.material.icons.outlined.Hub
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.material.icons.outlined.Label
+import androidx.compose.material.icons.outlined.Menu
+import androidx.compose.material.icons.outlined.School
+import androidx.compose.material.icons.outlined.Tune
+import androidx.compose.material3.DrawerValue
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalDrawerSheet
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.NavigationDrawerItem
+import androidx.compose.material3.NavigationDrawerItemDefaults
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Snackbar
+import androidx.compose.material3.SnackbarDuration
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.SnackbarResult
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.rememberDrawerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.martinkorelic.mobiletransformers.app.ui.theme.AppTheme
+import com.martinkorelic.mobiletransformers.app.ui.theme.AppThemedContent
+import com.martinkorelic.mobiletransformers.app.views.AboutScreen
+import com.martinkorelic.mobiletransformers.app.views.ChatScreen
+import com.martinkorelic.mobiletransformers.app.views.ClassifyScreen
+import com.martinkorelic.mobiletransformers.app.views.ConfigurationScreen
+import com.martinkorelic.mobiletransformers.app.views.ConfigurationTab
+import com.martinkorelic.mobiletransformers.app.views.FederatedScreen
+import com.martinkorelic.mobiletransformers.app.views.ModelBar
+import com.martinkorelic.mobiletransformers.app.views.ModelsScreen
+import com.martinkorelic.mobiletransformers.app.views.RetrievalScreen
+import com.martinkorelic.mobiletransformers.app.views.TrainScreen
+import kotlinx.coroutines.launch
+
+/**
+ * The MobileTransformers showcase app — **the reference example for the public SDK**.
+ *
+ * Every screen is a self-contained worked example of one capability, and every one of them talks to the
+ * library only through the public facade: `MobileTransformers.fromPretrained`,
+ * `MobileTransformerModel`, and the `config/` types. No `ORT*`, `*Native` or `*Repository` type appears
+ * anywhere in this module, and `tests/unit/test_guards.py::test_the_sample_app_uses_only_the_public_facade`
+ * fails the build if one does.
+ *
+ * That rule is the point of the app's existence. The previous version drove
+ * `LLMRepository`/`TrainingRepository`/`RagRepository`/`InferenceRepository` directly, which meant the
+ * public API the SDK shipped had never been exercised by anything — its ergonomics had never met a real
+ * screen, and there was no worked example of the interface every consumer is told to adopt.
+ *
+ * ### The shell
+ *
+ * Three parts, all of them global, because all three answer questions that arise on whichever screen
+ * the user happens to be on:
+ *
+ * - a **drawer** grouping the destinations by purpose, with each one saying why it is unusable when it
+ *   is (see [Destination.availability]) — replacing a `ScrollableTabRow` whose later tabs were
+ *   off-screen and whose dependency order was invisible;
+ * - a **[ModelBar]** pinned under the app bar, so "what is loaded, what can it do, is a pull running"
+ *   never requires navigating away from the question;
+ * - a **snackbar** fed by [AppSnackbar], so outcomes that complete while the user is elsewhere — a
+ *   download finishing, training failing — are not delivered to a screen nobody is looking at.
+ */
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            AppThemedContent(theme = AppTheme.FRI) {
+                // The SDK declares POST_NOTIFICATIONS but nothing requested it, so on API 33+ every
+                // foreground training notification was dropped by the system.
+                RequestNotificationPermissionOnce()
+                Surface(Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
+                    ShowcaseApp()
+                }
+            }
+        }
+    }
+}
+
+private val Destination.icon: ImageVector
+    get() = when (this) {
+        Destination.Models -> Icons.Outlined.Download
+        Destination.Chat -> Icons.AutoMirrored.Outlined.Chat
+    Destination.Retrieval -> Icons.Outlined.Search
+    Destination.Classify -> Icons.Outlined.Label
+        Destination.Train -> Icons.Outlined.School
+        Destination.Federated -> Icons.Outlined.Hub
+        Destination.Configuration -> Icons.Outlined.Tune
+        Destination.About -> Icons.Outlined.Info
+    }
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ShowcaseApp() {
+    var destination by remember { mutableStateOf(Destination.Models) }
+    // Which Configuration tab to open when something links into it (Chat's "Settings").
+    var configurationTab by remember { mutableStateOf(ConfigurationTab.Generation) }
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    val modelState by ModelHolder.state.collectAsState()
+    val download by ModelHolder.download.collectAsState()
+    val activity by ModelHolder.activity.collectAsState()
+
+    // Loading a classifier while sitting on Chat would leave the user on a screen that has just left
+    // the drawer, with no visible way back.
+    LaunchedEffect(modelState) { destination = redirectFor(destination, modelState) }
+
+    LaunchedEffect(Unit) {
+        AppSnackbar.events.collect { event ->
+            val result = snackbarHostState.showSnackbar(
+                message = event.message,
+                actionLabel = event.actionLabel,
+                // An error is the one kind worth making the user dismiss: it is the only one whose
+                // text they may need to read twice.
+                duration = if (event.severity == AppSnackbar.Severity.Error) {
+                    SnackbarDuration.Long
+                } else {
+                    SnackbarDuration.Short
+                },
+            )
+            if (result == SnackbarResult.ActionPerformed) event.onAction?.invoke()
+        }
+    }
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        drawerContent = {
+            ModalDrawerSheet {
+                DrawerContent(
+                    current = destination,
+                    modelState = modelState,
+                    onSelect = {
+                        destination = it
+                        scope.launch { drawerState.close() }
+                    },
+                )
+            }
+        },
+    ) {
+        Scaffold(
+            topBar = {
+                TopAppBar(
+                    title = {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            // The mark, not an `Icon`: `Icon` tints its payload with the current
+                            // content colour, which would flatten a full-colour logo to a solid
+                            // silhouette. `Image` draws it as authored, in both themes.
+                            Image(
+                                painter = painterResource(R.drawable.ic_logo),
+                                contentDescription = null, // decorative; the label beside it names the screen
+                                modifier = Modifier.size(28.dp),
+                            )
+                            Spacer(Modifier.width(12.dp))
+                            Text(destination.label)
+                        }
+                    },
+                    navigationIcon = {
+                        androidx.compose.material3.IconButton(
+                            onClick = { scope.launch { drawerState.open() } },
+                        ) { Icon(Icons.Outlined.Menu, contentDescription = "Open navigation drawer") }
+                    },
+                )
+            },
+            snackbarHost = {
+                // Top-anchored rather than Material's default bottom: the bottom of every screen here
+                // is where the primary controls live (Send, Start, the prompt field), and a banner
+                // that covers the button the user just pressed is worse than no banner.
+                Box(Modifier.fillMaxSize(), contentAlignment = Alignment.TopCenter) {
+                    SnackbarHost(snackbarHostState) { data ->
+                        Snackbar(snackbarData = data, modifier = Modifier.padding(8.dp))
+                    }
+                }
+            },
+        ) { padding ->
+            Column(Modifier.fillMaxSize().padding(padding)) {
+                ModelBar(
+                    state = modelState,
+                    activity = activity,
+                    download = download,
+                    onUnload = { scope.launch { ModelHolder.close() } },
+                    onGoToModels = { destination = Destination.Models },
+                )
+
+                when (destination) {
+                    Destination.Models -> ModelsScreen(viewModel())
+                    Destination.Chat -> ChatScreen(
+                        viewModel(),
+                        // "Settings" in Chat means the generation knobs, which live here.
+                        onOpenSettings = {
+                            configurationTab = ConfigurationTab.Generation
+                            destination = Destination.Configuration
+                },
+            )
+                    Destination.Retrieval -> RetrievalScreen(viewModel())
+                    Destination.Classify -> ClassifyScreen(viewModel())
+                    Destination.Train -> TrainScreen(viewModel())
+                    Destination.Federated -> FederatedScreen(viewModel())
+                    Destination.Configuration -> ConfigurationScreen(viewModel(), configurationTab)
+                    Destination.About -> AboutScreen(onGoToModels = { destination = Destination.Models })
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun DrawerContent(
+    current: Destination,
+    modelState: ModelState,
+    onSelect: (Destination) -> Unit,
+) {
+    Column(
+        Modifier.fillMaxWidth().verticalScroll(rememberScrollState()).padding(vertical = 12.dp),
+        verticalArrangement = Arrangement.spacedBy(2.dp),
+    ) {
+        Text(
+            "MobileTransformers",
+            style = MaterialTheme.typography.titleMedium,
+            modifier = Modifier.padding(horizontal = 28.dp, vertical = 12.dp),
+        )
+
+        val visible = visibleDestinations(modelState)
+        NavGroup.entries.forEach { group ->
+            val items = visible.filter { it.group == group }
+            if (items.isEmpty()) return@forEach
+
+            Text(
+                group.label,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(start = 28.dp, top = 16.dp, bottom = 4.dp),
+            )
+            items.forEach { d ->
+                val availability = d.availability(modelState)
+                val blocked = availability as? Availability.Blocked
+                NavigationDrawerItem(
+                    icon = { Icon(d.icon, contentDescription = null) },
+                    label = {
+                        Column {
+                            Text(d.label)
+                            // The reason IS the instruction — "load a model first", "pull one with
+                            // Training requested". Hiding it behind a tap means the user learns it
+                            // from an empty state after choosing wrongly.
+                            blocked?.let {
+                                Text(
+                                    it.reason,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                )
+                            }
+                        }
+                    },
+                    selected = d == current,
+                    // Still selectable when blocked: the destination explains itself far better than
+                    // a greyed-out row, and every screen already renders an honest empty state.
+                    onClick = { onSelect(d) },
+                    modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding),
+                )
+            }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelCatalog.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelCatalog.kt
new file mode 100644
index 0000000..7b0d061
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelCatalog.kt
@@ -0,0 +1,101 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.content.Context
+import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+
+/**
+ * The curated list of models the app offers, loaded from `assets/model_catalog.json`.
+ *
+ * ### Why a catalog exists at all
+ *
+ * The only way in was a free-text repo id field pre-filled with one example. That asks a new user to
+ * already know the answer to the question the app exists to answer, and it fails in a particularly
+ * unhelpful way: a plain Hugging Face model id looks exactly like a valid entry, is accepted, and then
+ * fails on the manifest request — because `fromPretrained` pulls an **exported package**, not a
+ * base model. Typing `google/gemma-3-270m` produces a 404 that says nothing about that distinction.
+ *
+ * A catalog turns the first step into a choice among things known to work, and carries the size and
+ * the feature groups next to each one so the cost of a multi-gigabyte pull is visible before it starts.
+ *
+ * ### Why a bundled asset rather than a Hub query
+ *
+ * The catalog must render with no network and no credentials — it is the first screen, and a user
+ * with neither still needs to see what the app is for. Listing an organisation over the Hub API also
+ * returns nothing for private or gated repos, which is what these are, so the live version of this
+ * would be reliably empty exactly where it matters. Editing one JSON file to add a model is the
+ * feature, not a limitation.
+ */
+object ModelCatalog {
+
+    private const val ASSET = "model_catalog.json"
+
+    private data class Wire(@SerializedName("models") val models: List<Entry> = emptyList())
+
+    data class Entry(
+        @SerializedName("repoId") val repoId: String = "",
+        @SerializedName("displayName") val displayName: String = "",
+        @SerializedName("description") val description: String = "",
+        /** The upstream model this package was exported from — provenance, never a load key. */
+        @SerializedName("baseModel") val baseModel: String = "",
+        @SerializedName("task") val task: String = "",
+        /** Inference group only; requesting train or rag adds to it. */
+        @SerializedName("approxSizeMb") val approxSizeMb: Int = 0,
+        @SerializedName("features") val features: List<String> = emptyList(),
+        @SerializedName("requiresToken") val requiresToken: Boolean = false,
+        /**
+         * Whether this package is actually on the Hub yet.
+         *
+         * A catalog entry that 404s on tap is worse than no entry: the user cannot tell "not
+         * published" from "your token is wrong" from "the app is broken". Unpublished entries stay
+         * visible — they describe what the project supports — with Install disabled and the reason
+         * on the card.
+         */
+        @SerializedName("published") val published: Boolean = false,
+        @SerializedName("recommendedFor") val recommendedFor: String = "",
+        /**
+ * The fine-tuning technique this package was exported with — `lora`, `lora-xs`, `mars`.
+ *
+ * Shown on the card *before* installing, because it is part of what distinguishes one shelf
+ * entry from another: MARS is the project's own method, and picking the MARS package is the
+ * whole point of trying it. The loaded model reports the same thing from its manifest
+ * (`RuntimeCapabilities.peftMethods`), which is authoritative — this is the catalog's claim,
+ * and the two disagreeing means the catalog is stale.
+ */
+        @SerializedName("peft") val peft: String = "",
+    ) {
+        /** The feature groups to request when installing this entry, mapped to the SDK's enum. */
+        val modelFeatures: Set<ModelFeature>
+            get() = buildSet {
+                add(ModelFeature.Inference)
+                if ("train" in features) add(ModelFeature.Training)
+                if ("rag" in features) add(ModelFeature.Rag)
+            }
+
+        val supportsTraining: Boolean get() = "train" in features
+        val supportsRag: Boolean get() = "rag" in features
+
+        val sizeLabel: String
+            get() = if (approxSizeMb >= 1024) {
+                "~%.1f GB".format(approxSizeMb / 1024.0)
+            } else {
+                "~$approxSizeMb MB"
+            }
+    }
+
+    /**
+     * Read the bundled catalog.
+     *
+     * A malformed or missing asset yields an empty list rather than a crash: the free-text "Pull by
+     * id" tab is always available, so a broken catalog degrades the first screen instead of removing
+     * the app's only entry point.
+     */
+    fun load(context: Context): List<Entry> =
+        runCatching {
+            context.assets.open(ASSET).bufferedReader(Charsets.UTF_8).use { reader ->
+                Gson().fromJson(reader, Wire::class.java)?.models.orEmpty()
+            }
+        }.getOrDefault(emptyList())
+            .filter { it.repoId.isNotBlank() }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelHolder.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelHolder.kt
new file mode 100644
index 0000000..bbcad2c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ModelHolder.kt
@@ -0,0 +1,359 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.content.Context
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.MobileTransformers
+import com.martinkorelic.mobiletransformers.config.HubConfig
+import com.martinkorelic.mobiletransformers.hub.DownloadJob
+import com.martinkorelic.mobiletransformers.hub.PackageDownloadWorker
+import com.martinkorelic.mobiletransformers.packages.CacheIndex
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.io.File
+
+/**
+ * The one loaded [MobileTransformerModel], shared by every screen.
+ *
+ * ### Why a single holder
+ *
+ * A model owns a native inference session and, when training, a native training session. Loading the
+ * same package twice from two screens would open two sessions over one set of weights, which on device
+ * means either wasted RAM or a mutating package underneath a live reader. So the app loads once and
+ * every screen observes [state].
+ *
+ * ### Why this is the app's only load path
+ *
+ * Everything here goes through the public facade — `MobileTransformers.fromPretrained`,
+ * `MobileTransformers.installed`. No `ORT*`, `*Native` or `*Repository` type appears anywhere in this
+ * module; `tests/unit/test_guards.py::test_the_sample_app_uses_only_the_public_facade` enforces that,
+ * which is what makes "the sample app is a worked example of the public API" checkable rather than
+ * claimed.
+ */
+object ModelHolder {
+
+    /** Guards load/unload so two screens cannot race two native sessions into existence. */
+    private val lock = Mutex()
+
+    private val _state = MutableStateFlow<ModelState>(ModelState.None)
+    val state: StateFlow<ModelState> = _state.asStateFlow()
+
+    /** The installed packages, refreshed by the Models screen. */
+    private val _installed = MutableStateFlow<List<CacheIndex.InstalledPackage>>(emptyList())
+    val installed: StateFlow<List<CacheIndex.InstalledPackage>> = _installed.asStateFlow()
+
+    /**
+     * The in-flight pull, if any — held here rather than in the Models screen's ViewModel.
+     *
+     * A download is the app's longest-running operation and the user is free to navigate away from
+     * the screen that started it. Keeping the progress in that screen's state meant the model bar
+     * (and every other screen) had nothing to show, so leaving Models during a pull looked exactly
+     * like no pull running.
+     */
+    private val _download = MutableStateFlow<DownloadUi?>(null)
+    val download: StateFlow<DownloadUi?> = _download.asStateFlow()
+
+    /**
+     * What the model is doing right now, for the one indicator every screen shows.
+     *
+     * The status dot used to be painted from [ModelState] alone, which only distinguishes loaded from
+     * not-loaded — so a model mid-generation and a model sitting idle looked identical, and the
+     * question the dot exists to answer ("can I ask it something now?") had no answer anywhere in the
+     * app. The work itself happens in three different ViewModels, so the flag has to live with the
+     * model rather than with any one of them.
+     */
+    private val _activity = MutableStateFlow(ModelActivity.Idle)
+    val activity: StateFlow<ModelActivity> = _activity.asStateFlow()
+
+    /**
+     * Run [block] with [activity] set, restoring it afterwards on every path.
+     *
+     * Nested and concurrent work is not modelled: only one native session exists, and two screens
+     * cannot drive it at once. The `finally` matters more than the nesting — a cancelled generation
+     * that left the dot red would be worse than no dot.
+     */
+    suspend fun <T> withActivity(activity: ModelActivity, block: suspend () -> T): T {
+        _activity.value = activity
+        return try {
+            block()
+        } finally {
+            _activity.value = ModelActivity.Idle
+        }
+    }
+
+    fun refreshInstalled(context: Context) {
+        _installed.value = MobileTransformers.installed(context)
+    }
+
+    /**
+     * The Hub credentials to pull with, or `null` for an anonymous pull.
+     *
+     * `null` rather than `HubConfig(token = "")`: an empty token is not "no token", and sending an
+     * empty `Authorization: Bearer` header is a different request from sending none. [HubResolver]
+     * already treats blank as absent, and this keeps that decision in one place.
+     *
+     * See `BuildConfig.HF_TOKEN` in the app's `build.gradle.kts` for where the value comes from and
+     * why baking one into an APK is a development affordance rather than a shipping pattern.
+     */
+    private fun hubConfig(): HubConfig? =
+        BuildConfig.HF_TOKEN.takeIf { it.isNotBlank() }?.let { HubConfig(token = it) }
+
+    /** Whether this build carries a Hub token — surfaced by the Models screen, never the token itself. */
+    val hasHfToken: Boolean get() = BuildConfig.HF_TOKEN.isNotBlank()
+
+    /**
+ * Pull [repoId] in the background via WorkManager, then load it.
+     *
+ * ### Why this exists beside [load]
+ *
+ * [load] downloads inside the caller's coroutine, so the pull dies with the Activity — on a
+ * multi-gigabyte package that is most of an hour of transfer lost to a task switch.
+ * `PackageDownloadWorker` was written to solve exactly that and had **no caller**, so the capability
+ * shipped and was unreachable.
+ *
+ * The worker only downloads and installs. Loading still goes through
+ * `MobileTransformers.fromPretrained`, which finds the package already in the cache and opens it
+ * without touching the network — so there is one load path, not two.
+ *
+ * @param wifiOnly the worker's `requireUnmetered` constraint. **Default true, and visible in the
+ * UI on purpose**: a pull that silently never starts on mobile data is indistinguishable from a
+ * hang, which is the trap this switch exists to make legible.
+ */
+    suspend fun loadInBackground(
+        context: Context,
+        repoId: String,
+        engine: InferenceEngine = InferenceEngine.NATIVE,
+        features: Set<ModelFeature> = setOf(ModelFeature.Inference),
+        wifiOnly: Boolean = true,
+) {
+        val already = MobileTransformers.installed(context).any { it.repoId == repoId }
+        if (already) {
+            // Nothing to download; go straight to the shared load path rather than enqueueing a
+            // worker that would resolve a manifest and find every file already present.
+            load(context, repoId, engine, features)
+            return
+        }
+
+        _state.value = ModelState.Loading(repoId)
+        _activity.value = ModelActivity.Loading
+        AppSnackbar.info("Queued $repoId for download")
+
+        PackageDownloadWorker.enqueue(
+                context = context,
+                repoId = repoId,
+            cacheDir = File(context.filesDir.absolutePath),
+                features = features,
+            genai = engine == InferenceEngine.GENAI,
+            token = hubConfig()?.token,
+            requireUnmetered = wifiOnly,
+                    )
+
+        // `first { it.isTerminal }` rather than a plain collect: the flow stays open for the work's
+        // whole retained history, so a collector without a terminal condition never returns.
+        val finished = try {
+            PackageDownloadWorker.observe(context, repoId)
+.onEach { jobs -> jobs.lastOrNull()?.let { publish(it) } }
+.mapNotNull { jobs -> jobs.lastOrNull()?.takeIf { it.isTerminal } }
+            .first()
+        } finally {
+            _download.value = null
+        }
+
+        when (finished.state) {
+            DownloadJob.State.Finished -> load(context, repoId, engine, features)
+            DownloadJob.State.Cancelled -> {
+            _state.value = ModelState.None
+            _activity.value = ModelActivity.Idle
+                AppSnackbar.info("Download cancelled — it will resume where it stopped")
+        }
+            else -> {
+                val reason = finished.error ?: "download failed"
+            _state.value = ModelState.Failed(repoId, reason)
+            _activity.value = ModelActivity.Idle
+            AppSnackbar.error(reason)
+        }
+        }
+        }
+
+    /** Stop a background pull. Safe to call when none is running. */
+    fun cancelBackgroundDownload(context: Context, repoId: String) {
+        PackageDownloadWorker.cancel(context, repoId)
+        }
+
+    private fun publish(job: DownloadJob) {
+                    _download.value = DownloadUi(
+            // `WaitingForConstraints` is the state worth naming: with wifiOnly it means "waiting for
+            // Wi-Fi", an indefinite and entirely normal wait that otherwise reads as a stall.
+            phase = job.phase ?: job.state.name,
+            waitingForConstraints = job.state == DownloadJob.State.WaitingForConstraints,
+            filesDone = job.filesDone,
+            filesTotal = job.filesTotal,
+            path = "",
+            fraction = job.fraction?.toFloat(),
+            bytesDone = job.bytesDone,
+            bytesTotal = job.bytesTotal,
+            bytesPerSecond = job.bytesPerSecond.toDouble(),
+                    )
+        }
+
+    /**
+ * Load [repoId], pulling it from the Hub **in the caller's coroutine** when it is not installed.
+ *
+ * Requests Training as well as Inference only when the package can provide it — asking for a
+     * feature the package lacks fails closed at construction (that is the point of
+     * `FeatureNotInstalledException`), and a user who pulled an inference-only package should still
+     * get a working Chat screen rather than an error.
+ *
+ * Prefer [loadInBackground] when a download is possible: this one dies with its caller's scope.
+     */
+    suspend fun load(
+        context: Context,
+        repoId: String,
+        engine: InferenceEngine = InferenceEngine.NATIVE,
+        features: Set<ModelFeature> = setOf(ModelFeature.Inference),
+    ) = lock.withLock {
+        _state.value = ModelState.Loading(repoId)
+        _activity.value = ModelActivity.Loading
+        AppSnackbar.info("Loading $repoId…")
+        try {
+            unlockedClose()
+            val model = MobileTransformers.fromPretrained(
+                context = context,
+                repoId = repoId,
+                engine = engine,
+                features = features,
+                // Without this the app could only ever pull PUBLIC packages: the facade has always
+                // taken a HubConfig, and this screen never passed one, so a private or gated repo was
+                // unreachable from the UI even though the whole download stack supported it.
+                hubConfig = hubConfig(),
+                onDownloadProgress = { p ->
+                    _download.value = DownloadUi(
+                        phase = p.phase.name,
+                        filesDone = p.filesDone,
+                        filesTotal = p.filesTotal,
+                        path = p.path,
+                        fraction = p.fraction,
+                        bytesDone = p.bytesDone,
+                        bytesTotal = p.bytesTotal,
+                        bytesPerSecond = p.bytesPerSecond,
+                        etaSeconds = p.etaSeconds,
+                    )
+                },
+            )
+            _state.value = ModelState.Loaded(model)
+            AppSnackbar.success("Loaded $repoId")
+            refreshInstalled(context)
+        } catch (e: CancellationException) {
+            // The user cancelled the pull. Not a load failure and not an error banner: leave the
+            // holder empty and let the caller explain what survived on disk.
+            _state.value = ModelState.None
+            throw e
+        } catch (e: Throwable) {
+            // Surfaced verbatim: the SDK's exceptions name the missing feature/artifact, and
+            // replacing that with "failed to load" is how an integrator loses the diagnosis.
+            val reason = e.message ?: e::class.java.simpleName
+            _state.value = ModelState.Failed(repoId, reason)
+            AppSnackbar.error(reason)
+        } finally {
+            _download.value = null
+            _activity.value = ModelActivity.Idle
+        }
+    }
+
+    suspend fun close() = lock.withLock {
+        val had = _state.value is ModelState.Loaded
+        unlockedClose()
+        if (had) AppSnackbar.info("Model unloaded")
+    }
+
+    private fun unlockedClose() {
+        (_state.value as? ModelState.Loaded)?.model?.close()
+        _state.value = ModelState.None
+    }
+}
+
+/**
+ * What the model is occupied with.
+ *
+ * Separate from [ModelState] on purpose: state answers "which model", activity answers "is it free".
+ * A dot painted from state alone can only say loaded/not-loaded, and the question a user actually has
+ * in front of a status light is the second one.
+ */
+enum class ModelActivity(val label: String) {
+    Idle("ready"),
+    Loading("loading"),
+    Generating("generating"),
+    Training("training"),
+    Merging("merging"),
+    Ingesting("ingesting"),
+    ;
+
+    /** Whether the native session is occupied — the whole reason this enum exists. */
+    val isBusy: Boolean get() = this != Idle
+}
+
+/** What the app knows about the model right now. Every screen renders one of these four. */
+sealed interface ModelState {
+    /** No model loaded — the first thing a new user sees, and the reason Models is the first screen. */
+    data object None : ModelState
+
+    data class Loading(val repoId: String) : ModelState
+
+    data class Loaded(val model: MobileTransformerModel) : ModelState
+
+    data class Failed(val repoId: String, val reason: String) : ModelState
+}
+
+/**
+ * UI-side mirror of the facade's `DownloadProgress`, so composables need no SDK import.
+ *
+ * Carries bytes and rate, not only a file count. A package's weights are one or two files of
+ * gigabytes, so "0 / 6 files" is what a working download looks like for most of its life — the same
+ * thing a hung one looks like.
+ */
+data class DownloadUi(
+    val phase: String,
+    /**
+     * The worker is enqueued and waiting on a constraint — in practice, Wi-Fi.
+     *
+     * A boolean rather than a magic phase string, because that is exactly how this broke: the phase
+     * was set to the human sentence `"waiting for Wi-Fi"`, and `downloadPhaseLabel` — which matches
+     * `Resolving`/`Verifying`/`Installing` and sends everything else to `"Downloading"` — swallowed
+     * it. The app then showed an active download that never advanced, which is precisely the state
+     * the sentence existed to distinguish it from. Two correct halves, one unverified seam.
+     */
+    val waitingForConstraints: Boolean = false,
+    val filesDone: Int,
+    val filesTotal: Int,
+    val path: String,
+    val fraction: Float?,
+    val bytesDone: Long = 0L,
+    val bytesTotal: Long? = null,
+    val bytesPerSecond: Double = 0.0,
+    val etaSeconds: Long? = null,
+) {
+    private fun mb(bytes: Long): String = "%.0f MB".format(bytes / 1_048_576.0)
+
+    /** e.g. `"412 MB / 1,320 MB · 8.4 MB/s · ~2m left"`, degrading as each part becomes unknown. */
+    val summary: String
+        get() = buildString {
+            append(mb(bytesDone))
+            bytesTotal?.let { append(" / ${mb(it)}") }
+            if (bytesPerSecond > 0) append(" · %.1f MB/s".format(bytesPerSecond / 1_048_576.0))
+            etaSeconds?.let { append(" · ~${humanDuration(it)} left") }
+        }
+
+    private fun humanDuration(seconds: Long): String = when {
+        seconds < 60 -> "${seconds}s"
+        seconds < 3600 -> "${seconds / 60}m"
+        else -> "${seconds / 3600}h ${(seconds % 3600) / 60}m"
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/Navigation.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/Navigation.kt
new file mode 100644
index 0000000..ede33ed
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/Navigation.kt
@@ -0,0 +1,155 @@
+package com.martinkorelic.mobiletransformers.app
+
+/**
+ * The app's destinations, and — the part that matters — **why each one is or is not usable right now**.
+ *
+ * ### Why a drawer replaced the tab row
+ *
+ * Six destinations do not fit a `NavigationBar`, so the previous version used a `ScrollableTabRow`:
+ * a horizontal strip where the later tabs are off-screen until you scroll, with no grouping and no
+ * indication that the order is a dependency order. Someone opening the app saw "Models" and had no
+ * way to learn that Tool calls exists, let alone that it needs a trained package first.
+ *
+ * A drawer shows all of them at once, grouped by what they are for, and — because [availability] is
+ * computed from the loaded model — can say *why* a destination will not do anything yet instead of
+ * letting the user find out by tapping it and reading an empty state.
+ *
+ * ### Why this file has no Compose in it
+ *
+ * [availability] is the app's only real navigation logic, and it is a pure function of [ModelState].
+ * Keeping it out of the composable layer is what lets `ShowcaseStateTest` check every case on the JVM
+ * — the rule the whole app module follows, and the reason its ViewModels hold the state mapping.
+ */
+enum class Destination(val label: String, val group: NavGroup) {
+    /** First for a reason: on a clean install nothing else can do anything until a package exists. */
+    Models("Models", NavGroup.Run),
+    Chat("Chat", NavGroup.Run),
+    /**
+ * Search the ingested documents and show the closest passages, with nothing generated.
+ *
+ * Its own destination rather than a corner of Chat because it is the only part of the retrieval
+ * story an **encoder** package can show at all: an embedding model has no generative head, so
+ * Chat is hidden for it and grounding is unreachable. It is also the only place retrieval can be
+ * judged on its own — inside a grounded answer, bad retrieval and a model ignoring good retrieval
+ * are indistinguishable.
+ */
+    Retrieval("Retrieval", NavGroup.Run),
+    /**
+ * Hidden for everything except a classifier that names its labels — the exact inverse of [Chat].
+ * A decoder has no classification head, so this is a capability the package genuinely does not
+ * have rather than a step the user has not taken yet.
+ */
+    Classify("Classify", NavGroup.Run),
+    Train("Training", NavGroup.Train),
+    Federated("Federated", NavGroup.Train),
+    Configuration("Configuration", NavGroup.Setup),
+    About("About", NavGroup.Setup),
+}
+
+enum class NavGroup(val label: String) {
+    Run("Run a model"),
+    Train("Train on device"),
+    Setup("Setup"),
+}
+
+/**
+ * Whether a destination can be used, and if not, the reason in words a user can act on.
+ *
+ * [Hidden] is distinct from [Blocked] on purpose. A capability the loaded package genuinely does not
+ * have — chat on a classification encoder — is noise in the drawer, not a locked door. A capability
+ * that merely needs a step first stays visible, because the reason *is* the instruction.
+ */
+sealed interface Availability {
+    data object Enabled : Availability
+
+    /** Reachable, but it will not work yet. [reason] says what to do about it. */
+    data class Blocked(val reason: String) : Availability
+
+    /** Not applicable to the loaded package at all; leave it out of the drawer. */
+    data object Hidden : Availability
+}
+
+/**
+ * What [state] means for this destination.
+ *
+ * Everything here comes from `RuntimeCapabilities`, which the facade already computes from the
+ * artifacts actually installed — so the drawer cannot claim a capability the package does not have,
+ * and cannot withhold one it does.
+ */
+fun Destination.availability(state: ModelState): Availability {
+    // Always reachable: it is where a model comes from, and the only useful thing to do with no
+    // model loaded is to go and load one.
+    if (this == Destination.Models || this == Destination.About) return Availability.Enabled
+
+    val model = (state as? ModelState.Loaded)?.model
+        ?: return Availability.Blocked(
+            when (state) {
+                is ModelState.Loading -> "loading ${state.repoId}…"
+                is ModelState.Failed -> "${state.repoId} failed to load — see Models"
+                else -> "load a model on the Models screen first"
+            },
+        )
+
+    return availabilityFor(model.capabilities)
+}
+
+/**
+ * The half of [availability] that depends only on what the loaded package can do.
+ *
+ * Split out to be reachable from a JVM test: a `ModelState.Loaded` carries a `MobileTransformerModel`,
+ * which owns a native session and cannot be constructed off-device, so as one function every
+ * capability branch here was untestable — including the one that decides whether Classify exists.
+ */
+internal fun Destination.availabilityFor(
+    caps: com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities,
+): Availability {
+    return when (this) {
+        Destination.Chat ->
+        // Any encoder — a classifier OR a plain embedding model — has no generative head at all,
+        // so offering a chat box for it is a promise the package cannot keep. Testing only
+        // `isClassifier` covered the first and missed the second, which is exactly the package
+        // the Retrieval screen exists for.
+        if (caps.isEncoderOnly) Availability.Hidden else Availability.Enabled
+
+        Destination.Retrieval ->
+        // The embedding stage is the whole requirement; whether the package can also generate is
+        // irrelevant here, which is what lets a pure encoder use this screen.
+        if (caps.supportsRag || caps.supportsEmbedding) {
+                Availability.Enabled
+            } else {
+            Availability.Blocked("this package has no embedding stage — pull one with RAG requested")
+            }
+
+        Destination.Classify ->
+        // `supportsClassification`, not `isClassifier`: a classification graph whose labels are
+        // unknown runs fine and answers `LABEL_3`, which is a number in a costume. The screen
+        // would show bars with no meaning, so the honest report is that it is not applicable.
+        if (caps.supportsClassification) {
+                Availability.Enabled
+            } else {
+                Availability.Hidden
+            }
+
+        Destination.Train, Destination.Federated ->
+            if (caps.supportsTraining) {
+                Availability.Enabled
+            } else {
+                Availability.Blocked("this package has no train/ stage — pull one with Training requested")
+            }
+
+        Destination.Models, Destination.About, Destination.Configuration -> Availability.Enabled
+    }
+}
+
+/** The destinations to show, in drawer order, for the current model. */
+fun visibleDestinations(state: ModelState): List<Destination> =
+    Destination.entries.filter { it.availability(state) !is Availability.Hidden }
+
+/**
+ * Where to send the user when the destination they are on stops being applicable.
+ *
+ * Loading a classifier while sitting on Chat would otherwise leave them looking at a screen that is
+ * no longer in the drawer, with no way back except the drawer they cannot see behind it.
+ */
+fun redirectFor(current: Destination, state: ModelState): Destination =
+    if (current.availability(state) is Availability.Hidden) Destination.Models else current
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/NotificationPermission.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/NotificationPermission.kt
new file mode 100644
index 0000000..554bc94
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/NotificationPermission.kt
@@ -0,0 +1,57 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
+
+/**
+ * Ask for `POST_NOTIFICATIONS` once, on first composition.
+ *
+ * ### Why this had to be added
+ *
+ * The SDK declares the permission in its own manifest — deliberately, so a consumer that calls
+ * `TrainingScheduler.schedule()` inherits it — and `TrainingWorker` posts a foreground notification
+ * with a Cancel action. But **nothing ever requested it**. Since API 33 the permission is runtime-
+ * granted and denied by default, so on every modern device the training notification was constructed,
+ * handed to the system, and silently dropped. The worker still ran; the user simply had no way to see
+ * that it was running or to stop it — which is the whole point of promoting it to the foreground.
+ *
+ * Declaring a permission and requesting it are different acts, and only one of them was happening.
+ *
+ * Below API 33 the permission does not exist and is granted implicitly, so this is a no-op there.
+ * A denial is not fatal and not re-prompted here: Android stops showing the dialog after two refusals
+ * anyway, and the About screen links to system settings for anyone who changes their mind.
+ */
+@Composable
+fun RequestNotificationPermissionOnce() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return
+
+    val context = LocalContext.current
+    val launcher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestPermission(),
+    ) { /* granted or not, the app works either way — only visibility changes */ }
+
+    LaunchedEffect(Unit) {
+        if (!hasNotificationPermission(context)) {
+            launcher.launch(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+}
+
+/**
+ * Whether background progress can actually be shown.
+ *
+ * Surfaced so a screen offering scheduled training can say "this will run without a visible
+ * notification" rather than implying an ongoing notification the system will discard.
+ */
+fun hasNotificationPermission(context: Context): Boolean =
+    Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+        ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+        PackageManager.PERMISSION_GRANTED
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/PermissionGate.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/PermissionGate.kt
new file mode 100644
index 0000000..84277d3
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/PermissionGate.kt
@@ -0,0 +1,63 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+
+/**
+ * Whether the app may actually start an allowed action's intent, and what to do when it may not.
+ *
+ * Firing an intent used to be a `runCatching { startActivity(...) }`, so a missing permission arrived
+ * as a `SecurityException` after the user had already tapped Run — an exception used to answer a
+ * question that could have been asked first. This asks first.
+ *
+ * ### Why the two outcomes are not the same
+ *
+ * A missing permission means opposite things depending on its protection level, and telling a user the
+ * wrong one wastes their time:
+ *
+ * - **Install-time** (`com.android.alarm.permission.SET_ALARM`) is granted at install *if the manifest
+ *   declares it*. If it is missing at runtime, no dialog will ever fix that — it is a build defect,
+ *   and the honest message says so rather than inviting the user to grant something they cannot.
+ * - **Runtime** is the user's decision, and the system dialog is the right response.
+ *
+ * The two are distinguished by asking the platform for the permission's own protection level rather
+ * than by keeping a list here, so a permission added to [ActionAllowlist] is classified correctly
+ * without this file changing.
+ */
+object PermissionGate {
+
+    /** Permissions in [required] that are not currently granted. */
+    fun missing(context: Context, required: List<String>): List<String> =
+        required.filter {
+            ContextCompat.checkSelfPermission(context, it) != PackageManager.PERMISSION_GRANTED
+        }
+
+    /**
+     * Whether [permission] is one the system will show a dialog for.
+     *
+     * Reads the platform's own `protectionLevel`. An unknown permission — one the device has never
+     * heard of — reports `false`: a dialog for it would be dismissed instantly, and calling it a
+     * configuration problem is both true and actionable.
+     */
+    fun isRuntimePermission(context: Context, permission: String): Boolean = runCatching {
+        val info = context.packageManager.getPermissionInfo(permission, 0)
+        @Suppress("DEPRECATION")
+        val level = info.protectionLevel and android.content.pm.PermissionInfo.PROTECTION_MASK_BASE
+        level == android.content.pm.PermissionInfo.PROTECTION_DANGEROUS
+    }.getOrDefault(false)
+
+    /**
+     * Split [missing] into the ones worth prompting for and the ones that are a build defect.
+     *
+     * @return `requestable` — show the system dialog for these; `undeclared` — no dialog can help,
+     *   the manifest is wrong.
+     */
+    fun classify(context: Context, missing: List<String>): Pair<List<String>, List<String>> =
+        missing.partition { isRuntimePermission(context, it) }
+
+    /** A message naming what is wrong, for permissions no dialog can resolve. */
+    fun undeclaredMessage(permissions: List<String>): String =
+        "this build is missing ${permissions.joinToString()} in its AndroidManifest — an install-time " +
+            "permission cannot be granted from here, so the app has to declare it and be reinstalled"
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/SampleData.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/SampleData.kt
new file mode 100644
index 0000000..bdc4553
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/SampleData.kt
@@ -0,0 +1,136 @@
+package com.martinkorelic.mobiletransformers.app
+
+import android.content.Context
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import java.io.File
+
+/**
+ * Bundled sample data, and the one-tap installers that put it where the SDK looks for it.
+ *
+ * ### Why this exists
+ *
+ * Two screens were structurally unreachable on a freshly pulled package, which is exactly the state a
+ * new user is in:
+ *
+ * - **Train** reads its dataset from `<cacheDir>/<repoId>/train/<trainFile>.jsonl`. Model packages
+ *   deliberately ship no training data — the task belongs with the data, and the data is the caller's —
+ *   so on a clean install that file does not exist and Start fails. Every instrumented test writes its
+ *   own copy; a person using the app had no equivalent.
+ * - **RAG** retrieves from a vector store that only `MobileTransformerModel.ingest` populates, and
+ *   nothing in the app called it. The toggle therefore always returned zero sources.
+ *
+ * Neither is an SDK defect, and neither should be fixed by making the SDK ship data. What was missing
+ * is the *worked example* of supplying it — which is this app's whole job.
+ *
+ * ### Why the assets are what they are
+ *
+ * [TRAIN_ASSET] is generated from the **same allowlist** the Tool calls screen declares, so training on
+ * it teaches this app's real action boundary and every completion is one `FunctionCallValidator`
+ * accepts. Regenerate it with the command below rather than editing it by hand — a row whose completion
+ * the validator would reject teaches the model to produce something the app then refuses.
+ *
+ * ```
+ * mobiletransformers agent-dataset --source generated \
+ *   --allowlist  app/src/main/assets/sample_action_schema.json \
+ *   --templates  app/src/main/assets/sample_action_templates.json \
+ *   --name sample_mobile_actions --per-action 16 --seed 7 --output <dir>
+ * ```
+ *
+ * Both inputs ship beside the output so that command is runnable from a clean checkout.
+ * `sample_action_schema.json` is a copy of the `ToolCallViewModel` allowlist, and the templates are
+ * needed because the generator's built-in `set_alarm` phrasings reference a `label` parameter this app
+ * does not declare — it refuses to emit a row whose slots the action never declared, which is the
+ * check that keeps the training set and the validator from drifting apart.
+ */
+object SampleData {
+
+    /** Tool-call training rows (`{"prompt", "completion"}`), matching the `mobile_actions` task. */
+    const val TRAIN_ASSET = "sample_mobile_actions.jsonl"
+
+    /** The preprocessor that parses [TRAIN_ASSET]; goes into `DatasetConfig.task`. */
+    const val TRAIN_TASK = "mobile_actions"
+
+    /** `DatasetConfig.trainFile` this installs as — the name, without the `.jsonl` the SDK appends. */
+    const val TRAIN_FILE = "sample_mobile_actions"
+
+    /** A short document for the RAG ingest example. */
+    const val RAG_ASSET = "sample_rag_document.md"
+
+    /**
+ * The bundled retrieval corpus — four short documents on deliberately distinct subjects.
+ *
+ * One document is enough to show that retrieval *runs*, and useless for showing that it
+ * **works**: every query returns chunks of the only thing in the store, so a perfect ranking and a
+ * random one look identical. With four separable subjects — the package format, fine-tuning,
+ * privacy, and device behaviour — a query like "what leaves my phone during federated learning"
+ * has a right answer a user can check at a glance, which is the whole point of the Retrieval
+ * screen.
+ */
+    val RAG_ASSETS = listOf(
+        RAG_ASSET,
+        "sample_rag_training.md",
+        "sample_rag_privacy.md",
+        "sample_rag_device.md",
+)
+
+    /** Example queries whose best match is a *different* document each time. */
+    val RAG_EXAMPLE_QUERIES = listOf(
+        "what leaves my phone during federated learning?",
+        "how does MARS differ from LoRA?",
+        "why does a scheduled run start late?",
+        "how is a package verified before it is downloaded?",
+)
+
+    /**
+     * Copy [TRAIN_ASSET] into the installed package's `train/` stage as `<TRAIN_FILE>.jsonl`.
+     *
+     * The stage directory is resolved through [PackagePaths], never by appending `"train"` to a path:
+     * a package declares where its stages live, and the cache layout is not simply the hub layout with
+     * the `variants/<id>/` prefix removed.
+     *
+     * @param cacheDir the cache root the model was loaded from.
+     * @param sanitizedRepoId the package's directory name (`PackageFormat.sanitizeRepoId`).
+     * @return the installed file, or `null` when the package has no `train/` stage to put it in —
+     *   the honest outcome for an inference-only package, rather than creating a directory the trainer
+     *   will never read.
+     */
+    fun installTrainingSet(context: Context, cacheDir: File, sanitizedRepoId: String): File? {
+        val trainDir = PackagePaths.forCache(cacheDir, sanitizedRepoId).train
+        if (!trainDir.isDirectory) return null
+        val target = File(trainDir, "$TRAIN_FILE.jsonl")
+        copyAsset(context, TRAIN_ASSET, target)
+        return target
+    }
+
+    /**
+     * Copy [RAG_ASSET] into the app's own files dir and return it, ready to hand to `ingest`.
+     *
+     * Not written into the package: an ingested document is user data, not part of the model, and
+     * putting it inside the package tree would make it collateral damage of the next reinstall.
+     */
+    fun installRagDocument(context: Context): File {
+        val target = File(context.filesDir, RAG_ASSET)
+        copyAsset(context, RAG_ASSET, target)
+        return target
+    }
+
+    /**
+ * Copy the whole [RAG_ASSETS] corpus into the app's files dir, ready to ingest.
+ *
+ * Returned in declaration order so the caller can report them predictably. Like
+ * [installRagDocument] these are written to app storage rather than into the package: an ingested
+ * document is user data, and putting it inside the package tree would make it collateral damage
+ * of the next reinstall.
+ */
+    fun installRagCorpus(context: Context): List<File> =
+    RAG_ASSETS.map { asset ->
+        File(context.filesDir, asset).also { copyAsset(context, asset, it) }
+    }
+
+    private fun copyAsset(context: Context, asset: String, target: File) {
+        target.parentFile?.mkdirs()
+        context.assets.open(asset).use { input ->
+            target.outputStream().use { output -> input.copyTo(output) }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Theme.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Theme.kt
new file mode 100644
index 0000000..c320c20
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Theme.kt
@@ -0,0 +1,334 @@
+package com.martinkorelic.mobiletransformers.app.ui.theme
+
+import android.app.Activity
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Shapes
+import androidx.compose.material3.Typography
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.unit.dp
+import androidx.core.view.WindowCompat
+
+enum class AppTheme {
+    FRI,
+    BETTER
+}
+
+/**
+ * The FRI palette, in one family.
+ *
+ * It used to be three. `primary` was the project red, but `primaryContainer` (`#E8F5F0`),
+ * `surfaceVariant` (`#DDE5DA`) and `background` were pale greens left over from an earlier theme, and
+ * `tertiary` was a brown from a third. Since `surfaceVariant` is what the persistent model bar paints
+ * itself with and `primaryContainer` is what filled chips use, the two surfaces the user sees on every
+ * screen were the ones in the wrong family — a red app with a green header.
+ *
+ * Everything below is derived from the red: containers are tinted toward it, the neutrals are warm
+ * greys rather than green-greys, and `tertiary` is a slate that reads as deliberate contrast instead
+ * of as a leftover.
+ */
+private val FriLightColors = lightColorScheme(
+    primary = Color(0xFFE03229),
+    onPrimary = Color.White,
+    primaryContainer = Color(0xFFFFDAD5),
+    onPrimaryContainer = Color(0xFF410100),
+
+    secondary = Color(0xFF58595B),
+    onSecondary = Color.White,
+    secondaryContainer = Color(0xFFE6E1E0),
+    onSecondaryContainer = Color(0xFF1B1B1D),
+
+    tertiary = Color(0xFF4A5C74),          // Slate — deliberate contrast, not a leftover brown
+    onTertiary = Color.White,
+    tertiaryContainer = Color(0xFFD6E2F3),
+    onTertiaryContainer = Color(0xFF0C1B2A),
+
+    error = Color(0xFFB3261E),
+    onError = Color.White,
+    errorContainer = Color(0xFFF9DEDC),
+    onErrorContainer = Color(0xFF410E0B),
+
+    background = Color(0xFFFDFBFB),
+    onBackground = Color(0xFF1C1B1B),
+    surface = Color(0xFFFDFBFB),
+    onSurface = Color(0xFF1C1B1B),
+    surfaceVariant = Color(0xFFF0E9E8),    // Warm neutral: the model bar's background
+    onSurfaceVariant = Color(0xFF4A4644),
+    outline = Color(0xFF857C7A),
+    outlineVariant = Color(0xFFD8D0CE),
+
+    // The surface-container family. Unset, these do NOT fall back to `surface` — `lightColorScheme()`
+    // fills every omitted role from Material 3's **baseline palette, which is purple**. `TopAppBar`
+    // and `ModalDrawerSheet` paint themselves from `surfaceContainer`/`surfaceContainerLow`, so
+    // leaving them out put a lilac bar across the top of a red app. Warm greys keyed to `surface`.
+    surfaceContainerLowest = Color(0xFFFFFFFF),
+    surfaceContainerLow = Color(0xFFFAF6F5),
+    surfaceContainer = Color(0xFFF5F0EF),
+    surfaceContainerHigh = Color(0xFFEFEAE9),
+    surfaceContainerHighest = Color(0xFFE9E4E3),
+    surfaceBright = Color(0xFFFDFBFB),
+    surfaceDim = Color(0xFFDED9D8),
+    // Tonal elevation tints surfaces with this; the default is `primary`, which would push elevated
+    // surfaces pink. Neutral keeps an elevated card the same family as a flat one.
+    surfaceTint = Color(0xFF857C7A),
+    inverseSurface = Color(0xFF322F2E),
+    inverseOnSurface = Color(0xFFF5F0EF),
+    inversePrimary = Color(0xFFFFB4AA),
+    scrim = Color(0xFF000000),
+)
+
+/**
+ * The dark counterpart.
+ *
+ * `AppThemedContent(isDarkMode = …)` has always taken this parameter and never used it, so the app
+ * rendered a light surface under a dark system bar. The default is still `false` — turning it on for
+ * everyone would change the app's appearance for a reason nobody asked for — but the parameter now
+ * means something when a caller passes it.
+ */
+private val FriDarkColors = darkColorScheme(
+    primary = Color(0xFFFFB4AA),
+    onPrimary = Color(0xFF690003),
+    primaryContainer = Color(0xFF93000C),
+    onPrimaryContainer = Color(0xFFFFDAD5),
+
+    secondary = Color(0xFFC7C6C8),
+    onSecondary = Color(0xFF303032),
+    secondaryContainer = Color(0xFF464648),
+    onSecondaryContainer = Color(0xFFE6E1E0),
+
+    tertiary = Color(0xFFAEC7E4),
+    onTertiary = Color(0xFF1A2F45),
+    tertiaryContainer = Color(0xFF32455C),
+    onTertiaryContainer = Color(0xFFD6E2F3),
+
+    error = Color(0xFFFFB4AB),
+    onError = Color(0xFF690005),
+    errorContainer = Color(0xFF93000A),
+    onErrorContainer = Color(0xFFFFDAD6),
+
+    background = Color(0xFF141313),
+    onBackground = Color(0xFFE6E1E0),
+    surface = Color(0xFF141313),
+    onSurface = Color(0xFFE6E1E0),
+    surfaceVariant = Color(0xFF302B2A),
+    onSurfaceVariant = Color(0xFFD0C7C5),
+    outline = Color(0xFF9A918F),
+    outlineVariant = Color(0xFF4E4746),
+
+    // Same reason as the light scheme: omitted roles come from the baseline purple, not from surface.
+    surfaceContainerLowest = Color(0xFF0E0E0E),
+    surfaceContainerLow = Color(0xFF1C1B1B),
+    surfaceContainer = Color(0xFF201F1F),
+    surfaceContainerHigh = Color(0xFF2B2A29),
+    surfaceContainerHighest = Color(0xFF363433),
+    surfaceBright = Color(0xFF3A3838),
+    surfaceDim = Color(0xFF141313),
+    surfaceTint = Color(0xFF9A918F),
+    inverseSurface = Color(0xFFE6E1E0),
+    inverseOnSurface = Color(0xFF322F2E),
+    inversePrimary = Color(0xFFB3261E),
+    scrim = Color(0xFF000000),
+)
+
+private val BetterLightColors = lightColorScheme(
+    primary = Color(0xFF026fd0),           // Professional blue
+    onPrimary = Color.White,
+    primaryContainer = Color(0xFFD1E4FF),
+    onPrimaryContainer = Color(0xFF001D36),
+
+    secondary = Color(0xFF4A5C74),         // Blue grey — was #F9F9F9, invisible against onSecondary
+    onSecondary = Color.White,
+    secondaryContainer = Color(0xFFD7E3F7),
+    onSecondaryContainer = Color(0xFF101C2B),
+
+    tertiary = Color(0xFF6A4C93),          // Purple accent
+    onTertiary = Color.White,
+    tertiaryContainer = Color(0xFFEADDFF),
+    onTertiaryContainer = Color(0xFF21005D),
+
+    error = Color(0xFFD32F2F),
+    onError = Color.White,
+    errorContainer = Color(0xFFFFDAD6),
+    onErrorContainer = Color(0xFF410002),
+
+    background = Color(0xFFFEFBFF),
+    onBackground = Color(0xFF1B1B1F),
+    surface = Color(0xFFFEFBFF),
+    onSurface = Color(0xFF1B1B1F),
+    surfaceVariant = Color(0xFFE2E2EC),
+    onSurfaceVariant = Color(0xFF45464F),
+    outline = Color(0xFF767680),
+    outlineVariant = Color(0xFFC6C6D0),
+
+    // Same omission as FRI had; this theme is blue, so the baseline purple showed here too.
+    surfaceContainerLowest = Color(0xFFFFFFFF),
+    surfaceContainerLow = Color(0xFFF7F8FC),
+    surfaceContainer = Color(0xFFF1F3F9),
+    surfaceContainerHigh = Color(0xFFEBEEF5),
+    surfaceContainerHighest = Color(0xFFE5E8F0),
+    surfaceTint = Color(0xFF767680),
+)
+
+private val BetterDarkColors = darkColorScheme(
+    primary = Color(0xFF9FCAFF),
+    onPrimary = Color(0xFF003259),
+    primaryContainer = Color(0xFF00497E),
+    onPrimaryContainer = Color(0xFFD1E4FF),
+    secondary = Color(0xFFBBC7DB),
+    onSecondary = Color(0xFF253141),
+    tertiary = Color(0xFFD3BCFA),
+    onTertiary = Color(0xFF3A2260),
+    error = Color(0xFFFFB4AB),
+    onError = Color(0xFF690005),
+    background = Color(0xFF131317),
+    onBackground = Color(0xFFE4E2E6),
+    surface = Color(0xFF131317),
+    onSurface = Color(0xFFE4E2E6),
+    surfaceVariant = Color(0xFF44474F),
+    onSurfaceVariant = Color(0xFFC4C6D0),
+    outline = Color(0xFF8E9099),
+)
+
+/**
+ * Status colours, which Material 3 has no roles for.
+ *
+ * "The model is ready" and "the model is busy" are the two states the model bar exists to
+ * distinguish, and neither is `primary` or `error`. Painting the ready dot with `primary` — which is
+ * what it did — made a healthy loaded model show a red dot in a red-primary theme, i.e. the exact
+ * opposite of what a status light is for.
+ *
+ * [busy] is deliberately the brand red rather than the error red: busy is not a fault, and the two
+ * are told apart by the row beneath the dot (a failure prints its reason there, a busy model prints
+ * what it is doing).
+ */
+@Immutable
+data class StatusColors(
+    /** Loaded and free — the model can take work right now. */
+    val ready: Color,
+    /** Loading, generating, training or merging. */
+    val busy: Color,
+    /** Nothing loaded. */
+    val idle: Color,
+    /** The last load or run failed. */
+    val failed: Color,
+)
+
+private val LightStatusColors = StatusColors(
+    ready = Color(0xFF2E7D32),
+    busy = Color(0xFFE03229),
+    idle = Color(0xFF9A918F),
+    failed = Color(0xFFB3261E),
+)
+
+private val DarkStatusColors = StatusColors(
+    ready = Color(0xFF7BC47F),
+    busy = Color(0xFFFF8A80),
+    idle = Color(0xFF9A918F),
+    failed = Color(0xFFFFB4AB),
+)
+
+/** Reachable as `MaterialTheme.statusColors` from any composable inside [AppThemedContent]. */
+val LocalStatusColors = staticCompositionLocalOf { LightStatusColors }
+
+val MaterialTheme.statusColors: StatusColors
+    @Composable
+    get() = LocalStatusColors.current
+
+// 5. Custom Typography per Theme
+@Composable
+private fun getTypography(theme: AppTheme): Typography {
+    return when (theme) {
+        AppTheme.FRI -> Typography(
+            headlineLarge = MaterialTheme.typography.headlineLarge.copy(
+                fontWeight = androidx.compose.ui.text.font.FontWeight.SemiBold
+            ),
+            titleMedium = MaterialTheme.typography.titleMedium.copy(
+                fontWeight = androidx.compose.ui.text.font.FontWeight.Medium
+            )
+        )
+        AppTheme.BETTER -> Typography(
+            headlineLarge = MaterialTheme.typography.headlineLarge.copy(
+                fontWeight = androidx.compose.ui.text.font.FontWeight.Bold
+            ),
+            titleMedium = MaterialTheme.typography.titleMedium.copy(
+                fontWeight = androidx.compose.ui.text.font.FontWeight.SemiBold
+            )
+        )
+    }
+}
+
+// 6. Custom Shapes per Theme
+@Composable
+private fun getShapes(theme: AppTheme): Shapes {
+    return when (theme) {
+        AppTheme.FRI -> Shapes(
+            small = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
+            medium = androidx.compose.foundation.shape.RoundedCornerShape(12.dp),
+            large = androidx.compose.foundation.shape.RoundedCornerShape(16.dp)
+        )
+        AppTheme.BETTER -> Shapes(
+            small = androidx.compose.foundation.shape.RoundedCornerShape(4.dp),
+            medium = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
+            large = androidx.compose.foundation.shape.RoundedCornerShape(12.dp)
+        )
+    }
+}
+
+// 4. Main Theme Composable
+@Composable
+fun AppThemedContent(
+    theme: AppTheme,
+    isDarkMode: Boolean = false,
+    content: @Composable () -> Unit
+) {
+    val colorScheme = when {
+        theme == AppTheme.FRI && isDarkMode -> FriDarkColors
+        theme == AppTheme.FRI -> FriLightColors
+        isDarkMode -> BetterDarkColors
+        else -> BetterLightColors
+    }
+
+    // The status bar is painted by the WINDOW, not by Compose, so a fully-themed app still sat under
+    // a strip of `Theme.MaterialComponents`' `colorPrimaryVariant` — the untouched Android Studio
+    // template purple (#3700B3), in both day and night. It is the same defect the surface-container
+    // block above documents, one layer further out: a role nobody set, filled from a baseline palette.
+    //
+    // Driven from the live `colorScheme` rather than restated in `themes.xml` because there are FOUR
+    // schemes here (FRI/Better x light/dark) and a hardcoded XML colour can only be right for one of
+    // them. `surfaceContainer` specifically: that is what `TopAppBar` paints itself with, so the
+    // status bar and the app bar read as one surface instead of a seam.
+    val view = LocalView.current
+    if (!view.isInEditMode) {
+        val window = (view.context as Activity).window
+        SideEffect {
+            window.statusBarColor = colorScheme.surfaceContainer.toArgb()
+            window.navigationBarColor = colorScheme.surfaceContainer.toArgb()
+            // Icon contrast is a separate decision from the fill: a light bar needs dark icons or the
+            // clock disappears. Keyed to the scheme, not to the system's dark-mode setting, because
+            // `isDarkMode` here is the app's own choice and may disagree with the system's.
+            WindowCompat.getInsetsController(window, view).apply {
+                isAppearanceLightStatusBars = !isDarkMode
+                isAppearanceLightNavigationBars = !isDarkMode
+            }
+        }
+    }
+
+    CompositionLocalProvider(
+        LocalStatusColors provides if (isDarkMode) DarkStatusColors else LightStatusColors,
+    ) {
+        MaterialTheme(
+            colorScheme = colorScheme,
+            typography = getTypography(theme),
+            shapes = getShapes(theme),
+            content = content
+        )
+    }
+}
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Type.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Type.kt
similarity index 94%
rename from android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Type.kt
rename to android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Type.kt
index 818c301..b9d381b 100644
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Type.kt
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/ui/theme/Type.kt
@@ -1,4 +1,4 @@
-package com.martinkorelic.orttransformer.ui.theme
+package com.martinkorelic.mobiletransformers.app.ui.theme
 
 import androidx.compose.material3.Typography
 import androidx.compose.ui.text.TextStyle
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ChatViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ChatViewModel.kt
new file mode 100644
index 0000000..38ef490
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ChatViewModel.kt
@@ -0,0 +1,744 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import android.net.Uri
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.GenerateCallback
+import com.martinkorelic.mobiletransformers.GenerateProgress
+import com.martinkorelic.mobiletransformers.agent.ActionSpec
+import com.martinkorelic.mobiletransformers.agent.FunctionCallValidator
+import com.martinkorelic.mobiletransformers.agent.ToolCallParser
+import com.martinkorelic.mobiletransformers.agent.ToolCallResult
+import com.martinkorelic.mobiletransformers.agent.ToolPromptBuilder
+import com.martinkorelic.mobiletransformers.app.ActionAllowlist
+import com.martinkorelic.mobiletransformers.app.AppConfig
+import com.martinkorelic.mobiletransformers.app.AppSnackbar
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.app.ModelActivity
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.app.PermissionGate
+import com.martinkorelic.mobiletransformers.app.SampleData
+import com.martinkorelic.mobiletransformers.RetrieveCallback
+import com.martinkorelic.mobiletransformers.rag.PromptAssembler
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import com.martinkorelic.mobiletransformers.runtime.RetrievalResult
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import java.io.File
+
+/**
+ * Chat with streaming, retrieval attached to the answer it grounded, and tool calls
+ * rendered in the conversation that produced them.
+ *
+ * The engine picker offers exactly `capabilities.availableEngines`, which the facade computes from the
+ * same two conditions `ModelRuntimeFactory` applies (the package ships `genai_config.json` **and** the
+ * native GenAI probe succeeds). Before that existed an app could only offer both engines and learn the
+ * answer by catching `EngineUnavailableException` — using an exception as control flow for a question
+ * the SDK already knew.
+ */
+class ChatViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(ChatUiState())
+    val ui: StateFlow<ChatUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    /**
+ * The app's single action declaration — see [ActionAllowlist].
+     *
+ * Kept as one value rather than a copy: the boundary and the training corpus are already
+ * generated from that one object, and a second hand-written list here would be another chance for
+ * them to disagree, with a refusal no error message could explain.
+     */
+    val allowlist: List<ActionSpec> get() = ActionAllowlist.ENTRIES
+
+    private val validator = FunctionCallValidator(ActionAllowlist.ENTRIES)
+
+    fun onPromptChanged(value: String) {
+        _ui.value = _ui.value.copy(prompt = value)
+    }
+
+    fun onRagToggled(value: Boolean) {
+        _ui.value = _ui.value.copy(useRag = value)
+    }
+
+    /**
+     * Whether an accepted tool call fires by itself or waits for a tap.
+     *
+     * Defaults to [ToolExecution.Approve]. The SDK never executes anything — `IntentBinder.dryRun`
+     * holds no `Context` and has no `startActivity` call site, which is the structural half of the
+     * "no model output is ever executed". Firing is therefore the **app's** deliberate act, taken
+     * only on a `ValidatedCall` that cleared the allowlist, and the default keeps a human in the loop
+     * for it.
+     */
+    fun onToolExecutionChanged(value: ToolExecution) {
+        _ui.value = _ui.value.copy(toolExecution = value)
+    }
+
+    /**
+     * Fire an accepted call's intent.
+     *
+     * Only reachable from a card the validator accepted, and the intent's action string comes from
+     * the app's own [ActionSpec] rather than from anything the model produced — a model selects an
+     * action, it cannot name an intent. `FLAG_ACTIVITY_NEW_TASK` because the launch originates from
+     * a ViewModel holding an application context, not an Activity.
+     */
+    fun runToolCall(card: ToolCallCard) {
+        val intent = card.intent ?: return
+        val context = getApplication<Application>()
+
+        // Ask before firing, rather than catching SecurityException afterwards. A missing permission
+        // used to surface only as a failed startActivity, which is what made tool calling look broken
+        // on device when the manifest simply did not declare SET_ALARM.
+        val missing = PermissionGate.missing(context, card.requiredPermissions)
+        if (missing.isNotEmpty()) {
+            val (requestable, undeclared) = PermissionGate.classify(context, missing)
+            if (undeclared.isNotEmpty()) {
+                // No dialog can fix an install-time permission; saying "grant it" would be wrong.
+                AppSnackbar.error(PermissionGate.undeclaredMessage(undeclared))
+            return
+    }
+            // Hand the request to the screen: a runtime prompt needs an Activity, and this holds an
+            // application context. The card is remembered so the call can resume once granted.
+            _ui.value = _ui.value.copy(pendingPermissions = PendingPermissions(card, requestable))
+            return
+    }
+
+        runCatching {
+            context.startActivity(
+                android.content.Intent(intent).addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK),
+            )
+        }
+            .onSuccess {
+                markExecuted(card)
+                AppSnackbar.success("Ran ${card.actionName}")
+            }
+            .onFailure {
+                // No handler for the intent is the common case on an emulator or a stripped ROM, and
+                // it is a property of the device rather than a failure of the call.
+                AppSnackbar.error(
+                    "Could not run ${card.actionName}: ${it.message ?: "no app handles that intent"}",
+            )
+    }
+    }
+
+    /**
+ * The screen has finished showing the system dialog.
+ *
+ * @param granted whether every requested permission was allowed. A refusal is a decision, not an
+ * error: it is reported and the call is dropped, never retried in a loop.
+ */
+    fun onPermissionResult(granted: Boolean) {
+        val pending = _ui.value.pendingPermissions ?: return
+        _ui.value = _ui.value.copy(pendingPermissions = null)
+        if (granted) {
+            runToolCall(pending.card)
+                } else {
+                AppSnackbar.error(
+                "${pending.card.actionName} needs ${pending.permissions.joinToString()}, which was " +
+                "declined — nothing was run",
+                )
+            }
+    }
+
+    /** Flip the card to executed, so the conversation records that it fired. */
+    private fun markExecuted(card: ToolCallCard) {
+        _ui.value = _ui.value.copy(
+            messages = _ui.value.messages.map { m ->
+                if (m.toolCall === card) m.copy(toolCall = card.copy(executed = true)) else m
+            },
+        )
+    }
+
+    /**
+     * Whether this conversation routes through the tool-call path at all.
+     *
+     * **Not a user-facing switch.** It used to be a chip the user had to set *before* sending, which
+     * asks them to predict something only the reply can answer: whether "wake me at 07:30" is a tool
+     * call or a question about alarms. With the toggle off a genuine call came back as prose; with it
+     * on, "what time is it in Tokyo" came back as a refusal.
+     *
+     * So the allowlist is declared on every turn for a model that has a tool-call grammar, and the
+     * *outcome* decides how the turn renders — `ToolCallResult.NoCall` for prose, `Accepted` or
+     * `Rejected` for a call. Declaring tools costs prompt tokens, so it is skipped for models that
+     * have no such grammar, where every turn would be prose anyway.
+     */
+    private fun toolsAvailable(model: MobileTransformerModel): Boolean =
+        model.capabilities.supportsToolCalling
+
+    /**
+     * Ingest a document into the on-device vector store.
+     *
+     * Retrieval reads a store that only `ingest` fills, and nothing in this app called it — so the RAG
+     * switch was structurally dead: every grounded query retrieved zero sources and the model answered
+     * ungrounded while the UI implied otherwise.
+     *
+     * @param uri a document the user picked, or `null` to install the bundled sample. Picking a file
+     *   is the difference between a demo of retrieval and retrieval over something you care about.
+     */
+    fun ingest(uri: Uri? = null) {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        if (!model.capabilities.supportsRag) {
+            val message = "this package has no embedding stage — re-pull it with the RAG feature " +
+                "requested on the Models screen (it is a separate ~91 MB download group)"
+            _ui.value = _ui.value.copy(error = message)
+            AppSnackbar.error(message)
+            return
+        }
+        viewModelScope.launch {
+            _ui.value = _ui.value.copy(ingesting = true, error = null, ingestNote = null)
+            try {
+                val doc = uri?.let { copyToCache(it) } ?: SampleData.installRagDocument(getApplication())
+                val result = ModelHolder.withActivity(ModelActivity.Ingesting) {
+                    model.ingest(doc.absolutePath, AppConfig.rag.value)
+                }
+                _ui.value = _ui.value.copy(
+                    ingestNote = "ingested ${doc.name}: ${result.chunkCount} chunks",
+                    ingestedDocuments = _ui.value.ingestedDocuments + doc.name,
+                )
+                AppSnackbar.success("Ingested ${doc.name} — ${result.chunkCount} chunks")
+            } catch (e: Throwable) {
+                val reason = e.message ?: e::class.java.simpleName
+                _ui.value = _ui.value.copy(error = reason)
+                AppSnackbar.error(reason)
+            } finally {
+                _ui.value = _ui.value.copy(ingesting = false)
+            }
+        }
+    }
+
+    /**
+     * Copy a picked document into app storage before ingesting it.
+     *
+     * `ingest` takes a filesystem path, and a `content://` URI from the document picker is not one —
+     * it is a handle into another app's provider, valid only for this grant. Copying is what turns it
+     * into something the SDK can open.
+     */
+    private fun copyToCache(uri: Uri): File {
+        val name = uri.lastPathSegment?.substringAfterLast('/')?.takeIf { it.isNotBlank() } ?: "document.txt"
+        val target = File(getApplication<Application>().filesDir, "ingested-$name")
+        getApplication<Application>().contentResolver.openInputStream(uri).use { input ->
+            requireNotNull(input) { "could not open $uri" }
+            target.outputStream().use { input.copyTo(it) }
+        }
+        return target
+    }
+
+    fun send() {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        val prompt = _ui.value.prompt.trim()
+        if (prompt.isEmpty() || _ui.value.generating) return
+
+        _ui.value = _ui.value.copy(
+            messages = _ui.value.messages + ChatMessage(text = prompt, fromUser = true),
+            prompt = "",
+            streaming = "",
+            generating = true,
+            error = null,
+        )
+
+        viewModelScope.launch {
+            try {
+                ModelHolder.withActivity(ModelActivity.Generating) {
+                    when {
+                        // Grounding is an explicit choice about *where the answer comes from*, which
+                        // is a question the user genuinely can answer in advance. Tool calling is not.
+                        _ui.value.useRag -> sendGrounded(model, prompt)
+                        toolsAvailable(model) -> sendMaybeToolCall(model, prompt)
+                        else -> sendPlain(model, prompt)
+                    }
+                }
+            } catch (e: Throwable) {
+                val reason = e.message ?: e::class.java.simpleName
+                _ui.value = _ui.value.copy(error = reason)
+                AppSnackbar.error(reason)
+            } finally {
+                _ui.value = _ui.value.copy(generating = false, streaming = "", phase = null)
+            }
+        }
+    }
+
+    private suspend fun sendPlain(
+        model: com.martinkorelic.mobiletransformers.MobileTransformerModel,
+        prompt: String,
+    ) {
+        val raw = StringBuilder()
+        val result = model.generate(
+            prompt = prompt,
+            config = AppConfig.generation.value,
+            callback = object : GenerateCallback {
+                override fun onPartialResult(progress: GenerateProgress) {
+                    // Cleaned for DISPLAY only, off a raw accumulator. Cleaning the displayed string
+                    // and appending to that would feed `trim()` its own output every token, so a
+                    // token ending in a newline — every list item, every paragraph break — would lose
+                    // it and the next token would run straight on.
+                    raw.append(progress.token)
+                    _ui.value = _ui.value.copy(streaming = cleanTurnMarkers(raw.toString()))
+                }
+            },
+        )
+        _ui.value = _ui.value.copy(
+            messages = _ui.value.messages + ChatMessage(
+                text = cleanTurnMarkers(result.text),
+                fromUser = false,
+                turnStats = TurnStats.of(result),
+            ),
+        )
+    }
+
+    /**
+     * Retrieve → assemble → generate, with both halves attached to the answer.
+     *
+     * ### Why this streams
+     *
+     * It did not, and that made the grounded path unusable rather than merely slow. `phase` was set
+     * to "retrieving…" once and then not touched again until the whole turn was over — so the screen
+     * said "retrieving" through the retrieval, through the prompt assembly, and through a decode over
+     * a prompt several hundred tokens longer than a plain one, which is the overwhelming majority of
+     * the wait. The one message shown was wrong for most of the time it was shown, and there was no
+     * other sign of life: no bubble, no tokens, nothing. It reads exactly like a hang.
+     *
+     * Both halves now report: the phase names the retrieval while it runs, then hands over to the
+     * same streaming bubble a plain answer uses.
+     */
+    private suspend fun sendGrounded(
+        model: com.martinkorelic.mobiletransformers.MobileTransformerModel,
+        prompt: String,
+    ) {
+        _ui.value = _ui.value.copy(phase = "retrieving…")
+        val raw = StringBuilder()
+        val grounded = model.generateWithRag(
+            query = prompt,
+            rag = AppConfig.rag.value,
+            generation = AppConfig.generation.value,
+            promptStrategy = PromptAssembler.DEFAULT,
+            // Posted the moment retrieval returns, which is the whole reason this callback is here:
+            // the sources are known long before the answer, and showing them then is what turns a
+            // silent wait into a conversation with a visible first step.
+            retrieveCallback = object : RetrieveCallback {
+                override fun onQueryResults(result: RetrievalResult) {
+                    _ui.value = _ui.value.copy(
+                        messages = _ui.value.messages + ChatMessage(
+                            text = "",
+                            fromUser = false,
+                            retrieval = RetrievalCard(
+                                passages = result.matches.map { SourceCard(it.text, it.score, it.title) },
+                                documents = result.documentTitles,
+                                queryTimeMs = result.queryTimeMs,
+                            ),
+                        ),
+                    )
+                }
+            },
+            callback = object : GenerateCallback {
+                // The first generation event is also the proof retrieval finished — retrieve → assemble
+                // → generate is sequential, so nothing can start generating while a query is open.
+                override fun onStartGeneration(progress: GenerateProgress) {
+                    _ui.value = _ui.value.copy(phase = "generating from ${progress.promptTokenCount} prompt tokens…")
+                }
+
+                override fun onPartialResult(progress: GenerateProgress) {
+                    // Raw accumulator, cleaned for display — see sendPlain for why the reverse loses
+                    // a newline at the end of a token.
+                    raw.append(progress.token)
+                    _ui.value = _ui.value.copy(phase = null, streaming = cleanTurnMarkers(raw.toString()))
+                }
+            },
+        )
+        _ui.value = _ui.value.copy(
+            phase = null,
+            streaming = "",
+            messages = _ui.value.messages + ChatMessage(
+                text = cleanTurnMarkers(grounded.text),
+                fromUser = false,
+                // The passages are NOT repeated here: they are their own turn above this one, posted
+                // when they were found. What stays on the answer is the prompt that produced it —
+                // the retrieval report says what was found, this says what was asked with it.
+                assembledPrompt = grounded.prompt,
+                stats = if (grounded.matches.isEmpty()) "ungrounded — nothing was retrieved" else null,
+                turnStats = TurnStats.of(grounded.generation),
+            ),
+        )
+    }
+
+    /**
+     * Tool calling in the conversation: one turn, with tools declared, rendered according to what
+     * came back.
+     *
+     * Three outcomes, three renderings, and the model picks which one — that is the whole point:
+     *
+     * - [ToolCallResult.NoCall] — it answered in words. An ordinary reply bubble.
+     * - [ToolCallResult.Accepted] — a call this app permits, shown with the intent it *would* fire.
+     * - [ToolCallResult.Rejected] — a call this app does not permit. Also a turn, not an error
+     *   banner: refusing untrusted output is the safety property working, and hiding it would hide
+     *   the one thing worth showing.
+     *
+     * `NoCall` is what makes this usable as the only chat path. It used to be a `Rejected` carrying
+     * "no tool call found in the model's output", so every ordinary sentence rendered as a refusal —
+     * and that message masked the real defect underneath, which was that the JSON parser was being
+     * handed FunctionGemma's grammar and could not have recognised a call in it.
+     */
+    private suspend fun sendMaybeToolCall(
+        model: com.martinkorelic.mobiletransformers.MobileTransformerModel,
+        prompt: String,
+    ) {
+        // Streams like any other turn. The tool-call path passed no callback at all, so on a
+        // tool-capable model — which is every turn for FunctionGemma — the screen sat blank for the
+        // whole generation and the tokens appeared at once at the end. Whether the reply turns out
+        // to be a call is decided *after* it is complete, so there is no reason not to show it
+        // arriving; if it does turn out to be a call, the streamed text is replaced by the card.
+        var lastProgress: GenerateProgress? = null
+        val raw = StringBuilder()
+        val result = model.generateToolCall(
+            instruction = prompt,
+            validator = validator,
+            config = AppConfig.generation.value,
+            callback = object : GenerateCallback {
+                override fun onPartialResult(progress: GenerateProgress) {
+                    lastProgress = progress
+                    // Turn markers are prompt scaffolding, not content: a model that keeps talking
+                    // past its turn would otherwise stream "<end_of_turn>" into the bubble. Cleaned
+                    // off a raw accumulator — see sendPlain.
+                    raw.append(progress.token)
+                    _ui.value = _ui.value.copy(streaming = cleanTurnMarkers(raw.toString()))
+                }
+
+                override fun onCompletion(progress: GenerateProgress) {
+                    lastProgress = progress
+                }
+            },
+        )
+        val message = when (result) {
+            is ToolCallResult.Accepted -> {
+                val intended = result.dryRun()
+                ChatMessage(
+                    text = "",
+                    fromUser = false,
+                    toolCall = ToolCallCard(
+                        accepted = true,
+                        actionName = result.call.actionName,
+                        parameters = result.call.parameters,
+                        intentAction = intended.intent.action ?: "(none)",
+                        raw = result.raw,
+                        intent = intended.intent,
+                        // From the app's own ActionSpec, carried through the validator and the
+                        // binder — so Run can check before firing rather than after.
+                        requiredPermissions = intended.requiredPermissions,
+                    ),
+                    turnStats = TurnStats.of(lastProgress),
+                )
+            }
+            is ToolCallResult.Rejected -> ChatMessage(
+                text = "",
+                fromUser = false,
+                toolCall = ToolCallCard(
+                    accepted = false,
+                    reason = result.reason,
+                    raw = result.raw,
+                ),
+                turnStats = TurnStats.of(lastProgress),
+            )
+            is ToolCallResult.NoCall -> ChatMessage(
+                // The model chose prose. Rendered as prose, with the tool-call framing stripped so a
+                // stray turn marker does not leak into the bubble.
+                text = cleanTurnMarkers(result.raw).ifBlank { "(the model returned nothing)" },
+                fromUser = false,
+                turnStats = TurnStats.of(lastProgress),
+            )
+        }
+        _ui.value = _ui.value.copy(messages = _ui.value.messages + message)
+
+        // Automatic mode fires here, after the card exists, so the conversation shows what ran even
+        // when nobody approved it.
+        val card = message.toolCall
+        if (card != null && card.accepted && _ui.value.toolExecution == ToolExecution.Automatic) {
+            runToolCall(card)
+        }
+    }
+
+    /**
+     * Drop the turn markers a chat model echoes, whichever template it was trained on.
+     *
+     * Two separate things put them in front of a reader:
+     *
+     * - A model that keeps talking past its turn emits its end marker and then carries on with a
+     *   conversation it invented, playing both parts. Only the first turn is this model's answer.
+     * - The end marker IS the eos token for several of these templates (`<|im_end|>` for SmolLM2 and
+     *   Qwen2.5), so it also arrives as the final token of a perfectly normal reply. The engines now
+     *   suppress that one at the emit site; this is the reader-facing net under it, and it is the
+     *   layer that also catches a marker the tokenizer does not recognise as eos.
+     *
+     * A leading role label is stripped only as its own line, which is how the template writes it —
+     * see [ROLE_LABEL_LINES] for why the looser form was wrong.
+     */
+    private fun cleanTurnMarkers(raw: String): String = Companion.cleanTurnMarkers(raw)
+
+    /**
+     * Feed a tool result back and let the model speak about it — the second half of the loop.
+     *
+     * Values are invented by this app, clearly: nothing is executed, so there is no real result to
+     * report. What the turn demonstrates is that the model consumes a `<start_function_response>` and
+     * answers in prose, which is the part a single call cannot show.
+     */
+    fun simulateToolResult(card: ToolCallCard) {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        val action = card.actionName ?: return
+        viewModelScope.launch {
+            _ui.value = _ui.value.copy(generating = true, phase = "feeding the result back…")
+            try {
+              ModelHolder.withActivity(ModelActivity.Generating) {
+                val response = ToolPromptBuilder.functionResponse(
+                    actionName = action,
+                    values = mapOf("status" to "ok"),
+                )
+                val result = model.generate(
+                    prompt = response,
+                    config = AppConfig.generation.value,
+                )
+                _ui.value = _ui.value.copy(
+                    messages = _ui.value.messages + ChatMessage(
+                        text = cleanTurnMarkers(result.text),
+                        fromUser = false,
+                        stats = "after a simulated result for $action",
+                        turnStats = TurnStats.of(result),
+                    ),
+                )
+              }
+            } catch (e: Throwable) {
+                AppSnackbar.error(e.message ?: "could not continue after the tool result")
+            } finally {
+                _ui.value = _ui.value.copy(generating = false, phase = null)
+            }
+        }
+    }
+
+    fun clear() {
+        _ui.value = ChatUiState(useRag = _ui.value.useRag, toolExecution = _ui.value.toolExecution)
+    }
+
+    companion object {
+        /**
+         * Turn markers across the chat templates this app's catalog actually ships.
+         *
+         * ChatML (`<|im_end|>`) for SmolLM2 and Qwen2.5, Gemma's pair for the two Gemma-3 packages,
+         * and `<|endoftext|>` because several tokenizers keep it as a second stop and a merged
+         * adapter can bring it back. Reply text is cut at the FIRST of these that appears.
+         */
+        internal val TURN_MARKERS = listOf(
+            "<|im_end|>",
+            "<|im_start|>",
+            "<end_of_turn>",
+            "<start_of_turn>",
+            "<|endoftext|>",
+        )
+
+        /** A role label the model completed for itself, as it appears at the START of a reply. */
+        private val ROLE_LABEL_LINES = listOf("model\n", "model\r\n", "assistant\n", "assistant\r\n")
+
+        /** See the instance-level doc. Lives here so it is reachable from a JVM test. */
+        internal fun cleanTurnMarkers(raw: String): String {
+            var text = raw
+            for (marker in TURN_MARKERS) text = text.substringBefore(marker)
+            // Gemma's prompt ends with `<start_of_turn>model\n`, and the model routinely completes
+            // that label itself, so a reply can open with a bare "model" line. Matched WITH its
+            // newline: `removePrefix("model")` alone also fires on "model weights are on device",
+            // turning a correct sentence into "weights are on device".
+            for (label in ROLE_LABEL_LINES) {
+                if (text.startsWith(label)) {
+                    text = text.removePrefix(label)
+                    break
+                }
+            }
+            return text.trim()
+        }
+    }
+}
+
+data class ChatUiState(
+    val prompt: String = "",
+    val messages: List<ChatMessage> = emptyList(),
+    val streaming: String = "",
+    val generating: Boolean = false,
+    /** What a non-streaming turn is doing right now, so a long wait is legible rather than frozen. */
+    val phase: String? = null,
+    val useRag: Boolean = false,
+    val toolExecution: ToolExecution = ToolExecution.Approve,
+    val ingesting: Boolean = false,
+    val ingestNote: String? = null,
+    val ingestedDocuments: List<String> = emptyList(),
+    /** Non-null while a tool call waits for the system permission dialog. */
+    val pendingPermissions: PendingPermissions? = null,
+    val error: String? = null,
+)
+
+/**
+ * One turn.
+ *
+ * Sources, the assembled prompt and a tool call hang off the message that produced them rather than
+ * off the screen, which is what lets a conversation keep more than one grounded answer.
+ */
+data class ChatMessage(
+    val text: String,
+    val fromUser: Boolean,
+    /** Non-null when this turn IS the retrieval report — see [RetrievalCard]. */
+    val retrieval: RetrievalCard? = null,
+    val assembledPrompt: String? = null,
+    val toolCall: ToolCallCard? = null,
+    val stats: String? = null,
+    /** Structured per-turn numbers; [stats] stays for the one-off notes that are not measurements. */
+    val turnStats: TurnStats? = null,
+)
+
+data class SourceCard(
+    val text: String,
+    val score: Double,
+    /** The file this passage was ingested from, e.g. `notes.md`. Blank when the store did not keep one. */
+    val title: String = "",
+)
+
+/**
+ * What retrieval found, as a turn of its own — posted **before** the answer it will produce.
+ *
+ * ### Why this is a message rather than a section of the answer
+ *
+ * Grounding is two steps, and only the first is fast. Hanging the sources off the answer meant they
+ * appeared at the same moment as the answer, i.e. after the whole slow half was over — so the part
+ * that explains where a grounded reply comes from arrived too late to set any expectation about it,
+ * and the wait itself still showed nothing. Retrieval finishing is a real event with a real result,
+ * and the conversation is the honest place to say so.
+ *
+ * It also makes a bad grounded answer diagnosable in the ordinary reading direction: you see what was
+ * found, and then what the model did with it.
+ */
+data class RetrievalCard(
+    val passages: List<SourceCard>,
+    /** Distinct source files, best-scoring first. Empty when nothing was attributed. */
+    val documents: List<String>,
+    val queryTimeMs: Long = 0L,
+) {
+    /** e.g. `"Found 4 passages in 2 documents"`, or the honest empty answer. */
+    val headline: String
+        get() = when {
+            passages.isEmpty() -> "No matching passages — the answer will be ungrounded"
+            documents.isEmpty() -> "Found ${passages.size} ${plural(passages.size, "passage")}"
+            else ->
+                "Found ${passages.size} ${plural(passages.size, "passage")} in " +
+                    "${documents.size} ${plural(documents.size, "document")}"
+        }
+
+    private fun plural(n: Int, word: String) = if (n == 1) word else "${word}s"
+}
+
+/**
+ * The per-turn numbers shown under an assistant message.
+ *
+ * Speed alone was all the app reported, and speed does not answer the question that actually
+ * predicts trouble: how full the window is. A turn that is fast and at 95% of context is about to
+ * start truncating; one that is slow at 3% is merely slow.
+ */
+data class TurnStats(
+    val tokens: Int,
+    val tokensPerSecond: Double,
+    val contextUsed: Int,
+    val contextLimit: Int,
+) {
+    /** e.g. `"37 tokens · 4.2 tok/s · context 512 / 32768 (2%)"`, degrading as parts go unknown. */
+    fun render(): String = buildString {
+        append("$tokens tokens")
+        if (tokensPerSecond > 0) append(" · %.1f tok/s".format(tokensPerSecond))
+        if (contextLimit > 0) {
+            val pct = (contextUsed * 100.0 / contextLimit)
+            append(" · context %,d / %,d (%.0f%%)".format(contextUsed, contextLimit, pct))
+        } else if (contextUsed > 0) {
+            append(" · context %,d tokens".format(contextUsed))
+        }
+    }
+
+    companion object {
+        fun of(result: com.martinkorelic.mobiletransformers.runtime.GenerationResult?) = result?.let { TurnStats(
+            tokens = it.tokenCount,
+            tokensPerSecond = it.avgTokensPerSecond,
+            contextUsed = it.contextUsedTokens,
+            contextLimit = it.contextLimit,
+        ) }
+
+        /** From the last streamed progress, for paths that have no GenerationResult in hand. */
+        fun of(progress: GenerateProgress?) = progress?.let {
+            TurnStats(
+                tokens = it.totalDecodedTokens,
+                tokensPerSecond = it.avgTokensPerSecond,
+                contextUsed = it.promptTokenCount + it.totalDecodedTokens,
+                contextLimit = it.contextLimit,
+            )
+        }
+    }
+}
+
+/** An accepted or refused tool call, rendered inline. Accepted and refused are peers. */
+data class ToolCallCard(
+    val accepted: Boolean,
+    val actionName: String? = null,
+    val parameters: Map<String, String> = emptyMap(),
+    val intentAction: String? = null,
+    val reason: String? = null,
+    val raw: String = "",
+    /**
+     * The intent this call would fire, or null for a refusal.
+     *
+     * Held so the app can run it on request. It was built by `IntentBinder` from the app's own
+     * `ActionSpec`, so what is stored here is not model output.
+     */
+    val intent: android.content.Intent? = null,
+    /** Set once the app has actually started it. */
+    val executed: Boolean = false,
+    /**
+ * Permissions the app must hold to start [intent], from the app's own `ActionSpec`.
+ *
+ * Carried on the card so the Run button can check before firing rather than discovering the
+ * answer as a `SecurityException` after the tap.
+ */
+    val requiredPermissions: List<String> = emptyList(),
+            )
+
+/**
+ * A tool call waiting on the system permission dialog.
+ *
+ * The request has to be launched from the Activity — a ViewModel holds an application context, which
+ * cannot show a permission prompt — so this is the ViewModel asking the screen to do it, holding on
+ * to the card so the call can be resumed if the user agrees.
+ */
+data class PendingPermissions(
+    val card: ToolCallCard,
+    val permissions: List<String>,
+)
+
+/** What happens when a tool call is accepted. */
+enum class ToolExecution(val label: String) {
+    /** Show it and wait for a tap. The default: a validated call is still an action on the device. */
+    Approve("Ask before running"),
+
+    /** Fire it as soon as it is accepted. */
+    Automatic("Run automatically"),
+}
+
+/** What the engine picker renders: the selected engine plus the ones this device/package allows. */
+data class EnginePickerState(
+    val selected: InferenceEngine,
+    val available: Set<InferenceEngine>,
+) {
+    /**
+     * GenAI missing is the common case, and the honest reason matters: it is either not in the package
+     * or not on the device. Both collapse to "not selectable here", which is what the facade reports.
+     */
+    val genAiNote: String?
+        get() = if (InferenceEngine.GENAI in available) {
+            null
+        } else {
+            "GenAI is not selectable: the installed package ships no genai_config.json, or the GenAI " +
+                "native probe failed on this device. Native is the guaranteed floor."
+        }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ClassifyViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ClassifyViewModel.kt
new file mode 100644
index 0000000..b06382e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ClassifyViewModel.kt
@@ -0,0 +1,94 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.app.ModelActivity
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.runtime.LabelScore
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * The encoder story's payoff: ask a fine-tuned classifier something and see the class it picks.
+ *
+ * The encoder path is complete — `text-classification` export, a trainable head, `classify()` on
+ * the facade, `ClassifierSession` under it — and then had nowhere to show it. A classifier could be
+ * pulled and fine-tuned on device and never asked a single question, which made the encoder work
+ * unfalsifiable from the app.
+ *
+ * ### Why the screen keeps the previous result
+ *
+ * [ClassifyUiState.previous] holds the last run's scores while a new one is in flight. The interesting
+ * comparison for this screen is *before versus after training the head*, and a screen that blanks on
+ * every submit makes the user hold both distributions in their head. Keeping the last one on screen is
+ * the cheap version of the before/after the encoder story wants.
+ */
+class ClassifyViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(ClassifyUiState())
+    val ui: StateFlow<ClassifyUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    fun onTextChanged(value: String) {
+        _ui.value = _ui.value.copy(text = value)
+    }
+
+    fun submit() {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        val text = _ui.value.text.trim()
+        if (text.isEmpty() || _ui.value.running) return
+
+        viewModelScope.launch {
+            _ui.value = _ui.value.copy(
+                running = true,
+                error = null,
+                // Demote rather than discard, so the comparison survives the next run.
+                previous = _ui.value.scores.takeIf { it.isNotEmpty() },
+                previousText = _ui.value.classifiedText,
+            )
+            try {
+                val result = ModelHolder.withActivity(ModelActivity.Generating) {
+                    model.classify(text = text, topK = TOP_K)
+                }
+                _ui.value = _ui.value.copy(
+                    scores = result.top,
+                    classifiedText = text,
+                )
+            } catch (e: Throwable) {
+                // Named, not swallowed: the most likely failure here is a package whose head has no
+                // id2label, and `classify()` says exactly that. Paraphrasing loses the diagnosis.
+                _ui.value = _ui.value.copy(error = e.message ?: e::class.java.simpleName)
+            } finally {
+                _ui.value = _ui.value.copy(running = false)
+            }
+        }
+    }
+
+    fun clear() {
+        _ui.value = ClassifyUiState(text = _ui.value.text)
+    }
+
+    companion object {
+        /** Enough to show a distribution rather than just a winner; a head with fewer returns fewer. */
+        const val TOP_K = 5
+    }
+}
+
+data class ClassifyUiState(
+    val text: String = "The battery lasts all day and the screen is gorgeous.",
+    val running: Boolean = false,
+    /** Highest probability first — `ClassificationResult.top` is already sorted. */
+    val scores: List<LabelScore> = emptyList(),
+    /** The input [scores] describes, so the result cannot silently re-label edited text. */
+    val classifiedText: String = "",
+    val previous: List<LabelScore>? = null,
+    val previousText: String = "",
+    val error: String? = null,
+) {
+    val best: LabelScore? get() = scores.firstOrNull()
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ConfigurationViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ConfigurationViewModel.kt
new file mode 100644
index 0000000..5dfd09c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ConfigurationViewModel.kt
@@ -0,0 +1,243 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.content.Context
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.Tasks
+import com.martinkorelic.mobiletransformers.app.AppConfig
+import com.martinkorelic.mobiletransformers.app.AppSnackbar
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.config.DatasetConfig
+import com.martinkorelic.mobiletransformers.config.DeviceConfig
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import com.martinkorelic.mobiletransformers.config.RagConfig
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.constants.CoreConfigId
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.constants.MemoryConfigId
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.constants.SearchType
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.packages.PackagePaths
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * The ~45 knobs, expressed through the **public** config types only.
+ *
+ * The old Configuration screen was 1,091 lines editing `ORTGenerationConfig`, `ORTTrainingConfig`,
+ * `ORTRagConfig`, `SamplingOptions`, `DeviceOptions` and `SchedulerConfig` directly. Everything it
+ * could express is reachable here through `GenerationConfig`/`TrainConfig`/`RagConfig`/`DatasetConfig`
+ * — which is the check this screen exists to perform. A knob that turned out to be unreachable would
+ * be a facade gap to record, not a licence to import an `ORT*` type.
+ */
+class ConfigurationViewModel : ViewModel() {
+
+    val generation: StateFlow<GenerationConfig> = AppConfig.generation
+    val train: StateFlow<TrainConfig> = AppConfig.train
+    val rag: StateFlow<RagConfig> = AppConfig.rag
+    val dataset: StateFlow<DatasetConfig> = AppConfig.dataset
+    val device: StateFlow<DeviceConfig> = AppConfig.device
+    val peft: StateFlow<PeftConfig> = AppConfig.peft
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    /** The task names the trainer actually dispatches on — not a list retyped into the UI. */
+    val taskOptions: List<Tasks.Task> = Tasks.TASKS
+
+    /**
+     * The `.jsonl` files present in the loaded package's `train/` stage.
+     *
+     * `DatasetConfig.trainFile` names a file the trainer opens at
+     * `<cacheDir>/<repoId>/train/<trainFile>.jsonl`, and the field was free text — so the only way to
+     * discover a wrong name was a failed run. Listing what is actually there turns it into a choice,
+     * and shows an empty list when the answer is "you have not installed a dataset yet", which is the
+     * real diagnosis in the common case.
+     */
+    fun availableTrainFiles(context: Context): List<String> {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return emptyList()
+        val trainDir = PackagePaths.forCache(
+            context.filesDir,
+            PackageFormat.sanitizeRepoId(model.repoId),
+        ).train
+        if (!trainDir.isDirectory) return emptyList()
+        return trainDir.listFiles()
+            .orEmpty()
+            .filter { it.isFile && it.name.endsWith(".jsonl") }
+            .map { it.name.removeSuffix(".jsonl") }
+            .sorted()
+    }
+
+    // --- device -------------------------------------------------------------------------------
+    fun setExecutionProvider(v: ExecutionProvider) = AppConfig.updateDevice { it.copy(executionProvider = v) }
+
+    fun setCoreConfig(v: CoreConfigId) = AppConfig.updateDevice { it.copy(coreConfigId = v) }
+
+    fun setMemoryConfig(v: MemoryConfigId) = AppConfig.updateDevice { it.copy(memoryConfigId = v) }
+
+    fun setProfiling(v: Boolean) = AppConfig.updateDevice { it.copy(enableProfiling = v) }
+
+    // --- peft ---------------------------------------------------------------------------------
+
+    /**
+     * Select a PEFT method and validate it against the installed package.
+     *
+     * `applyPeft` is the SDK's own check that the requested method matches what the package was
+     * exported with — PEFT topology is baked in at export time, so a mismatch is a fact about the
+     * package, not something the device can fix. Reporting it here, at selection, is the difference
+     * between a clear refusal and a training run that fails for a reason recorded in a config file.
+     */
+    fun setPeft(v: PeftConfig) {
+        AppConfig.updatePeft(v)
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        viewModelScope.launch {
+            runCatching { model.applyPeft(v) }
+                .onSuccess { AppSnackbar.success("PEFT set to ${v.label}") }
+                .onFailure { AppSnackbar.error(it.message ?: "this package does not support ${v.label}") }
+        }
+    }
+
+    fun setPeftRank(rank: Int) = setPeft(AppConfig.peft.value.withRank(rank))
+
+    fun setPeftAlpha(alpha: Int) = setPeft(AppConfig.peft.value.withAlpha(alpha))
+
+    // --- generation ---------------------------------------------------------------------------
+    fun setMaxNewTokens(v: Int) = AppConfig.updateGeneration { it.copy(maxNewTokens = v.coerceAtLeast(1)) }
+
+    fun setSamplingMethod(v: SamplingMethod) =
+        AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(method = v)) }
+
+    fun setTemperature(v: Float) =
+        AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(temperature = v)) }
+
+    fun setTopK(v: Int) = AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(topK = v)) }
+
+    fun setTopP(v: Float) = AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(topP = v)) }
+
+    fun setSeed(v: Int) = AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(seed = v)) }
+
+    fun setSystemPrompt(v: String) =
+        AppConfig.updateGeneration { it.copy(systemPrompt = v.ifBlank { null }) }
+
+    fun setLoadMerged(v: Boolean) = AppConfig.updateGeneration { it.copy(loadMerged = v) }
+
+    // --- training -----------------------------------------------------------------------------
+    fun setEpochs(v: Int) = AppConfig.updateTrain { it.copy(epochs = v.coerceAtLeast(1)) }
+
+    fun setBatchSize(v: Int) = AppConfig.updateTrain { it.copy(batchSize = v.coerceAtLeast(1)) }
+
+    /**
+     * `maxSteps` is an **upper bound**, not a target: training also stops at the end of the epoch, so
+     * `rows / batchSize` wins when it is smaller. Measured the hard way on 2026-08-14 — a run asking
+     * for 120 steps took 54 because the dataset held 108 rows.
+     */
+    fun setMaxSteps(v: Int?) = AppConfig.updateTrain { it.copy(maxSteps = v) }
+
+    /**
+     * The default is 4, and `optimizerStep` fires on `globalStep % gradAccumSteps == 0` — so a short
+     * bounded run at the default can complete, report success on every callback, and apply **no
+     * update at all**. Worth surfacing rather than burying.
+     */
+    fun setGradientAccumulationSteps(v: Int) =
+        AppConfig.updateTrain { it.copy(gradientAccumulationSteps = v.coerceAtLeast(1)) }
+
+    fun setLearningRate(v: Float) = AppConfig.updateTrain { it.copy(learningRate = v) }
+
+    fun setScheduler(v: SchedulerType) = AppConfig.updateTrain { it.copy(scheduler = v) }
+
+    fun setWarmupSteps(v: Int) = AppConfig.updateTrain { it.copy(warmupSteps = v.coerceAtLeast(0)) }
+
+    fun setMergeAtEnd(v: Boolean) = AppConfig.updateTrain { it.copy(mergeAtEnd = v) }
+
+    fun setResumeFromState(v: Boolean) = AppConfig.updateTrain { it.copy(resumeFromState = v) }
+
+    // --- rag ----------------------------------------------------------------------------------
+    fun setTopKRag(v: Int) = AppConfig.updateRag { it.copy(topK = v.coerceAtLeast(1)) }
+
+    fun setSearchType(v: SearchType) = AppConfig.updateRag { it.copy(searchType = v) }
+
+    fun setMinScore(v: Double) = AppConfig.updateRag { it.copy(minScore = v) }
+
+    fun setChunkSize(v: Int) = AppConfig.updateRag { it.copy(chunkSize = v.coerceAtLeast(1)) }
+
+    fun setChunkOverlap(v: Int) = AppConfig.updateRag { it.copy(chunkOverlap = v.coerceAtLeast(0)) }
+
+    // --- dataset ------------------------------------------------------------------------------
+    fun setTrainFile(v: String) = AppConfig.updateDataset { it.copy(trainFile = v) }
+
+    fun setTask(v: String) = AppConfig.updateDataset { it.copy(task = v.ifBlank { null }) }
+
+    fun setMaxSequenceLength(v: Int) =
+        AppConfig.updateDataset { it.copy(maxSequenceLength = v.coerceAtLeast(1)) }
+
+    fun setMaxDatasetLength(v: Int) =
+        AppConfig.updateDataset { it.copy(maxDatasetLength = v.coerceAtLeast(1)) }
+
+    fun reset() = AppConfig.reset()
+}
+
+/**
+ * The PEFT methods as a pickable list.
+ *
+ * `PeftConfig` is a sealed class with per-variant fields, which is right for the API and awkward for
+ * a picker. This flattens it to the choice a user actually makes — which method — while preserving
+ * the current rank and alpha across a switch, so changing method does not silently reset them.
+ */
+val peftOptions: List<String> = listOf("lora", "mars-opt0", "mars-opt1", "mars-quantized")
+
+val PeftConfig.label: String
+    get() = when (this) {
+        is PeftConfig.Lora -> "lora"
+        is PeftConfig.MarsOpt0 -> "mars-opt0"
+        is PeftConfig.MarsOpt1 -> "mars-opt1"
+        is PeftConfig.MarsQuantized -> "mars-quantized"
+    }
+
+/** Build the named method, carrying [rank]/[alpha] over so a method switch is not also a reset. */
+fun peftOf(label: String, rank: Int, alpha: Int): PeftConfig = when (label) {
+    "mars-opt0" -> PeftConfig.MarsOpt0(rank = rank, alpha = alpha)
+    "mars-opt1" -> PeftConfig.MarsOpt1(rank = rank, alpha = alpha)
+    "mars-quantized" -> PeftConfig.MarsQuantized(rank = rank, alpha = alpha)
+    else -> PeftConfig.Lora(rank = rank, alpha = alpha)
+}
+
+fun PeftConfig.withRank(rank: Int): PeftConfig = peftOf(label, rank, alpha)
+
+fun PeftConfig.withAlpha(alpha: Int): PeftConfig = peftOf(label, rank, alpha)
+
+/**
+ * How a PEFT method is spelled for a reader: `LoRA`, `MARS`, `LoRA-XS`.
+ *
+ * **Display only.** The lowercase forms are wire values — they are the `PEFTMethod` enum mirrored
+ * from Python and pinned by `make parity`, they are what a manifest's `peftMethods` contains, and
+ * they are what [peftOf] looks up. Nothing here may change them; this is the one place that decides
+ * how they are *shown*, so the casing cannot drift between the catalog chip and the picker.
+ *
+ * They are acronyms — Low-Rank Adaptation, Multi-Adapter Rank Sharing — and rendering the project's
+ * own method as "mars" reads like a typo rather than a name. An unknown value passes through
+ * unchanged rather than being guessed at, so a method added to the SDK shows its wire value instead
+ * of silently displaying as something else.
+ */
+fun peftDisplayName(wire: String): String = when (wire.lowercase()) {
+    "lora" -> "LoRA"
+    "lora-xs" -> "LoRA-XS"
+    "mars" -> "MARS"
+    "mars-opt0" -> "MARS-opt0"
+    "mars-opt1" -> "MARS-opt1"
+    "mars-quantized" -> "MARS-quantized"
+    "all" -> "Full fine-tune"
+    "nolora" -> "No adapters"
+    else -> wire
+}
+
+/** What each method costs and requires, shown under the picker. */
+fun peftDescription(label: String): String = when (label) {
+    "lora" -> "low-rank adapters on the attention projections; the default and the widest support"
+    "mars-opt0" -> "MARS, fully trainable, no quantization"
+    "mars-opt1" -> "MARS, partially trainable (frozen + fused down-proj), no quantization"
+    "mars-quantized" -> "MARS with 8- or 4-bit weights; smallest memory, narrowest package support"
+    else -> ""
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/FederatedViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/FederatedViewModel.kt
new file mode 100644
index 0000000..e1329e2
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/FederatedViewModel.kt
@@ -0,0 +1,124 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.app.AppConfig
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.config.TrainConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConfig
+import com.martinkorelic.mobiletransformers.federated.FederatedConsent
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * One federated round: import → train locally → export, with the consent gate visible.
+ *
+ * ### The disabled state is the honest default
+ *
+ * `BuildConfig.FEDERATION_ENABLED` is **false** in shipped builds, and this screen shows that rather
+ * than hiding the feature. Pressing Run in such a build produces a `FederatedConsentException` naming
+ * the missing protection, which is exactly what an integrator needs to see — so the screen surfaces the
+ * refusal instead of pre-emptively greying everything out and explaining nothing.
+ *
+ * ### Nothing is uploaded
+ *
+ * The round returns bytes. Handing them to a gateway is deliberately the caller's problem, which is
+ * what lets the whole loop run against a local `federated serve` (or over `adb`) with no server in the
+ * app. This screen stops at "here is the payload and its size" — `payloadBytes` being the agreed
+ * measurement.
+ */
+class FederatedViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(FederatedUiState())
+    val ui: StateFlow<FederatedUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    fun onGatewayChanged(value: String) {
+        _ui.value = _ui.value.copy(gatewayUrl = value)
+    }
+
+    fun onTokenChanged(value: String) {
+        _ui.value = _ui.value.copy(token = value)
+    }
+
+    fun onConsentChanged(granted: Boolean) {
+        _ui.value = _ui.value.copy(consentGranted = granted)
+    }
+
+    fun runRound() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        val s = _ui.value
+        viewModelScope.launch {
+            _ui.value = s.copy(running = true, error = null, result = null)
+            try {
+                val result = loaded.model.federatedRound(
+                    config = FederatedConfig(
+                        gatewayUrl = s.gatewayUrl,
+                        clientAuthToken = s.token,
+                        // Consent carries the policy version it was granted against, so a policy
+                        // change invalidates it rather than riding on the old agreement.
+                        consent = if (s.consentGranted) {
+                            FederatedConsent(
+                                granted = true,
+                                policyVersion = "1.0",
+                                grantedAtEpochMs = System.currentTimeMillis(),
+                            )
+                        } else {
+                            FederatedConsent.NONE
+                        },
+                    ),
+                    // Round 0 has nothing to import: a device must be able to join a cohort that has
+                    // not published an aggregate yet.
+                    globalRecord = null,
+                    roundNumber = s.round,
+                    localTraining = { _ ->
+                        loaded.model.train(
+                            dataset = AppConfig.dataset.value,
+                            config = AppConfig.train.value.copy(maxSteps = 5, mergeAtEnd = false),
+                        )
+                        Unit
+                    },
+                )
+                _ui.value = _ui.value.copy(
+                    result = RoundSummary(
+                        round = result.round,
+                        importedTensors = result.importedTensors,
+                        payloadBytes = result.payloadBytes,
+                        trainedLocally = result.trainedLocally,
+                    ),
+                    round = s.round + 1,
+                )
+            } catch (e: Throwable) {
+                // Includes the fail-closed consent/TLS/auth refusals, which name the missing protection.
+                _ui.value = _ui.value.copy(error = e.message ?: e::class.java.simpleName)
+            } finally {
+                _ui.value = _ui.value.copy(running = false)
+            }
+        }
+    }
+}
+
+data class FederatedUiState(
+    val gatewayUrl: String = "https://localhost:8443",
+    val token: String = "",
+    val consentGranted: Boolean = false,
+    val round: Int = 0,
+    val running: Boolean = false,
+    val result: RoundSummary? = null,
+    val error: String? = null,
+)
+
+data class RoundSummary(
+    val round: Int,
+    val importedTensors: Int,
+    val payloadBytes: Int,
+    val trainedLocally: Boolean,
+)
+
+/** Kept beside the state so the screen's copy and the SDK's default cannot drift apart. */
+val federationDefaultTrainConfig: TrainConfig = TrainConfig(maxSteps = 5, mergeAtEnd = false)
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ModelsViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ModelsViewModel.kt
new file mode 100644
index 0000000..d8177c1
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/ModelsViewModel.kt
@@ -0,0 +1,268 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.app.AppSnackbar
+import com.martinkorelic.mobiletransformers.app.DownloadUi
+import com.martinkorelic.mobiletransformers.app.ModelCatalog
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * The Models / Hub screen.
+ *
+ * **This screen exists because the old sample app could not be used by anyone.** It assumed a package
+ * already `adb push`ed into place, which no real user can do, so on a clean install every other screen
+ * was dead. Pulling a package by repo id is therefore the app's entry point, not a convenience.
+ */
+class ModelsViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(ModelsUiState())
+    val ui: StateFlow<ModelsUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    /** Held by [ModelHolder], not here, so a pull stays visible after navigating away from Models. */
+    val download: StateFlow<DownloadUi?> = ModelHolder.download
+
+    /**
+     * Whether this build carries an `HF_TOKEN`, so a private-repo pull that 401s is diagnosable.
+     *
+     * The boolean, never the token: "you have no credentials" and "your credentials were rejected" are
+     * different problems with the same symptom, and a screen that shows neither leaves the user
+     * guessing. Rendering the token itself would put it on screen and in screenshots for no benefit.
+     */
+    val hasHfToken: Boolean get() = ModelHolder.hasHfToken
+
+    init {
+        refresh()
+    }
+
+    fun refresh() {
+        ModelHolder.refreshInstalled(getApplication())
+        _ui.value = _ui.value.copy(
+            installed = ModelHolder.installed.value.map {
+                InstalledRow(
+                    repoId = it.repoId,
+                    sanitizedRepoId = it.sanitizedRepoId,
+                    baseModelId = it.baseModelId,
+                    variantIds = it.variantIds,
+                    installedVariantId = it.installedVariantId,
+                    requestedFeatures = it.requestedFeatures,
+                    sizeBytes = it.sizeBytes,
+                    hasManifest = it.hasManifest,
+                )
+            },
+        )
+    }
+
+    fun onRepoIdChanged(value: String) {
+        _ui.value = _ui.value.copy(repoId = value)
+    }
+
+    fun onTrainingRequestedChanged(value: Boolean) {
+        _ui.value = _ui.value.copy(requestTraining = value)
+    }
+
+    /**
+     * RAG is a **download-time** decision, not a runtime toggle.
+     *
+     * The embedding encoder lives in its own `rag` feature group (~91 MB), and `DownloadPlanner` only
+     * fetches that group when the feature is requested. Without this the Chat screen's RAG switch was
+     * structurally dead: no encoder was ever downloaded, so ingest had nothing to embed with and every
+     * grounded query returned zero sources. Asking here, where the cost is visible next to the other
+     * groups, is the honest place for it.
+     */
+    fun onRagRequestedChanged(value: Boolean) {
+        _ui.value = _ui.value.copy(requestRag = value)
+    }
+
+    fun onWifiOnlyChanged(value: Boolean) {
+        _ui.value = _ui.value.copy(wifiOnly = value)
+    }
+
+    /**
+     * Drop the Wi-Fi requirement and restart the queued pull on whatever connection there is.
+     *
+     * Offered from the download card when the worker is parked on its network constraint. A queued
+     * download is the correct behaviour but an indefinite one, and the switch that governs it sits
+     * inside the Advanced disclosure — which someone who tapped Install on a catalog card has never
+     * opened. Without this the only exits are Cancel or finding Wi-Fi.
+     *
+     * The existing worker must be cancelled first: constraints are fixed at enqueue time, so
+     * re-enqueuing under the same unique name without cancelling leaves the original request in
+     * place, still waiting. The `.partial` files survive, so this resumes rather than restarts.
+     */
+    fun retryWithoutWifiRequirement() {
+        val repoId = _ui.value.repoId
+        ModelHolder.cancelBackgroundDownload(getApplication(), repoId)
+        pullJob?.cancel()
+        pullJob = null
+        _ui.value = _ui.value.copy(wifiOnly = false, message = null)
+        loadSelected(repoId)
+    }
+
+    /**
+     * The in-flight pull, so it can be cancelled.
+     *
+     * Without a handle there was no way to stop a download at all: `viewModelScope.launch` outlives
+     * every screen the user can navigate to, so starting a 4 GB pull by mistake meant waiting it out
+     * or killing the app. The partial files survive cancellation and `Range`-resume picks them up.
+     */
+    private var pullJob: Job? = null
+
+    /** Pull-if-absent then load, reporting download progress through the facade's new callback. */
+    fun loadSelected(repoId: String = _ui.value.repoId) {
+        if (repoId.isBlank()) {
+            _ui.value = _ui.value.copy(message = "enter a repo id first, e.g. HuggingFaceTB/SmolLM2-135M-Instruct")
+            return
+        }
+        if (pullJob?.isActive == true) {
+            _ui.value = _ui.value.copy(message = "a pull is already running — cancel it first")
+            return
+        }
+        pullJob = viewModelScope.launch {
+            _ui.value = _ui.value.copy(message = null)
+            val features = buildSet {
+                add(ModelFeature.Inference)
+                if (_ui.value.requestTraining) add(ModelFeature.Training)
+                if (_ui.value.requestRag) add(ModelFeature.Rag)
+            }
+            try {
+                // Background rather than in-scope: the pull now survives leaving the app, which is
+                // the whole reason PackageDownloadWorker exists. Loading still happens through the
+                // one shared path once the worker reports Finished.
+                ModelHolder.loadInBackground(
+                    context = getApplication(),
+                    repoId = repoId,
+                    engine = _ui.value.engine,
+                    features = features,
+                    wifiOnly = _ui.value.wifiOnly,
+                )
+            } catch (cancellation: CancellationException) {
+                // Cancelling is a user action with a normal outcome, not an error: say what survived.
+                _ui.value = _ui.value.copy(
+                    message = "download cancelled — partial files are kept, so pulling again resumes " +
+                        "from where it stopped",
+                )
+                AppSnackbar.info("Download cancelled — it will resume where it stopped")
+                throw cancellation
+            } finally {
+                refresh()
+            }
+        }
+    }
+
+    /**
+     * Install a catalog entry: request exactly the feature groups it declares, then load it.
+     *
+     * The entry's own `features` drive the request rather than whatever the manual toggles happen to
+     * be set to — a catalog row that says it ships a train stage should install one without the user
+     * first discovering that a switch on another tab governs it.
+     */
+    fun installFromCatalog(entry: ModelCatalog.Entry) {
+        _ui.value = _ui.value.copy(
+            repoId = entry.repoId,
+            requestTraining = entry.supportsTraining,
+            requestRag = entry.supportsRag,
+        )
+        loadSelected(entry.repoId)
+    }
+
+    /**
+ * Stop the in-flight pull, keeping the `.partial` files so a retry resumes.
+ *
+ * Cancels the WORKER as well as the coroutine observing it. Cancelling only the coroutine would
+ * detach the UI from a download that kept running — which is the failure mode background work
+ * introduces and the reason this is not just `pullJob?.cancel` any more.
+ */
+    fun cancelDownload() {
+        ModelHolder.cancelBackgroundDownload(getApplication(), _ui.value.repoId)
+        pullJob?.cancel()
+        pullJob = null
+    }
+
+    fun onEngineChanged(engine: InferenceEngine) {
+        _ui.value = _ui.value.copy(engine = engine)
+    }
+
+    fun unload() {
+        viewModelScope.launch {
+            ModelHolder.close()
+            refresh()
+        }
+    }
+}
+
+data class ModelsUiState(
+    val repoId: String = "HuggingFaceTB/SmolLM2-135M-Instruct",
+    val requestTraining: Boolean = false,
+    val requestRag: Boolean = false,
+    /**
+ * Constrain the background pull to unmetered networks.
+ *
+ * Visible rather than implicit: `PackageDownloadWorker` defaults `requireUnmetered` to true, so on
+ * mobile data the work sits in `ENQUEUED` indefinitely and looks exactly like a hang. A switch is
+ * the difference between "waiting for Wi-Fi" and "broken".
+ */
+    val wifiOnly: Boolean = true,
+    /**
+     * The engine to load with. Was hardcoded to `NATIVE` at the call site, which made the Chat
+     * screen's engine picker decorative — GenAI could be *reported* as available and never selected.
+     */
+    val engine: InferenceEngine = InferenceEngine.NATIVE,
+    val installed: List<InstalledRow> = emptyList(),
+    val message: String? = null,
+) {
+    /** The empty state the whole app hangs off: nothing installed, nothing to do but pull. */
+    val isEmpty: Boolean get() = installed.isEmpty()
+}
+
+data class InstalledRow(
+    /**
+     * The repo id to load this row with.
+     *
+     * Emphatically NOT [baseModelId]. This screen used to load `baseModelId ?: sanitizedRepoId`, and
+     * the manifest's `baseModelId` names the model a package was exported *from*, not the repo it was
+     * pulled *from* — so tapping Load on `mobiletransformers/functiongemma-270m-it` asked for
+     * `google/functiongemma-270m-it`, resolved to a cache directory that does not exist, and reported
+     * the package as not installed while it sat one directory over. `CacheIndex` now records the
+     * installing repo id, and this is it.
+     */
+    val repoId: String,
+    val sanitizedRepoId: String,
+    val baseModelId: String?,
+    val variantIds: List<String>,
+    val installedVariantId: String? = null,
+    val requestedFeatures: List<String> = emptyList(),
+    val sizeBytes: Long,
+    val hasManifest: Boolean,
+) {
+    val sizeMb: Long get() = sizeBytes / (1024 * 1024)
+
+    /**
+     * A package without a manifest is a legacy or hand-pushed directory. It still loads, but variant
+     * selection and capability reporting have nothing to read — worth showing rather than hiding,
+     * because it explains why such a package offers no variants.
+     */
+    val subtitle: String
+        get() = buildString {
+            append("${sizeMb} MB")
+            baseModelId?.let { append(" · base: $it") }
+            when {
+                installedVariantId != null -> append(" · variant: $installedVariantId")
+                variantIds.isNotEmpty() -> append(" · variants: ${variantIds.joinToString(", ")}")
+            }
+            if (requestedFeatures.isNotEmpty()) append(" · pulled with: ${requestedFeatures.joinToString(", ")}")
+            if (!hasManifest) append(" · no manifest (legacy layout)")
+        }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/RetrievalViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/RetrievalViewModel.kt
new file mode 100644
index 0000000..862b432
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/RetrievalViewModel.kt
@@ -0,0 +1,175 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import android.net.Uri
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.app.AppConfig
+import com.martinkorelic.mobiletransformers.app.AppSnackbar
+import com.martinkorelic.mobiletransformers.app.ModelActivity
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.app.SampleData
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+import java.io.File
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * Retrieval on its own: a query in, the closest passages out, and nothing generated.
+ *
+ * `MobileTransformerModel.retrieve()` has existed since retrieval did, and nothing in the app called
+ * it — the only way to see retrieval was to turn on grounding in Chat and read the source cards
+ * attached to an answer. That conflates two things that fail for different reasons. When a grounded
+ * answer is wrong, there is no way to tell whether retrieval returned the wrong passages or the model
+ * ignored the right ones, because the only view of retrieval is filtered through generation.
+ *
+ * This screen is the unfiltered view, and it is also the only part of the retrieval story an **encoder
+ * package** can show at all: `all-MiniLM-L6-v2` has no generative head, so Chat is hidden for it and
+ * grounding is unreachable. Ingestion lives here too, for the same reason — a store you fill is a
+ * property of retrieval, not of a conversation.
+ */
+class RetrievalViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(RetrievalUiState())
+    val ui: StateFlow<RetrievalUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    /** Queries whose best match is a different bundled document each time. */
+    val exampleQueries: List<String> = SampleData.RAG_EXAMPLE_QUERIES
+
+    fun onQueryChanged(value: String) {
+        _ui.value = _ui.value.copy(query = value)
+    }
+
+    fun search() {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        val query = _ui.value.query.trim()
+        if (query.isEmpty() || _ui.value.searching) return
+
+        if (!model.capabilities.supportsRag) {
+            report(NO_EMBEDDING_STAGE)
+            return
+        }
+
+        viewModelScope.launch {
+            _ui.value = _ui.value.copy(searching = true, error = null)
+            try {
+                val result = ModelHolder.withActivity(ModelActivity.Generating) {
+                    model.retrieve(query, AppConfig.rag.value)
+                }
+                _ui.value = _ui.value.copy(
+                    matches = result.matches,
+                    // The query the matches answer, so an edited box cannot silently re-label results.
+                    searchedQuery = query,
+                    queryTimeMs = result.queryTimeMs,
+                    // An empty store and a query that genuinely matches nothing look identical in the
+                    // result list, and the fix for them is completely different. Record which it was.
+                    searchedWithEmptyStore = _ui.value.ingestedDocuments.isEmpty(),
+                )
+            } catch (e: Throwable) {
+                report(e.message ?: e::class.java.simpleName)
+            } finally {
+                _ui.value = _ui.value.copy(searching = false)
+            }
+        }
+    }
+
+    /**
+     * Fill the store.
+     *
+     * @param uri a document the user picked, or `null` to ingest the whole bundled corpus. Retrieval
+     *   over one document cannot demonstrate ranking — every result is a chunk of the only thing
+     *   there is — so the sample button installs four separable subjects rather than one file.
+     */
+    fun ingestSamples() = ingestAll { SampleData.installRagCorpus(getApplication()) }
+
+    fun ingest(uri: Uri) = ingestAll { listOf(copyToCache(uri)) }
+
+    private fun ingestAll(resolve: () -> List<File>) {
+        val model = (ModelHolder.state.value as? ModelState.Loaded)?.model ?: return
+        if (!model.capabilities.supportsRag) {
+            report(NO_EMBEDDING_STAGE)
+            return
+        }
+        viewModelScope.launch {
+            _ui.value = _ui.value.copy(ingesting = true, error = null, note = null)
+            try {
+                val documents = resolve()
+                var chunks = 0
+                val names = mutableListOf<String>()
+                for (document in documents) {
+                    val result = ModelHolder.withActivity(ModelActivity.Ingesting) {
+                        model.ingest(document.absolutePath, AppConfig.rag.value)
+                    }
+                    chunks += result.chunkCount
+                    names += document.name
+                }
+                _ui.value = _ui.value.copy(
+                    note = "ingested ${names.size} document(s), $chunks chunks",
+                    // Re-ingesting the same file adds chunks again; the list is what is ON SCREEN, so
+                    // it must not grow duplicates and imply a bigger store than there is.
+                    ingestedDocuments = (_ui.value.ingestedDocuments + names).distinct(),
+                )
+                AppSnackbar.success("Ingested $chunks chunks from ${names.size} document(s)")
+            } catch (e: Throwable) {
+                report(e.message ?: e::class.java.simpleName)
+            } finally {
+                _ui.value = _ui.value.copy(ingesting = false)
+            }
+        }
+    }
+
+    fun useExample(query: String) {
+        _ui.value = _ui.value.copy(query = query)
+    }
+
+    fun clear() {
+        _ui.value = _ui.value.copy(matches = emptyList(), searchedQuery = "", error = null)
+    }
+
+    private fun report(message: String) {
+        _ui.value = _ui.value.copy(error = message)
+        AppSnackbar.error(message)
+    }
+
+    /**
+     * `ingest` takes a filesystem path, and a `content://` URI is not one — it is a handle into
+     * another app's provider, valid only for this grant. Copying is what turns it into something the
+     * SDK can open.
+     */
+    private fun copyToCache(uri: Uri): File {
+        val name = uri.lastPathSegment?.substringAfterLast('/')?.takeIf { it.isNotBlank() } ?: "document.txt"
+        val target = File(getApplication<Application>().filesDir, name)
+        getApplication<Application>().contentResolver.openInputStream(uri)?.use { input ->
+            target.outputStream().use { output -> input.copyTo(output) }
+        } ?: error("could not open $uri")
+        return target
+    }
+
+    private companion object {
+        const val NO_EMBEDDING_STAGE =
+            "this package has no embedding stage — re-pull it with the RAG feature requested on the " +
+                "Models screen (it is a separate download group)"
+    }
+}
+
+data class RetrievalUiState(
+    val query: String = "",
+    val searching: Boolean = false,
+    val ingesting: Boolean = false,
+    /** Highest score first — `RetrievalResult.matches` is already ranked. */
+    val matches: List<RetrievalMatch> = emptyList(),
+    val searchedQuery: String = "",
+    val queryTimeMs: Long = 0L,
+    val searchedWithEmptyStore: Boolean = false,
+    val ingestedDocuments: List<String> = emptyList(),
+    val note: String? = null,
+    val error: String? = null,
+) {
+    /** A search ran and found nothing — distinct from "no search has run yet". */
+    val foundNothing: Boolean get() = searchedQuery.isNotEmpty() && matches.isEmpty()
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/TrainViewModel.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/TrainViewModel.kt
new file mode 100644
index 0000000..76e14a9
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/viewmodels/TrainViewModel.kt
@@ -0,0 +1,390 @@
+package com.martinkorelic.mobiletransformers.app.viewmodels
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.martinkorelic.mobiletransformers.app.AppConfig
+import com.martinkorelic.mobiletransformers.app.AppSnackbar
+import com.martinkorelic.mobiletransformers.app.ModelActivity
+import com.martinkorelic.mobiletransformers.app.ModelHolder
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.app.SampleData
+import com.martinkorelic.mobiletransformers.packages.PackageFormat
+import com.martinkorelic.mobiletransformers.scheduler.ScheduledChunk
+import com.martinkorelic.mobiletransformers.scheduler.TrainingScheduleConfig
+import com.martinkorelic.mobiletransformers.scheduler.TrainingScheduler
+import com.martinkorelic.mobiletransformers.training.TrainingEvent
+import com.martinkorelic.mobiletransformers.training.TrainingStatus
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * Training driven through `trainingJob()`, plus the charging-cycle scheduler.
+ *
+ * Uses the **lifecycle** handle rather than the one-shot `train()`, because status/events/cancel/resume
+ * are the half an app actually needs. That was only reachable by importing `ORTTrainingConfig` until
+ * `TrainingJob.start(DatasetConfig, TrainConfig)` was added — recorded as a facade gap.
+ */
+class TrainViewModel(app: Application) : AndroidViewModel(app) {
+
+    private val _ui = MutableStateFlow(TrainUiState())
+    val ui: StateFlow<TrainUiState> = _ui.asStateFlow()
+
+    val modelState: StateFlow<ModelState> = ModelHolder.state
+
+    private val _scheduledRuns = MutableStateFlow<List<ScheduledRun>>(emptyList())
+
+    /**
+     * The scheduled queue for the loaded model.
+     *
+     * `TrainingScheduler.observe` existed and had **no caller**, so the only feedback a
+     * user got from scheduling was a UUID in a text field. "Queued and waiting for the charger",
+     * "running chunk 3" and "finished an hour ago" were indistinguishable — for a feature whose whole
+     * point is that it runs when you are not watching.
+     */
+    val scheduledRuns: StateFlow<List<ScheduledRun>> = _scheduledRuns.asStateFlow()
+
+    private var observeJob: Job? = null
+
+    init {
+        // Re-subscribe when the model changes: the unique work name is per repo id.
+        viewModelScope.launch {
+            ModelHolder.state.collect { state ->
+                observeJob?.cancel()
+                val repoId = (state as? ModelState.Loaded)?.model?.repoId
+                if (repoId == null) {
+                    _scheduledRuns.value = emptyList()
+                    return@collect
+                }
+                observeJob = launch {
+                    TrainingScheduler.observeChunks(getApplication(), repoId).collect { chunks ->
+                        _scheduledRuns.value = chunks.map { it.toScheduledRun() }
+                    }
+                }
+            }
+        }
+    }
+
+    fun onStartDelayChanged(value: StartDelay) {
+        _ui.value = _ui.value.copy(startDelay = value)
+    }
+
+    /** Cancel the queued run; the chunk in flight checkpoints on its way out. */
+    fun cancelSchedule() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        runCatching { TrainingScheduler.cancel(getApplication(), loaded.model.repoId) }
+            .onSuccess {
+                _ui.value = _ui.value.copy(scheduled = null)
+                AppSnackbar.info("Scheduled run cancelled")
+            }
+            .onFailure { AppSnackbar.error(it.message ?: "could not cancel the scheduled run") }
+    }
+
+    fun start() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        if (!loaded.model.capabilities.supportsTraining) {
+            _ui.value = _ui.value.copy(
+                error = "this package has no train/ stage — re-export with TRAIN=1 or pull a " +
+                    "train-capable variant",
+            )
+            return
+        }
+        viewModelScope.launch {
+            val job = loaded.model.trainingJob()
+            _ui.value = _ui.value.copy(
+                running = true,
+                error = null,
+                events = emptyList(),
+                points = emptyList(),
+            )
+            AppSnackbar.info("Training started")
+
+            // Observe before starting: a run short enough to finish first would otherwise report nothing.
+            val statusJob = launch {
+                job.status.collect { s -> _ui.value = _ui.value.copy(status = s.describe()) }
+            }
+            val eventJob = launch {
+                job.events.collect { e ->
+                    val ui = _ui.value
+                    _ui.value = ui.copy(
+                        events = (ui.events + e.describe()).takeLast(EVENT_LOG_LIMIT),
+                        // Every Step event already carried loss, learning rate and step duration;
+                        // rendering it with `toString()` threw all of it away.
+                        points = e.point()?.let { ui.points + it } ?: ui.points,
+                    )
+                }
+            }
+            try {
+                ModelHolder.withActivity(ModelActivity.Training) {
+                    job.start(dataset = AppConfig.dataset.value, config = AppConfig.train.value)
+                }
+                _ui.value = _ui.value.copy(canResume = job.canResume)
+                val last = _ui.value.points.lastOrNull()
+                AppSnackbar.success(
+                    last?.let { "Training finished — loss %.4f at step %d".format(it.loss, it.step) }
+                        ?: "Training finished",
+                )
+            } catch (e: Throwable) {
+                val reason = e.message ?: e::class.java.simpleName
+                _ui.value = _ui.value.copy(error = reason)
+                AppSnackbar.error(reason)
+            } finally {
+                statusJob.cancel()
+                eventJob.cancel()
+                _ui.value = _ui.value.copy(running = false)
+            }
+        }
+    }
+
+    /**
+     * Copy the bundled tool-call training set into the installed package and point [AppConfig] at it.
+     *
+     * Without this the Start button could not work on a freshly pulled package: the trainer reads
+     * `<cacheDir>/<repoId>/train/<trainFile>.jsonl`, model packages deliberately ship no training
+     * data, and the app had no way to create one. That made the whole Train screen unreachable for
+     * anyone who had not `adb push`ed a dataset by hand.
+     *
+     * The cache root mirrors what `ModelHolder` lets `fromPretrained` default to (`context.filesDir`);
+     * `sanitizeRepoId` is the public mapping from repo id to cache directory name.
+     */
+    fun installSampleDataset() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        val app = getApplication<Application>()
+        runCatching {
+            SampleData.installTrainingSet(
+                context = app,
+                // The cache root ModelHolder lets `fromPretrained` default to.
+                cacheDir = app.filesDir,
+                sanitizedRepoId = PackageFormat.sanitizeRepoId(loaded.model.repoId),
+            )
+        }
+            .onSuccess { installed ->
+                if (installed == null) {
+                    _ui.value = _ui.value.copy(
+                        error = "this package has no train/ stage, so there is nowhere to put a " +
+                            "training set — pull one with the Training feature requested",
+                    )
+                } else {
+                    AppConfig.updateDataset {
+                        it.copy(trainFile = SampleData.TRAIN_FILE, task = SampleData.TRAIN_TASK)
+                    }
+                    _ui.value = _ui.value.copy(
+                        error = null,
+                        datasetNote = "installed ${installed.name} (${installed.length()} bytes) and " +
+                            "set trainFile=${SampleData.TRAIN_FILE}, task=${SampleData.TRAIN_TASK}",
+                    )
+                }
+            }
+            .onFailure { _ui.value = _ui.value.copy(error = it.message ?: "could not install sample data") }
+    }
+
+    fun cancel() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        viewModelScope.launch {
+            // Cooperative: the native loop breaks at the next step boundary and the checkpoint is
+            // persisted, so cancelling is resumable rather than destructive.
+            runCatching { loaded.model.trainingJob().cancel(saveCheckpoint = true) }
+                .onFailure { _ui.value = _ui.value.copy(error = it.message) }
+        }
+    }
+
+    /** Hand the same public configs to WorkManager instead of running now. */
+    fun schedule() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        if (!loaded.model.capabilities.supportsScheduledTraining) {
+            _ui.value = _ui.value.copy(error = "scheduled training needs a train-capable package")
+            return
+        }
+        runCatching {
+            TrainingScheduler.schedule(
+                context = getApplication(),
+                repoId = loaded.model.repoId,
+                dataset = AppConfig.dataset.value,
+                training = AppConfig.train.value,
+                config = TrainingScheduleConfig(
+                    initialDelayMinutes = _ui.value.startDelay.minutes,
+                ),
+            )
+        }.onSuccess {
+            val delay = _ui.value.startDelay
+            _ui.value = _ui.value.copy(
+                scheduled = "queued as $it — ${delay.describe()}, and each chunk re-evaluates its " +
+                    "constraints before it starts",
+            )
+            AppSnackbar.success("Scheduled — ${delay.describe()}")
+        }.onFailure {
+            _ui.value = _ui.value.copy(error = it.message)
+            AppSnackbar.error(it.message ?: "could not schedule training")
+        }
+    }
+
+    fun merge() {
+        val loaded = ModelHolder.state.value as? ModelState.Loaded ?: return
+        viewModelScope.launch {
+            runCatching { ModelHolder.withActivity(ModelActivity.Merging) { loaded.model.merge() } }
+                .onSuccess {
+                    _ui.value = _ui.value.copy(status = "merged=${it.merged}")
+                    AppSnackbar.success(
+                        if (it.merged) {
+                            "Merged — generation now uses the fine-tuned weights"
+                        } else {
+                            "Nothing to merge: no adapter has been trained yet"
+                        },
+                    )
+                }
+                .onFailure {
+                    _ui.value = _ui.value.copy(error = it.message)
+                    AppSnackbar.error(it.message ?: "merge failed")
+                }
+        }
+    }
+}
+
+/** Keep the log bounded: a long run emits thousands of steps and this is a phone. */
+private const val EVENT_LOG_LIMIT = 300
+
+data class TrainUiState(
+    val running: Boolean = false,
+    val status: String = "idle",
+    val events: List<String> = emptyList(),
+    /** The series behind the charts — one entry per reported step. */
+    val points: List<StepPoint> = emptyList(),
+    val canResume: Boolean = false,
+    val scheduled: String? = null,
+    val datasetNote: String? = null,
+    val startDelay: StartDelay = StartDelay.WhenReady,
+    val error: String? = null,
+)
+
+/**
+ * When the first chunk may start.
+ *
+ * ### Why these are delays and not clock times
+ *
+ * WorkManager's `setInitialDelay` is the only start-time control Android offers deferrable work, and
+ * it is a **floor, not an appointment** — the system batches, and Doze can hold a job well past it.
+ * An exact wall-clock start needs `AlarmManager.setExactAndAllowWhileIdle` and the
+ * `SCHEDULE_EXACT_ALARM` permission, which Play restricts to alarm clocks and calendar reminders; a
+ * multi-hour training job is neither, and asking for that permission to run a background trainer
+ * would rightly be refused.
+ *
+ * So the honest UI is "not before", and the constraints (charging, battery not low) remain the real
+ * gate — a delay only moves the earliest moment they are consulted.
+ */
+enum class StartDelay(val label: String, val minutes: Long) {
+    WhenReady("As soon as it can", 0),
+    InAnHour("Not for an hour", 60),
+    InFourHours("Not for 4 hours", 240),
+    Overnight("Not for 8 hours", 480),
+    ;
+
+    fun describe(): String = when (this) {
+        WhenReady -> "it starts as soon as the device is charging"
+        else -> "it starts no earlier than $minutes minutes from now, once charging"
+    }
+}
+
+/** One scheduled chunk, as the queue panel renders it. */
+data class ScheduledRun(val stateLabel: String, val detail: String)
+
+/** Put the SDK's chunk state into the words the panel shows. */
+private fun ScheduledChunk.toScheduledRun(): ScheduledRun {
+    val label = when (state) {
+        ScheduledChunk.State.WaitingForConstraints -> "Waiting for charging + idle"
+        ScheduledChunk.State.Running -> "Running" + (chunk?.let { " chunk $it" } ?: "")
+        ScheduledChunk.State.Finished -> "Chunk finished"
+        ScheduledChunk.State.Failed -> "Failed"
+        ScheduledChunk.State.Blocked -> "Blocked by an earlier chunk"
+        ScheduledChunk.State.Cancelled -> "Cancelled"
+    }
+    val detail = buildString {
+        globalStep?.let { append("globalStep $it") }
+        if (stalled) {
+            if (isNotEmpty()) append(" · ")
+            append("advanced no steps, so no further chunk was queued")
+        }
+        error?.let {
+            if (isNotEmpty()) append(" · ")
+            append(it)
+        }
+        if (isEmpty()) {
+            append(
+                "Chunks run only while the device is charging and idle, and each one re-checks that " +
+                    "before starting.",
+            )
+        }
+    }
+    return ScheduledRun(label, detail)
+}
+
+/** One reported training step, as the charts consume it. */
+data class StepPoint(
+    val step: Int,
+    val loss: Float,
+    val learningRate: Float,
+    val stepDurationMs: Long,
+)
+
+/**
+ * A human-readable status line rather than a Kotlin class name.
+ *
+ * `this::class.java.simpleName` rendered `Running` for a run and gave no indication of *where* it
+ * was, even though `TrainingStatus.Running` carries the progress that answers exactly that.
+ */
+private fun TrainingStatus.describe(): String = when (this) {
+    is TrainingStatus.Idle -> "idle"
+    is TrainingStatus.Preparing -> "preparing — loading the training graph"
+    is TrainingStatus.Running ->
+        "step ${progress.currentStep} · epoch ${progress.currentEpoch} · loss %.4f".format(progress.stepLoss)
+    is TrainingStatus.Merging -> "merging the adapter into the inference graph"
+    is TrainingStatus.Saving -> "saving checkpoint"
+    is TrainingStatus.Completed ->
+        "completed — %d steps, final loss %.4f".format(result.finalStep, result.finalLoss)
+    is TrainingStatus.Cancelled ->
+        "cancelled" + (checkpoint?.let { " — checkpoint at step ${it.currentGlobalStep}" } ?: "")
+    is TrainingStatus.Failed -> "failed: ${error.message ?: error::class.java.simpleName}"
+}
+
+/**
+ * One aligned line per event.
+ *
+ * This used to be `toString()` on the event, which printed a whole Kotlin data class — including the
+ * nested `TrainingProgress` with all ten of its fields — for every step. The log was technically
+ * complete and practically unreadable, and it is the chart's table-view twin, so it has to be the
+ * place a value can actually be read.
+ */
+private fun TrainingEvent.describe(): String = when (this) {
+    is TrainingEvent.DataLoaded -> "data loaded · $totalSteps steps · $stepsPerEpoch per epoch"
+    is TrainingEvent.Step ->
+        "step %-5d loss %-9.4f lr %-10.2e %d ms".format(
+            progress.currentStep, progress.stepLoss, progress.learningRate, progress.stepDurationMs,
+        )
+    is TrainingEvent.OptimizerStep -> "optimizer step at ${progress.currentStep}"
+    is TrainingEvent.Epoch ->
+        "epoch %d ended · epoch loss %.4f · %d ms".format(
+            progress.currentEpoch, progress.epochLoss, progress.epochDurationMs,
+        )
+    is TrainingEvent.Metric -> "metric: $m"
+    is TrainingEvent.MergeStarted -> "merge started"
+    is TrainingEvent.MergeFinished -> "merge finished"
+    is TrainingEvent.Saved -> "checkpoint saved at step ${progress.currentStep}"
+    is TrainingEvent.Done ->
+        "done · %d steps · final loss %.4f · %d ms".format(
+            result.finalStep, result.finalLoss, result.totalDurationMs,
+        )
+    is TrainingEvent.Error -> "error: ${t.message ?: t::class.java.simpleName}"
+}
+
+/** The chart point a step event carries, or null for the events that are not steps. */
+private fun TrainingEvent.point(): StepPoint? = when (this) {
+    is TrainingEvent.Step -> StepPoint(
+        step = progress.currentStep,
+        loss = progress.stepLoss,
+        learningRate = progress.learningRate,
+        stepDurationMs = progress.stepDurationMs,
+    )
+    else -> null
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/AboutScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/AboutScreen.kt
new file mode 100644
index 0000000..f3df912
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/AboutScreen.kt
@@ -0,0 +1,140 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.hasNotificationPermission
+
+/**
+ * What this app is, in what order to use it, and the two device settings that change what it can show.
+ *
+ * The tour used to live in a `Guide` card on the Models screen, which meant the one explanation of how
+ * the app fits together was reachable only from the screen a user had already worked out. It belongs
+ * somewhere addressable — and the drawer now makes "somewhere" cheap.
+ */
+@Composable
+fun AboutScreen(onGoToModels: () -> Unit) {
+    val context = LocalContext.current
+    val notificationsOn = hasNotificationPermission(context)
+
+    Column(
+        Modifier.fillMaxSize().verticalScroll(rememberScrollState()),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        ScreenIntro(
+            "MobileTransformers runs, fine-tunes and retrieves with language models entirely on this " +
+                "device. Nothing you type, ingest or train on is uploaded — the only network traffic " +
+                "is pulling a model package from the Hub.",
+        )
+
+        Section("The order things work in") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Step(
+                    "1 · Models",
+                    "Pick a package from the catalog or enter any Hub repo id. Nothing else works " +
+                        "until one is installed. Tick Training if you want the Training and Tool " +
+                        "calls screens; tick RAG for grounding in Chat — each is a separate download " +
+                        "group and cannot be added later without re-pulling.",
+                )
+                Step(
+                    "2 · Chat",
+                    "Type and send; tokens stream as they arrive. A small model on a phone is slow " +
+                        "and not very fluent — that is the hardware and the model size, not a defect.",
+                )
+                Step(
+                    "3 · Training",
+                    "Install the sample dataset first: packages ship no training data by design, " +
+                        "because the task belongs with the data and the data is yours. Then Start, " +
+                        "and watch the loss curve. Merge writes what was learned into the inference " +
+                        "graph.",
+                )
+                Step(
+                    "4 · Tool calls",
+                    "Turn an instruction into a validated call bound to a real Android intent — in " +
+                        "dry-run only, always. On a model you have not fine-tuned, Rejected is the " +
+                        "correct answer rather than a bug.",
+                )
+                Button(onClick = onGoToModels) { Text("Start at Models") }
+            }
+        }
+
+        Section("Device settings that affect what you see") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(
+                    if (notificationsOn) {
+                        "Notifications are allowed, so scheduled training and background downloads " +
+                            "show their progress and can be cancelled from the shade."
+                    } else {
+                        "Notifications are blocked. Training still runs in the background, but its " +
+                            "ongoing notification — the only place its progress and Cancel button " +
+                            "appear while you are outside the app — will not be shown."
+                    },
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                if (!notificationsOn && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    OutlinedButton(onClick = {
+                        context.startActivity(
+                            Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
+                                .putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName)
+                                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
+                        )
+                    }) { Text("Open notification settings") }
+                }
+                Text(
+                    "Scheduled training runs only while charging and idle, and re-checks that on " +
+                        "every chunk — so unplugging pauses a run instead of failing it.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+            }
+        }
+
+        Section("Bringing your own model") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(
+                    "Any package exported with `mobiletransformers export` and pushed to the Hub can " +
+                        "be pulled here by repo id. The catalog on the Models screen is a bundled " +
+                        "JSON file — adding an entry to it is editing one asset, not writing code.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                Text(
+                    "Every screen in this app talks to the SDK only through " +
+                        "MobileTransformers.fromPretrained and MobileTransformerModel. A build guard " +
+                        "fails if any screen names an engine-layer type, which is what makes this a " +
+                        "worked example of the public API rather than a claim about one.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                OutlinedButton(onClick = {
+                    context.startActivity(
+                        Intent(
+                            Intent.ACTION_VIEW,
+                            Uri.parse("https://github.com/martinkorelic/mobiletransformers"),
+                        ).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
+                    )
+                }) { Text("Documentation and source") }
+            }
+        }
+    }
+}
+
+@Composable
+private fun Step(title: String, body: String) {
+    Column(Modifier.padding(bottom = 4.dp), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+        Text(title, style = MaterialTheme.typography.labelLarge)
+        Text(body, style = MaterialTheme.typography.bodySmall)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ChatScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ChatScreen.kt
new file mode 100644
index 0000000..0d55ec9
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ChatScreen.kt
@@ -0,0 +1,427 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Bolt
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.viewmodels.ChatMessage
+import com.martinkorelic.mobiletransformers.app.viewmodels.ChatViewModel
+import com.martinkorelic.mobiletransformers.app.viewmodels.EnginePickerState
+import com.martinkorelic.mobiletransformers.app.viewmodels.ToolCallCard
+import com.martinkorelic.mobiletransformers.app.viewmodels.ToolExecution
+
+/**
+ * Generate and stream, ground in ingested documents, and call tools, all in one
+ * conversation.
+ *
+ * The retrieved sources and the assembled prompt hang off **the message they produced**, not off the
+ * screen. Previously they lived in a screen-level "Sources" section detached from any answer and
+ * cleared by the next question, so a conversation with several grounded answers showed one set of
+ * sources belonging to none of them in particular.
+ */
+@Composable
+fun ChatScreen(vm: ChatViewModel, onOpenSettings: () -> Unit = {}) {
+    val ui by vm.ui.collectAsState()
+    val state by vm.modelState.collectAsState()
+
+    // The system permission dialog, launched from the Activity — a ViewModel holds an application
+    // context and cannot show one. The ViewModel asks by setting `pendingPermissions`; this answers.
+    val permissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestMultiplePermissions(),
+) { granted -> vm.onPermissionResult(granted.values.all { it }) }
+
+    LaunchedEffect(ui.pendingPermissions) {
+        ui.pendingPermissions?.let { permissionLauncher.launch(it.permissions.toTypedArray()) }
+        }
+
+    ModelGate(state, needs = "Chat needs an inference-capable package.") { model ->
+        val listState = rememberLazyListState()
+        // Follow the conversation: without this a streaming answer scrolls out from under the reader.
+        LaunchedEffect(ui.messages.size, ui.streaming) {
+            val last = ui.messages.lastIndex
+            if (last >= 0) listState.animateScrollToItem(last)
+        }
+
+        Column(Modifier.fillMaxSize()) {
+            ChatToolbar(
+                useRag = ui.useRag,
+                supportsRag = model.capabilities.supportsRag,
+                supportsTools = model.capabilities.supportsToolCalling,
+                onRag = vm::onRagToggled,
+                onOpenSettings = onOpenSettings,
+            )
+
+            LazyColumn(
+                Modifier.weight(1f),
+                state = listState,
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                if (ui.messages.isEmpty()) {
+                    item {
+                        EmptyState(
+                            title = "Say something",
+                            detail = if (model.capabilities.supportsToolCalling) {
+                                "This model can call tools. Ask it anything — a reply that turns out " +
+                                    "to be a call to one of this app's actions is shown as a call, " +
+                                    "with the intent it would fire; anything else is shown as an answer."
+                            } else {
+                                "Tokens appear as they are generated."
+                            },
+                        )
+                    }
+                }
+                items(ui.messages) { m ->
+                    MessageCard(m, onSimulate = vm::simulateToolResult, onRun = vm::runToolCall)
+                }
+
+                if (ui.streaming.isNotEmpty()) {
+                    item { Bubble(fromUser = false, text = ui.streaming, streaming = true) }
+                }
+                ui.phase?.let {
+                    // The grounded and tool-call paths do not stream, so without this a 20-second
+                    // answer is a frozen screen.
+                    item {
+                        Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) {
+                            Text(it, style = MaterialTheme.typography.bodySmall)
+                            LinearProgressIndicator(Modifier.fillMaxWidth().padding(top = 4.dp))
+                        }
+                    }
+                }
+                ui.error?.let { item { Section("Error") { Text(it) } } }
+            }
+
+            HorizontalDivider()
+            Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                TextField("Message", ui.prompt, vm::onPromptChanged)
+                ActionRow {
+                    Button(onClick = vm::send, enabled = !ui.generating) {
+                        Text(if (ui.generating) "Generating…" else "Send")
+                    }
+                    OutlinedButton(onClick = vm::clear) { Text("Clear") }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * One toggle, one badge, one link.
+ *
+ * The "Tool calls" chip that used to sit here asked the user to declare, before sending, whether
+ * their next message was a tool call — which is a property of the *reply*, not of the question.
+ * Getting it wrong in either direction produced a wrong-looking result from a correctly working
+ * system. Tool calling is now detected from the answer, so what remains here is a statement of
+ * capability rather than a control.
+ *
+ * Grounding stays a toggle, because "answer from the documents I ingested" genuinely is a decision
+ * the user makes in advance.
+ *
+ * ### Why "Setup" became a link to Configuration
+ *
+ * It used to expand a panel here holding three things, none of which belonged in a conversation: the
+ * engine (a read-only fact about the loaded model, now in the model bar), the ingest controls (a
+ * property of retrieval, now on the Retrieval screen) and the tool-call allowlist (now in
+ * Configuration). Meanwhile the settings a user actually wants mid-chat — temperature, length,
+ * sampling — were never there at all, so "Setup" opened a panel that could not do the thing its name
+ * promised. It now opens the Generation settings, which is what was wanted.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun ChatToolbar(
+    useRag: Boolean,
+    supportsRag: Boolean,
+    supportsTools: Boolean,
+    onRag: (Boolean) -> Unit,
+    onOpenSettings: () -> Unit,
+) {
+    FlowRow(
+        Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 6.dp),
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp, Alignment.CenterVertically),
+    ) {
+        ModeChip("Ground with RAG", useRag, enabled = supportsRag) { onRag(!useRag) }
+        if (supportsTools) {
+            AssistChip(
+                onClick = { },
+                enabled = false,
+                leadingIcon = { Icon(Icons.Outlined.Bolt, contentDescription = null) },
+                label = { Text("can call tools") },
+            )
+        }
+        TextButton(onClick = onOpenSettings) { Text("Settings") }
+    }
+}
+
+@Composable
+private fun ModeChip(label: String, selected: Boolean, enabled: Boolean = true, onClick: () -> Unit) {
+    androidx.compose.material3.FilterChip(
+        selected = selected,
+        onClick = onClick,
+        enabled = enabled,
+        label = { Text(label) },
+    )
+}
+
+@Composable
+private fun MessageCard(
+    m: ChatMessage,
+    onSimulate: (ToolCallCard) -> Unit,
+    onRun: (ToolCallCard) -> Unit,
+) {
+    when {
+        m.toolCall != null -> ToolCallBubble(m.toolCall, m.turnStats, onSimulate, onRun)
+        m.retrieval != null -> RetrievalBubble(m.retrieval)
+        else -> Bubble(
+            fromUser = m.fromUser,
+            text = m.text,
+            assembledPrompt = m.assembledPrompt,
+            stats = m.stats,
+            turnStats = m.turnStats,
+        )
+    }
+}
+
+/**
+ * What retrieval found, as its own turn above the answer it produced.
+ *
+ * ### Why it does not look like either speaker
+ *
+ * It is neither the user's turn nor the model's — it is the app reporting on a step it took, so it
+ * takes the full width, a `tertiaryContainer` tint and no "you"/"model" caption. A reader should be
+ * able to tell at a glance that this line is machinery rather than conversation.
+ *
+ * ### Why it is collapsed
+ *
+ * Retrieved chunks are long — `chunkSize` is 512 characters — and several of them between the
+ * question and the answer would push the answer off the screen, which is the opposite of what
+ * showing the sources is for. The headline is the claim; the passages are there when you want them.
+ */
+@Composable
+private fun RetrievalBubble(card: com.martinkorelic.mobiletransformers.app.viewmodels.RetrievalCard) {
+    var expanded by remember { mutableStateOf(false) }
+
+    Card(
+        Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 3.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.tertiaryContainer,
+            contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
+        ),
+    ) {
+        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Text("retrieval", style = MaterialTheme.typography.labelSmall)
+            Text(card.headline, style = MaterialTheme.typography.bodyMedium)
+
+            // The file names, which are what a user recognises — the passage text is the detail
+            // behind them, not the headline.
+            if (card.documents.isNotEmpty()) {
+                Text(
+                    card.documents.joinToString(" · "),
+                    style = MaterialTheme.typography.bodySmall,
+                )
+            }
+            if (card.queryTimeMs > 0) {
+                Text("search %d ms".format(card.queryTimeMs), style = MaterialTheme.typography.labelSmall)
+            }
+
+            if (card.passages.isNotEmpty()) {
+                TextButton(onClick = { expanded = !expanded }) {
+                    Text(if (expanded) "Hide passages" else "Show passages")
+                }
+                if (expanded) {
+                    card.passages.forEach { p ->
+                        Column(Modifier.padding(bottom = 8.dp)) {
+                            Text(
+                                // Source first: "which file, how close" is the pair that makes a
+                                // passage judgeable. A bare score says nothing about provenance.
+                                if (p.title.isBlank()) {
+                                    "score %.3f".format(p.score)
+                                } else {
+                                    "%s · score %.3f".format(p.title, p.score)
+                                },
+                                style = MaterialTheme.typography.labelSmall,
+                            )
+                            Text(p.text, style = MaterialTheme.typography.bodySmall)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * One turn.
+ *
+ * ### Telling the two speakers apart
+ *
+ * Both sides used to be an identical full-width `Card` distinguished only by the words "you" and
+ * "model" in 11sp grey above the text — so scanning back through a conversation meant reading the
+ * label on every bubble. Three cues carry it now, none of them load-bearing alone: the user's turn
+ * is tinted with `primaryContainer` and inset from the left, the model's uses `surfaceVariant` and
+ * is inset from the right, and both keep the caption. Colour is never the only signal, which matters
+ * for the same reason the status dot has words next to it.
+ */
+@Composable
+private fun Bubble(
+    fromUser: Boolean,
+    text: String,
+    streaming: Boolean = false,
+    assembledPrompt: String? = null,
+    stats: String? = null,
+    turnStats: com.martinkorelic.mobiletransformers.app.viewmodels.TurnStats? = null,
+) {
+    var showPrompt by remember { mutableStateOf(false) }
+
+    Row(
+        Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 3.dp),
+        // The asymmetric inset is the cue that survives a greyscale screenshot.
+        horizontalArrangement = if (fromUser) Arrangement.End else Arrangement.Start,
+    ) {
+        Card(
+            Modifier.fillMaxWidth(0.92f),
+            colors = CardDefaults.cardColors(
+                containerColor = if (fromUser) {
+                    MaterialTheme.colorScheme.primaryContainer
+                } else {
+                    MaterialTheme.colorScheme.surfaceVariant
+                },
+                contentColor = if (fromUser) {
+                    MaterialTheme.colorScheme.onPrimaryContainer
+                } else {
+                    MaterialTheme.colorScheme.onSurfaceVariant
+                },
+            ),
+        ) {
+        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Text(
+                when {
+                    fromUser -> "you"
+                    streaming -> "model · generating…"
+                    else -> "model"
+                },
+                style = MaterialTheme.typography.labelSmall,
+            )
+            Text(text, style = MaterialTheme.typography.bodyMedium)
+
+            // The measured cost of the turn: speed, and how full the window now is.
+            turnStats?.let {
+                Text(
+                    it.render(),
+                    style = MaterialTheme.typography.labelSmall,
+                )
+            }
+
+            stats?.let {
+                Text(
+                    it,
+                    style = MaterialTheme.typography.labelSmall,
+                )
+            }
+
+            assembledPrompt?.let { p ->
+                TextButton(onClick = { showPrompt = !showPrompt }) {
+                    Text(if (showPrompt) "Hide the prompt" else "What the model was actually asked")
+                }
+                // The whole point of a grounded API returning its prompt: an app that cannot show
+                // what was asked cannot debug a bad grounded answer.
+                if (showPrompt) Text(p, style = MaterialTheme.typography.bodySmall)
+            }
+        }
+        }
+    }
+}
+
+/**
+ * A tool call as a turn.
+ *
+ * Accepted and refused render as peers, because a refusal is the expected answer for untrusted output
+ * — it is the safety property working, not a failure to display.
+ */
+@Composable
+private fun ToolCallBubble(
+    card: ToolCallCard,
+    turnStats: com.martinkorelic.mobiletransformers.app.viewmodels.TurnStats?,
+    onSimulate: (ToolCallCard) -> Unit,
+    onRun: (ToolCallCard) -> Unit,
+) {
+    var showRaw by remember { mutableStateOf(false) }
+
+    Card(
+        Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 3.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = if (card.accepted) {
+                MaterialTheme.colorScheme.secondaryContainer
+            } else {
+                MaterialTheme.colorScheme.errorContainer
+            },
+        ),
+    ) {
+        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Text(
+                if (card.accepted) "tool call · accepted" else "tool call · refused",
+                style = MaterialTheme.typography.labelSmall,
+            )
+
+            if (card.accepted) {
+                Text(card.actionName.orEmpty(), style = MaterialTheme.typography.titleSmall)
+                card.parameters.forEach { (k, v) ->
+                    Text("$k = $v", style = MaterialTheme.typography.bodySmall)
+                }
+                Text(card.intentAction.orEmpty(), style = MaterialTheme.typography.labelSmall)
+                ActionRow {
+                    // The card used to explain the dry-run contract in two sentences on every call.
+                    // That belongs in the docs, not in the conversation — here it is just a button.
+                    if (!card.executed) {
+                        Button(onClick = { onRun(card) }) { Text("Run") }
+                    } else {
+                        Text("ran", style = MaterialTheme.typography.labelSmall)
+                    }
+                    OutlinedButton(onClick = { onSimulate(card) }) { Text("Simulate a result") }
+                }
+            } else {
+                Text(card.reason.orEmpty(), style = MaterialTheme.typography.bodyMedium)
+            }
+
+            turnStats?.let {
+                Text(it.render(), style = MaterialTheme.typography.labelSmall)
+            }
+
+            TextButton(onClick = { showRaw = !showRaw }) {
+                Text(if (showRaw) "Hide raw output" else "What the model emitted")
+            }
+            if (showRaw) Text(card.raw.take(1000), style = MaterialTheme.typography.bodySmall)
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ClassifyScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ClassifyScreen.kt
new file mode 100644
index 0000000..2662eee
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ClassifyScreen.kt
@@ -0,0 +1,134 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.viewmodels.ClassifyViewModel
+import com.martinkorelic.mobiletransformers.runtime.LabelScore
+
+/**
+ * Ask a classifier something and see the probability it assigns each label.
+ *
+ * The screen is deliberately a distribution rather than a single answer. A classifier that is 34%/33%/
+ * 33% across three labels and one that is 99%/0.5%/0.5% both "predict" the same class, and only the
+ * bars distinguish them — which is exactly the difference a fine-tuning run is supposed to make, and
+ * the reason this screen is the encoder story's payoff rather than a debug view.
+ */
+@Composable
+fun ClassifyScreen(viewModel: ClassifyViewModel) {
+    val ui by viewModel.ui.collectAsState()
+    val modelState by viewModel.modelState.collectAsState()
+
+    Column(Modifier.fillMaxWidth().verticalScroll(rememberScrollState())) {
+        ScreenIntro(
+            "Runs the package's classification head over your text and shows every label's " +
+                "probability. Train the head first and run the same text again — the bars moving is " +
+                "the fine-tune working.",
+        )
+
+        ModelGate(modelState, needs = "This screen needs a text-classification package.") {
+            Section("Text") {
+                TextField(label = "Input", value = ui.text, onChange = viewModel::onTextChanged)
+                ActionRow {
+                    Button(
+                        onClick = viewModel::submit,
+                        enabled = !ui.running && ui.text.isNotBlank(),
+                    ) { Text(if (ui.running) "Classifying…" else "Classify") }
+                    OutlinedButton(
+                        onClick = viewModel::clear,
+                        enabled = !ui.running && ui.scores.isNotEmpty(),
+                    ) { Text("Clear") }
+                    if (ui.running) {
+                        CircularProgressIndicator(Modifier.width(20.dp))
+                    }
+                }
+            }
+
+            ui.error?.let { message ->
+                Section("Could not classify") {
+                    // Verbatim. The likeliest cause is a package whose head ships no `id2label`, and
+                    // `classify()` says so precisely; a friendlier paraphrase loses the fix.
+                    Text(message, style = MaterialTheme.typography.bodySmall)
+                }
+            }
+
+            if (ui.scores.isNotEmpty()) {
+                Section("Prediction") {
+                    ui.best?.let { best ->
+                        Text(best.label, style = MaterialTheme.typography.headlineSmall)
+                        Text(
+                            "%.1f%% confident · class index ${best.index}".format(best.score * 100),
+                            style = MaterialTheme.typography.bodySmall,
+                        )
+                    }
+                    if (ui.classifiedText.isNotBlank()) {
+                        Text(
+                            "for: \"${ui.classifiedText}\"",
+                            style = MaterialTheme.typography.bodySmall,
+                        )
+                    }
+                }
+
+                Section("All labels") {
+                    ui.scores.forEach { LabelBar(it) }
+                }
+            }
+
+            ui.previous?.let { previous ->
+                Section("Previous run") {
+                    if (ui.previousText.isNotBlank()) {
+                        Text(
+                            "for: \"${ui.previousText}\"",
+                            style = MaterialTheme.typography.bodySmall,
+                        )
+                    }
+                    previous.forEach { LabelBar(it) }
+                }
+            }
+        }
+    }
+}
+
+/** One label, its probability bar, and the number — the bar alone cannot be read precisely. */
+@Composable
+private fun LabelBar(score: LabelScore) {
+    Column(Modifier.fillMaxWidth().padding(vertical = 4.dp)) {
+        Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+            Text(
+                score.label,
+                style = MaterialTheme.typography.bodyMedium,
+                modifier = Modifier.weight(1f),
+            )
+            Text(
+                "%.1f%%".format(score.score * 100),
+                style = MaterialTheme.typography.bodySmall,
+                textAlign = TextAlign.End,
+            )
+        }
+        LinearProgressIndicator(
+            // coerceIn because a softmax that has drifted (or a head read through a stale
+            // embeddingDim) can hand back something outside 0..1, and the indicator would otherwise
+            // draw past its own bounds rather than showing that anything is wrong.
+            progress = { score.score.toFloat().coerceIn(0f, 1f) },
+            modifier = Modifier.fillMaxWidth().padding(top = 2.dp),
+        )
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/Common.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/Common.kt
new file mode 100644
index 0000000..be97b9b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/Common.kt
@@ -0,0 +1,405 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExposedDropdownMenuBox
+import androidx.compose.material3.ExposedDropdownMenuDefaults
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Tab
+import androidx.compose.material3.TabRow
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.ModelState
+
+/**
+ * The empty state every screen needs.
+ *
+ * On a real device most screens do nothing without an installed package — arm64-v8a only, no emulator
+ * — so "no model installed" is the first thing a new user sees and has to be legible rather than a
+ * blank screen or a crash. [action] tells them where to go.
+ */
+@Composable
+fun EmptyState(title: String, detail: String, modifier: Modifier = Modifier) {
+    Card(modifier = modifier.fillMaxWidth().padding(16.dp)) {
+        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(title, style = MaterialTheme.typography.titleMedium)
+            Text(detail, style = MaterialTheme.typography.bodyMedium)
+        }
+    }
+}
+
+/** Renders the four [ModelState] cases uniformly, so no screen invents its own vocabulary for them. */
+@Composable
+fun ModelGate(
+    state: ModelState,
+    needs: String,
+    content: @Composable (com.martinkorelic.mobiletransformers.MobileTransformerModel) -> Unit,
+) {
+    when (state) {
+        is ModelState.None -> EmptyState(
+            title = "No model loaded",
+            detail = "Open the Models tab and pull a package by repo id. $needs",
+        )
+        is ModelState.Loading -> Column(Modifier.fillMaxWidth().padding(16.dp)) {
+            Text("Loading ${state.repoId}…")
+            LinearProgressIndicator(Modifier.fillMaxWidth().padding(top = 8.dp))
+        }
+        is ModelState.Failed -> EmptyState(
+            title = "Could not load ${state.repoId}",
+            // Verbatim: the SDK's exceptions name the missing feature or artifact, and paraphrasing
+            // them is how the diagnosis gets lost.
+            detail = state.reason,
+        )
+        is ModelState.Loaded -> content(state.model)
+    }
+}
+
+/** A labelled section, used by every screen so the app reads as one thing. */
+@Composable
+fun Section(title: String, content: @Composable () -> Unit) {
+    Card(
+        Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 6.dp),
+        colors = CardDefaults.cardColors(),
+    ) {
+        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(title, style = MaterialTheme.typography.titleSmall)
+            content()
+        }
+    }
+}
+
+/**
+ * A label and a switch, with the **label** giving way when space runs out.
+ *
+ * `SpaceBetween` alone lets the text claim its full intrinsic width and pushes the switch past the
+ * right edge — which is how "Also request the RAG feature (~91 MB encoder)" ended up with an
+ * unreachable control. `weight(1f)` makes the label the flexible half, so the switch keeps its fixed
+ * size and stays on screen and the label wraps instead.
+ */
+@Composable
+fun LabeledSwitch(label: String, checked: Boolean, onChange: (Boolean) -> Unit) {
+    Row(
+        Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.spacedBy(12.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(label, style = MaterialTheme.typography.bodyMedium, modifier = Modifier.weight(1f))
+        Switch(checked = checked, onCheckedChange = onChange)
+    }
+}
+
+/**
+ * A numeric field that refuses to write a malformed value rather than silently coercing it to 0.
+ *
+ * It now also **shows what you typed**. The previous version rendered `value.toString()` and dropped
+ * any keystroke that did not parse, which makes the field feel broken in the most ordinary editing
+ * there is: clearing "128" to type "256" produces an empty string, which does not parse, so the field
+ * snapped back to "128" and the keyboard appeared dead. The text is local state; the config is
+ * written only when the text parses and satisfies [range].
+ */
+@Composable
+fun IntField(label: String, value: Int, range: IntRange? = null, hint: String? = null, onChange: (Int) -> Unit) {
+    var text by remember(value) { mutableStateOf(value.toString()) }
+    val parsed = text.toIntOrNull()
+    val error = parsed == null || (range != null && parsed !in range)
+
+    OutlinedTextField(
+        value = text,
+        onValueChange = { new ->
+            text = new
+            new.toIntOrNull()?.let { if (range == null || it in range) onChange(it) }
+        },
+        label = { Text(label) },
+        isError = error,
+        supportingText = {
+            when {
+                parsed == null && text.isNotBlank() -> Text("not a whole number")
+                range != null && parsed != null && parsed !in range ->
+                    Text("must be between ${range.first} and ${range.last}")
+                hint != null -> Text(hint)
+            }
+        },
+        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+        singleLine = true,
+        modifier = Modifier.fillMaxWidth(),
+    )
+}
+
+@Composable
+fun FloatField(
+    label: String,
+    value: Float,
+    range: ClosedFloatingPointRange<Float>? = null,
+    hint: String? = null,
+    onChange: (Float) -> Unit,
+) {
+    var text by remember(value) { mutableStateOf(value.toString()) }
+    val parsed = text.toFloatOrNull()
+    val error = parsed == null || (range != null && parsed !in range)
+
+    OutlinedTextField(
+        value = text,
+        onValueChange = { new ->
+            text = new
+            new.toFloatOrNull()?.let { if (range == null || it in range) onChange(it) }
+        },
+        label = { Text(label) },
+        isError = error,
+        supportingText = {
+            when {
+                parsed == null && text.isNotBlank() -> Text("not a number")
+                range != null && parsed != null && parsed !in range ->
+                    Text("must be between ${range.start} and ${range.endInclusive}")
+                hint != null -> Text(hint)
+            }
+        },
+        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+        singleLine = true,
+        modifier = Modifier.fillMaxWidth(),
+    )
+}
+
+/**
+ * A picker over a closed set.
+ *
+ * Several settings the SDK models as enums or as a fixed registry were rendered as free text, which
+ * turns a choice into a spelling test whose failure surfaces far from where it was made: mistyping
+ * `DatasetConfig.task` is accepted here and reported as `Unsupported task: …` minutes into a training
+ * run, on a different screen. Anything with a knowable set of values belongs here instead.
+ *
+ * @param describe optional second line per option, for sets whose names do not explain themselves.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun <T> Dropdown(
+    label: String,
+    options: List<T>,
+    selected: T?,
+    optionLabel: (T) -> String,
+    describe: (T) -> String? = { null },
+    onSelect: (T) -> Unit,
+) {
+    var expanded by remember { mutableStateOf(false) }
+
+    ExposedDropdownMenuBox(
+        expanded = expanded,
+        onExpandedChange = { expanded = it },
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        OutlinedTextField(
+            value = selected?.let(optionLabel) ?: "",
+            onValueChange = { },
+            readOnly = true,
+            label = { Text(label) },
+            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
+            supportingText = selected?.let(describe)?.let { { Text(it) } },
+            modifier = Modifier.menuAnchor().fillMaxWidth(),
+        )
+        ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
+            options.forEach { option ->
+                DropdownMenuItem(
+                    text = {
+                        Column {
+                            Text(optionLabel(option))
+                            describe(option)?.let {
+                                Text(it, style = MaterialTheme.typography.bodySmall)
+                            }
+                        }
+                    },
+                    onClick = {
+                        onSelect(option)
+                        expanded = false
+                    },
+                )
+            }
+        }
+    }
+}
+
+/** A row of chips over a closed set — the compact form of [Dropdown] for three or four options. */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun <T> ChipPicker(label: String, options: List<T>, selected: T?, optionLabel: (T) -> String, onSelect: (T) -> Unit) {
+    Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        Text(label, style = MaterialTheme.typography.labelMedium)
+        // Wraps for the same reason ActionRow does: four chips with real labels do not fit a phone.
+        FlowRow(
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp),
+        ) {
+            options.forEach { option ->
+                FilterChip(
+                    selected = option == selected,
+                    onClick = { onSelect(option) },
+                    label = { Text(optionLabel(option)) },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun TextField(label: String, value: String, onChange: (String) -> Unit) {
+    OutlinedTextField(
+        value = value,
+        onValueChange = onChange,
+        label = { Text(label) },
+        singleLine = true,
+        modifier = Modifier.fillMaxWidth(),
+    )
+}
+
+/**
+ * A collapsible "what do I do here" card.
+ *
+ * The showcase app is the reference example for the SDK, and someone opening it for the first time on
+ * a real phone has no way to know that the order matters (nothing works before a package is pulled),
+ * that a pull is gigabytes, or that the Tool calls screen is *supposed* to refuse until the model has
+ * been fine-tuned. None of that is discoverable from the controls themselves, and a wrong expectation
+ * reads as a broken app.
+ *
+ * Collapsible because it is scaffolding: useful once, noise afterwards.
+ */
+@Composable
+fun Guide(title: String, steps: List<String>, initiallyExpanded: Boolean = true) {
+    var expanded by remember { mutableStateOf(initiallyExpanded) }
+    Card(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 6.dp)) {
+        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Row(
+                Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(title, style = MaterialTheme.typography.titleSmall)
+                TextButton(onClick = { expanded = !expanded }) {
+                    Text(if (expanded) "Hide" else "Show")
+                }
+            }
+            if (expanded) {
+                steps.forEach { step ->
+                    Text(step, style = MaterialTheme.typography.bodySmall)
+                }
+            }
+        }
+    }
+}
+
+/**
+ * A collapsed disclosure for the *justification* behind a control.
+ *
+ * The screens accumulated multi-sentence paragraphs explaining why a setting exists, why a default is
+ * what it is, and what happens if you choose wrong. Every one of those was written because someone
+ * would otherwise read the behaviour as a bug — so none of it is deletable — but stacked above the
+ * controls it buried them, and a user looking for a switch had to read an essay to find it.
+ *
+ * The rule this encodes: **lead with the control, put the argument behind [Details].** Distinct from
+ * [Guide], which is a whole-screen walkthrough shown once, and from [ScreenIntro], which is the one
+ * always-visible line saying what you are looking at.
+ *
+ * Collapsed by default, unlike [Guide] — this is reference material for the moment something looks
+ * wrong, not an introduction.
+ */
+@Composable
+fun Details(label: String = "Why?", content: @Composable () -> Unit) {
+    var expanded by remember { mutableStateOf(false) }
+    Column {
+        TextButton(onClick = { expanded = !expanded }, contentPadding = PaddingValues(0.dp)) {
+            Text(
+                if (expanded) "$label  ▾" else "$label  ▸",
+                style = MaterialTheme.typography.labelMedium,
+            )
+        }
+        if (expanded) content()
+    }
+}
+
+/** [Details] over a single paragraph — the common case, so callers do not repeat the `Text` styling. */
+@Composable
+fun Details(text: String, label: String = "Why?") {
+    Details(label) { Text(text, style = MaterialTheme.typography.bodySmall) }
+}
+
+/**
+ * One line saying what a screen does and what to expect from it.
+ *
+ * Deliberately separate from [Guide]: this always shows, because "what am I looking at" stays useful
+ * after "how do I start" stops being.
+ */
+@Composable
+fun ScreenIntro(text: String) {
+    Text(
+        text,
+        style = MaterialTheme.typography.bodySmall,
+        modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp),
+    )
+}
+
+/**
+ * Tabs *within* one drawer destination.
+ *
+ * Now that the drawer carries navigation, a tab row means one thing only: alternative views of the
+ * same subject. Configuration splits into the config objects it edits; Models splits into where a
+ * package comes from. Previously the tab row was the navigation, so it had to carry six unrelated
+ * destinations and could express neither grouping nor dependency.
+ */
+@Composable
+fun SubTabs(titles: List<String>, selected: Int, onSelect: (Int) -> Unit) {
+    TabRow(selectedTabIndex = selected) {
+        titles.forEachIndexed { index, title ->
+            Tab(
+                selected = index == selected,
+                onClick = { onSelect(index) },
+                text = { Text(title, style = MaterialTheme.typography.labelLarge) },
+            )
+        }
+    }
+}
+
+/**
+ * A row of actions with one primary.
+ *
+ * Buttons were previously laid out ad hoc per screen, so identical action rows had different spacing
+ * and no shared baseline — the "unaligned buttons" that read as sloppiness rather than as a bug.
+ *
+ * **Wraps.** It was a plain `Row`, which lays children out past the right edge rather than onto a
+ * second line, so any row of three buttons whose labels were long enough lost the last one entirely —
+ * off screen, unreachable, with nothing to indicate it existed. Three-button rows are the norm here
+ * (Start / Cancel / Merge, Install / Load / Unload), so this was a matter of label length, not of
+ * layout intent.
+ *
+ * @param modifier for call sites that live outside a [Section] and must supply their own padding —
+ *   a bare `fillMaxWidth()` row sits flush against the screen edge.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun ActionRow(modifier: Modifier = Modifier, content: @Composable () -> Unit) {
+    FlowRow(
+        modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterVertically),
+    ) { content() }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ConfigurationScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ConfigurationScreen.kt
new file mode 100644
index 0000000..1b36f0c
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ConfigurationScreen.kt
@@ -0,0 +1,461 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.Tasks
+import com.martinkorelic.mobiletransformers.app.ActionAllowlist
+import com.martinkorelic.mobiletransformers.app.PermissionGate
+import com.martinkorelic.mobiletransformers.app.viewmodels.ConfigurationViewModel
+import com.martinkorelic.mobiletransformers.app.viewmodels.label
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftDescription
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftDisplayName
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftOf
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftOptions
+import com.martinkorelic.mobiletransformers.constants.CoreConfigId
+import com.martinkorelic.mobiletransformers.constants.ExecutionProvider
+import com.martinkorelic.mobiletransformers.constants.IndexingMode
+import com.martinkorelic.mobiletransformers.constants.MemoryConfigId
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.constants.SchedulerType
+import com.martinkorelic.mobiletransformers.constants.SearchType
+
+/**
+ * The knobs, expressed through the public config types.
+ *
+ * If a setting here needed an `ORT*` type to express, that would be a facade gap. None
+ * did — which is the result this screen reports.
+ *
+ * ### Why it is tabbed, and why so much of it is now pickers
+ *
+ * It was one scroll of ~25 fields with no grouping, and several of them were **text fields over
+ * closed sets**: `task` had to be spelled exactly right from a list in a help paragraph, and the
+ * device options were not editable at all despite being on every public config. A mistyped task is
+ * accepted here and reported as `Unsupported task: …` minutes into a training run, on a different
+ * screen — which is the worst possible place to learn about a typo. Anything with a knowable set of
+ * values is a [Dropdown] or a [ChipPicker] now.
+ */
+
+/**
+ * The tabs of the Configuration screen, in order.
+ *
+ * An enum rather than bare indices because other screens now link *into* a specific tab — Chat's
+ * "Settings" opens [Generation] — and `destination = Configuration; tab = 0` is the kind of coupling
+ * that silently points somewhere else the moment a tab is inserted.
+ */
+enum class ConfigurationTab(val label: String) {
+    Generation("Generation"),
+    Training("Training"),
+    Dataset("Dataset"),
+    Retrieval("Retrieval"),
+    Actions("Actions"),
+    Device("Device"),
+}
+
+@Composable
+fun ConfigurationScreen(
+    vm: ConfigurationViewModel,
+    initialTab: ConfigurationTab = ConfigurationTab.Generation,
+) {
+    // Keyed on `initialTab` so arriving from Chat's "Settings" lands on Generation even if this
+    // screen was last left on another tab — otherwise the link would sometimes open the wrong page,
+    // which is exactly the confusion it exists to remove.
+    var tab by remember(initialTab) { mutableIntStateOf(initialTab.ordinal) }
+
+    Column(Modifier.fillMaxSize()) {
+        SubTabs(ConfigurationTab.entries.map { it.label }, tab) { tab = it }
+
+        Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {
+            when (ConfigurationTab.entries[tab]) {
+                ConfigurationTab.Generation -> GenerationTab(vm)
+                ConfigurationTab.Training -> TrainingTab(vm)
+                ConfigurationTab.Dataset -> DatasetTab(vm)
+                ConfigurationTab.Retrieval -> RetrievalTab(vm)
+                ConfigurationTab.Actions -> ActionsTab()
+                ConfigurationTab.Device -> DeviceTab(vm)
+            }
+
+            OutlinedButton(onClick = vm::reset, modifier = Modifier.padding(16.dp)) {
+                Text("Reset every section to SDK defaults")
+            }
+        }
+    }
+}
+
+@Composable
+private fun GenerationTab(vm: ConfigurationViewModel) {
+    val gen by vm.generation.collectAsState()
+
+    Section("Length and sampling") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField(
+                "maxNewTokens", gen.maxNewTokens, range = 1..4096,
+                hint = "how many tokens to generate before stopping",
+                onChange = vm::setMaxNewTokens,
+            )
+            ChipPicker(
+                "sampling method",
+                SamplingMethod.entries,
+                gen.sampling.method,
+                { it.wire },
+                vm::setSamplingMethod,
+            )
+            // Only the knobs the chosen method actually reads. Showing topK beside GREEDY invites the
+            // reasonable conclusion that changing it will do something.
+            when (gen.sampling.method) {
+                SamplingMethod.GREEDY -> Text(
+                    "Greedy takes the highest-probability token every step, so temperature, topK, " +
+                        "topP and seed have no effect — the output is deterministic.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                SamplingMethod.TOP_K -> {
+                    FloatField("temperature", gen.sampling.temperature, 0.01f..5f, onChange = vm::setTemperature)
+                    IntField("topK", gen.sampling.topK, 1..1000, onChange = vm::setTopK)
+                    IntField("seed", gen.sampling.seed, onChange = vm::setSeed)
+                }
+                SamplingMethod.TOP_P -> {
+                    FloatField("temperature", gen.sampling.temperature, 0.01f..5f, onChange = vm::setTemperature)
+                    FloatField("topP", gen.sampling.topP, 0f..1f, onChange = vm::setTopP)
+                    IntField("seed", gen.sampling.seed, onChange = vm::setSeed)
+                }
+            }
+        }
+    }
+
+    Section("Prompt and weights") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            TextField("systemPrompt", gen.systemPrompt ?: "", vm::setSystemPrompt)
+            LabeledSwitch("loadMerged", gen.loadMerged, vm::setLoadMerged)
+            Text(
+                "loadMerged generates from the merged weights a training run wrote back into the " +
+                    "inference graph. Off, you are generating from the package as it was pulled — " +
+                    "which is how to compare before and after fine-tuning.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+}
+
+@Composable
+private fun TrainingTab(vm: ConfigurationViewModel) {
+    val train by vm.train.collectAsState()
+    val peft by vm.peft.collectAsState()
+
+    Section("Run length") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField("epochs", train.epochs, 1..100, onChange = vm::setEpochs)
+            IntField("batchSize", train.batchSize, 1..64, onChange = vm::setBatchSize)
+            IntField(
+                "maxSteps (0 = unbounded)", train.maxSteps ?: 0, 0..100_000,
+                hint = "an upper bound, not a target",
+            ) { vm.setMaxSteps(it.takeIf { v -> v > 0 }) }
+            Text(
+                "maxSteps is an upper bound — training also stops at the end of the epoch, so " +
+                    "rows / batchSize wins when it is smaller. Measured: a run asking for 120 steps " +
+                    "took 54 because the dataset held 108 rows.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+
+    Section("Optimizer") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField(
+                "gradientAccumulationSteps", train.gradientAccumulationSteps, 1..64,
+                onChange = vm::setGradientAccumulationSteps,
+            )
+            Text(
+                "The optimizer steps on globalStep % gradAccumSteps == 0. At the default of 4 a short " +
+                    "bounded run can finish, report success on every callback, and apply no update " +
+                    "at all — set it to 1 for a quick demo run.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            FloatField("learningRate", train.learningRate, 0f..1f, onChange = vm::setLearningRate)
+            ChipPicker("scheduler", SchedulerType.entries, train.scheduler, { it.wire }, vm::setScheduler)
+            IntField("warmupSteps", train.warmupSteps, 0..10_000, onChange = vm::setWarmupSteps)
+        }
+    }
+
+    Section("PEFT method") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Dropdown(
+                label = "method",
+                options = peftOptions,
+                selected = peft.label,
+                // The list stays wire values — `onSelect` feeds `peftOf`, which matches on them —
+                // and only the rendering is prettied. Mapping the options themselves would make the
+                // lookup depend on display text.
+                optionLabel = { peftDisplayName(it) },
+                describe = { peftDescription(it) },
+                onSelect = { vm.setPeft(peftOf(it, peft.rank, peft.alpha)) },
+            )
+            IntField("rank", peft.rank, 1..256, onChange = vm::setPeftRank)
+            IntField("alpha", peft.alpha, 1..256, onChange = vm::setPeftAlpha)
+            Text(
+                "PEFT topology is fixed at export time, so this selects and validates against what " +
+                    "the installed package was built with rather than rewriting the graph. A " +
+                    "mismatch is reported here, at selection, instead of failing a training run.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+
+    Section("After the run") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            LabeledSwitch("mergeAtEnd", train.mergeAtEnd, vm::setMergeAtEnd)
+            LabeledSwitch("resumeFromState", train.resumeFromState, vm::setResumeFromState)
+        }
+    }
+}
+
+@Composable
+private fun DatasetTab(vm: ConfigurationViewModel) {
+    val dataset by vm.dataset.collectAsState()
+    val context = LocalContext.current
+    val modelState by vm.modelState.collectAsState()
+    // Re-read when the model changes: the files live inside the loaded package's train/ stage.
+    val trainFiles = remember(modelState) { vm.availableTrainFiles(context) }
+
+    Section("Which file, and how to read it") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            if (trainFiles.isEmpty()) {
+                Text(
+                    "No .jsonl files in the loaded package's train/ stage. Model packages ship no " +
+                        "training data by design — use 'Install sample dataset' on the Training " +
+                        "screen, or push your own into that directory.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                TextField("trainFile", dataset.trainFile, vm::setTrainFile)
+            } else {
+                Dropdown(
+                    label = "trainFile",
+                    options = trainFiles,
+                    selected = dataset.trainFile.takeIf { it in trainFiles },
+                    optionLabel = { it },
+                    onSelect = vm::setTrainFile,
+                )
+            }
+
+            Dropdown(
+                label = "task (the preprocessor that parses it)",
+                options = vm.taskOptions,
+                selected = vm.taskOptions.firstOrNull { it.name == dataset.task },
+                optionLabel = { it.name },
+                describe = { it.description },
+                onSelect = { vm.setTask(it.name) },
+            )
+            Text(
+                "The task names come from the trainer's own dispatch, so this list cannot drift from " +
+                    "what it accepts. Leaving it unset uses whatever the package declares; a package " +
+                    "declaring nothing fails closed rather than guessing how to parse your rows.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+
+    Section("Shape") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField(
+                "maxSequenceLength", dataset.maxSequenceLength, 8..4096,
+                hint = "tokens per example; longer costs memory quadratically in attention",
+                onChange = vm::setMaxSequenceLength,
+            )
+            IntField(
+                "maxDatasetLength", dataset.maxDatasetLength, 1..100_000,
+                hint = "rows to read; caps a long run on a phone",
+                onChange = vm::setMaxDatasetLength,
+            )
+        }
+    }
+}
+
+@Composable
+private fun RetrievalTab(vm: ConfigurationViewModel) {
+    val rag by vm.rag.collectAsState()
+
+    Section("Search") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField("topK", rag.topK, 1..100, hint = "chunks retrieved per query", onChange = vm::setTopKRag)
+            ChipPicker("searchType", SearchType.entries, rag.searchType, { it.wire }, vm::setSearchType)
+            FloatField(
+                "minScore", rag.minScore.toFloat(), 0f..1f,
+                hint = "drop matches below this cosine similarity",
+            ) { vm.setMinScore(it.toDouble()) }
+            Text(
+                "similarityMetric is ${rag.similarityMetric} and read-only — the on-device vector " +
+                    "store uses cosine similarity.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+
+    Section("Chunking") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            IntField("chunkSize", rag.chunkSize, 32..4096, onChange = vm::setChunkSize)
+            IntField(
+                "chunkOverlap", rag.chunkOverlap, 0..1024,
+                hint = "characters repeated between adjacent chunks",
+                onChange = vm::setChunkOverlap,
+            )
+            ChipPicker(
+                "indexingMode",
+                IndexingMode.entries,
+                rag.indexingMode,
+                { it.wire },
+                // DYNAMIC is a fail-closed stub in v1, so selecting it would produce a refusal. It is
+                // shown because the enum has it, and the note says what it does.
+                { },
+            )
+            Text(
+                "indexingMode is ${rag.indexingMode.wire}. DYNAMIC is declared by the enum but fails " +
+                    "closed in v1, so it is not selectable here.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            Text(
+                "The embedding identity (repo, file, dimension) defaults to whatever the package " +
+                    "declares in embedding/rag_config.json. Hardcoding it would point the retriever " +
+                    "at a vector width the package need not have.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+}
+
+@Composable
+private fun DeviceTab(vm: ConfigurationViewModel) {
+    val device by vm.device.collectAsState()
+
+    Section("Execution") {
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(
+                "These apply to generation, training and retrieval together.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            Dropdown(
+                label = "executionProvider",
+                options = ExecutionProvider.entries,
+                selected = device.executionProvider,
+                optionLabel = { it.wire },
+                describe = {
+                    when (it) {
+                        ExecutionProvider.CPU -> "the guaranteed floor; works on every device"
+                        ExecutionProvider.XNNPACK -> "optimized CPU kernels; usually the fastest here"
+                        ExecutionProvider.NNAPI -> "vendor accelerator, where the device offers one"
+                    }
+                },
+                onSelect = vm::setExecutionProvider,
+            )
+            Dropdown(
+                label = "coreConfigId",
+                options = CoreConfigId.entries,
+                selected = device.coreConfigId,
+                optionLabel = { it.wire },
+                onSelect = vm::setCoreConfig,
+            )
+            Dropdown(
+                label = "memoryConfigId",
+                options = MemoryConfigId.entries,
+                selected = device.memoryConfigId,
+                optionLabel = { it.wire },
+                describe = {
+                    when (it) {
+                        MemoryConfigId.LOW_MEM -> "smaller arenas; for devices near their ceiling"
+                        MemoryConfigId.HIGH_PERF -> "larger arenas; the default"
+                    }
+                },
+                onSelect = vm::setMemoryConfig,
+            )
+            LabeledSwitch("enableProfiling", device.enableProfiling, vm::setProfiling)
+            Details(
+                "Profiling writes an ONNX Runtime trace beside the model. Useful once, expensive " +
+                    "every time — it slows the session it measures.",
+            )
+        }
+    }
+
+    Section("When these take effect") {
+        Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            // Kept visible, not collapsed: this one is a *consequence* a user hits immediately —
+            // changing a dropdown and seeing nothing happen reads as a broken control.
+            Text(
+                "On the next load, training run or ingest — not the session already open.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            Details(
+                "A session reads its device options when it is created. Reload from Models to apply " +
+                    "them to generation now.",
+            )
+        }
+    }
+}
+
+/**
+ * What this app will let a model do — the allowlist, read-only.
+ *
+ * Moved here from a collapsible panel inside Chat, where it was three sentences of security rationale
+ * sitting in the middle of a conversation. It is reference material: a user consults it once to learn
+ * what "can call tools" actually permits, and never again mid-chat.
+ *
+ * Read-only on purpose. Editing the allowlist at runtime would make it a setting, and its whole value
+ * is that it is fixed when the app is built — the set of intents any model output can reach is decided
+ * in source, not in a preferences screen.
+ */
+@Composable
+private fun ActionsTab() {
+    val context = LocalContext.current
+
+    Section("What a model may ask for") {
+        Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+            Text(
+                "A model picks an action from this list by name. It can never name an intent — those " +
+                "come only from here — so this is the complete set of things any reply can reach.",
+                    style = MaterialTheme.typography.bodySmall,
+            )
+            ActionAllowlist.ENTRIES.forEach { spec ->
+                Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+                    Text(spec.actionName, style = MaterialTheme.typography.titleSmall)
+                    Text(spec.allowedIntent, style = MaterialTheme.typography.labelSmall)
+                    if (spec.parameters.isNotEmpty()) {
+            Text(
+                            "takes ${spec.parameters.keys.joinToString()}",
+                    style = MaterialTheme.typography.bodySmall,
+            )
+            }
+                    // Granted or not, stated plainly: a permission the app is missing is the
+                    // difference between an action that runs and one that fails at the last step.
+                    spec.requiredPermissions.forEach { permission ->
+                        val granted = PermissionGate.missing(context, listOf(permission)).isEmpty()
+            Text(
+                            "needs $permission — ${if (granted) "granted" else "NOT granted"}",
+                    style = MaterialTheme.typography.bodySmall,
+            )
+            }
+            }
+            }
+            }
+            }
+
+    Section("Running a call") {
+            Text(
+            "An accepted call is shown in the conversation with a Run button; nothing fires on its " +
+            "own. Whether a reply is a call is read from the reply, so there is nothing to switch " +
+            "on beforehand.",
+                    style = MaterialTheme.typography.bodySmall,
+            )
+            }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/FederatedScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/FederatedScreen.kt
new file mode 100644
index 0000000..3b92b6f
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/FederatedScreen.kt
@@ -0,0 +1,93 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.BuildConfig
+import com.martinkorelic.mobiletransformers.app.viewmodels.FederatedViewModel
+
+/**
+ * One federated round, with the consent gate on screen rather than implied.
+ *
+ * The disabled state is shown honestly. `FEDERATION_ENABLED` is false by default, and rather than
+ * hiding the feature the screen says so and still lets the button be pressed — the resulting
+ * `FederatedConsentException` names the missing protection, which is more useful to an integrator than
+ * a greyed-out control with no explanation.
+ */
+@Composable
+fun FederatedScreen(vm: FederatedViewModel) {
+    val ui by vm.ui.collectAsState()
+    val state by vm.modelState.collectAsState()
+
+    ModelGate(state, needs = "A federated round trains locally, so it needs a train-capable package.") {
+        Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {
+            if (!BuildConfig.FEDERATION_ENABLED) {
+                EmptyState(
+                    title = "Federation is disabled in this build",
+                    detail = "BuildConfig.FEDERATION_ENABLED = false. It is off by default and must be " +
+                        "enabled deliberately by the app that ships it. Running a round below will " +
+                        "fail closed and name this as the reason.",
+                )
+            }
+
+            Section("Gateway") {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    TextField("Gateway URL", ui.gatewayUrl, vm::onGatewayChanged)
+                    TextField("Client auth token", ui.token, vm::onTokenChanged)
+                    LabeledSwitch("Consent granted", ui.consentGranted, vm::onConsentChanged)
+                    Details(
+                        "Consent, TLS and auth are checked before any tensor is read. Only adapter " +
+                            "factors and aggregate metrics ever leave the device — never examples.",
+                        label = "What leaves the device",
+                    )
+                }
+            }
+
+            Section("Round ${ui.round}") {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    // Control first: the three-stage description is what a round IS, which matters
+                    // once, and sat above the only button on the screen every time.
+                    Button(onClick = vm::runRound, enabled = !ui.running) {
+                        Text(if (ui.running) "Running…" else "Run one round")
+                    }
+                    Details(
+                        "Import the global adapter → train locally → export this device's update. " +
+                            "Round 0 imports nothing: a device must be able to join a cohort that has " +
+                            "not published an aggregate yet.",
+                        label = "What a round does",
+                    )
+                }
+            }
+
+            ui.result?.let { r ->
+                Section("Result") {
+                    Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                        Text("round ${r.round}")
+                        Text("imported tensors: ${r.importedTensors}")
+                        Text("trained locally: ${r.trainedLocally}")
+                        Text("upload payload: ${r.payloadBytes} B", style = MaterialTheme.typography.bodyLarge)
+                        Text("Nothing was uploaded.", style = MaterialTheme.typography.bodySmall)
+                        Details(
+                            "The round returns bytes; handing them to a gateway is the caller's " +
+                                "choice, which is what lets the whole loop run against a local " +
+                                "`federated serve`.",
+                        )
+                    }
+                }
+            }
+
+            ui.error?.let { Section("Refused / error") { Text(it) } }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/LossChart.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/LossChart.kt
new file mode 100644
index 0000000..69912fb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/LossChart.kt
@@ -0,0 +1,257 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.text.ExperimentalTextApi
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.viewmodels.StepPoint
+import kotlin.math.abs
+
+/**
+ * The training run as a picture: loss per step, with learning rate beneath it.
+ *
+ * ### Why the app needed one
+ *
+ * `TrainingEvent.Step` has always carried `stepLoss`, `epochLoss`, `learningRate` and
+ * `stepDurationMs`, and the Train screen rendered the whole event with `toString()` into a scrolling
+ * list of data-class dumps. Everything needed to see whether a run was working was arriving and being
+ * thrown away — and "is the loss going down" is the only question a fine-tuning demo has to answer.
+ *
+ * ### Why two charts rather than one with two axes
+ *
+ * Loss and learning rate differ by four orders of magnitude, so plotting both against one y-axis makes
+ * one of them a flat line; plotting them against *two* y-axes is worse, because the alignment between
+ * the two scales is arbitrary and the reader sees a relationship the data does not contain. Small
+ * multiples over a shared x-axis show both honestly: same steps, separate scales, no implied
+ * correlation.
+ *
+ * One series per chart, so neither needs a legend — the title names it. Colors come from the theme,
+ * and no text is drawn in a series colour: the numbers wear text tokens and the line carries identity.
+ */
+@Composable
+fun TrainingCharts(points: List<StepPoint>, modifier: Modifier = Modifier) {
+    if (points.size < 2) {
+        Text(
+            if (points.isEmpty()) {
+                "No steps yet — the curve appears once training reports its first step."
+            } else {
+                "One step so far; a curve needs two."
+            },
+            style = MaterialTheme.typography.bodySmall,
+            modifier = modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+        )
+        return
+    }
+
+    Column(modifier, verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        StatTiles(points)
+
+        LineChart(
+            title = "Loss",
+            values = points.map { it.loss },
+            steps = points.map { it.step },
+            color = MaterialTheme.colorScheme.primary,
+            height = 160.dp,
+            format = { "%.4f".format(it) },
+        )
+
+        LineChart(
+            title = "Learning rate",
+            values = points.map { it.learningRate },
+            steps = points.map { it.step },
+            color = MaterialTheme.colorScheme.tertiary,
+            height = 80.dp,
+            format = { "%.2e".format(it) },
+        )
+    }
+}
+
+/**
+ * The three numbers worth reading without decoding a curve.
+ *
+ * "Δ from first" is the one that answers the actual question — a loss that has not moved is the
+ * failure mode a short run at the default `gradientAccumulationSteps` produces silently.
+ */
+@Composable
+private fun StatTiles(points: List<StepPoint>) {
+    val first = points.first().loss
+    val last = points.last().loss
+    val delta = last - first
+
+    Row(
+        Modifier.fillMaxWidth().padding(horizontal = 16.dp),
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Tile("loss now", "%.4f".format(last), Modifier.weight(1f))
+        Tile("best", "%.4f".format(points.minOf { it.loss }), Modifier.weight(1f))
+        Tile(
+            "Δ from first",
+            (if (delta <= 0) "−" else "+") + "%.4f".format(abs(delta)),
+            Modifier.weight(1f),
+        )
+    }
+}
+
+@Composable
+private fun Tile(label: String, value: String, modifier: Modifier = Modifier) {
+    Column(modifier) {
+        Text(
+            label,
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Text(value, style = MaterialTheme.typography.titleMedium)
+    }
+}
+
+/**
+ * One series over global step, with a labelled x-axis.
+ *
+ * ### Three things this got wrong
+ *
+ * - **`strokeWidth = 1f` is one *pixel*, not one dp.** At this device's 3x density that is a third of
+ *   a dp, which lands between physical pixels and renders as a barely-visible grey smear — the axes
+ *   looked absent.
+ * - **The x-axis was drawn at exactly `y = h`**, the last row of the canvas, so half the stroke fell
+ *   outside the drawing bounds and was clipped. What survived was half of an already-invisible line:
+ *   "cut off at the bottom" was literally true.
+ * - **There were no ticks.** The only x information was a `step 0 → 108` caption under the plot, so a
+ *   reader could see the range but could not place any point within it.
+ *
+ * Now the canvas reserves gutters and the series is drawn into a plot rect inset from them, which is
+ * what leaves room for tick labels without clipping either axis. Ticks are drawn with the measured
+ * text so they sit exactly under their gridline rather than being approximated by a `Row`.
+ *
+ * Still deliberately sparse: no grid, hairline axes one shade off the surface, one direct label at
+ * the last point. At phone width a gridded 160dp plot is mostly grid, and every value is also in the
+ * Events list below, which is this chart's table-view twin.
+ */
+@OptIn(ExperimentalTextApi::class)
+@Composable
+private fun LineChart(
+    title: String,
+    values: List<Float>,
+    steps: List<Int>,
+    color: Color,
+    height: androidx.compose.ui.unit.Dp,
+    format: (Float) -> String,
+) {
+    val axis = MaterialTheme.colorScheme.outlineVariant
+    val tickInk = MaterialTheme.colorScheme.onSurfaceVariant
+    val tickStyle = MaterialTheme.typography.labelSmall
+    val measurer = rememberTextMeasurer()
+
+    val min = values.min()
+    val max = values.max()
+    // A flat series has zero range; without a floor every point maps to the same y and the line
+    // collapses onto an edge.
+    val span = (max - min).takeIf { it > 1e-9f } ?: 1f
+
+    Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp)) {
+        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+            Text(title, style = MaterialTheme.typography.labelMedium)
+            // The direct label: current value, in text ink rather than the series colour.
+            Text(
+                format(values.last()),
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+
+        // The gutter is part of the canvas, not padding around it: the axis has to be drawn INSIDE
+        // the drawing bounds or it gets clipped, and the tick labels need somewhere to live.
+        Canvas(Modifier.fillMaxWidth().height(height + X_AXIS_GUTTER).padding(top = 6.dp)) {
+            val gutter = X_AXIS_GUTTER.toPx()
+            val stroke = 1.dp.toPx()
+            // Inset by half a stroke so neither axis is half-outside the canvas.
+            val left = stroke / 2f
+            val right = size.width - stroke / 2f
+            val top = stroke / 2f
+            val bottom = size.height - gutter
+
+            drawLine(axis, Offset(left, bottom), Offset(right, bottom), strokeWidth = stroke)
+            drawLine(axis, Offset(left, top), Offset(left, bottom), strokeWidth = stroke)
+
+            val plotWidth = right - left
+            val plotHeight = bottom - top
+            fun xAt(index: Int): Float =
+                if (values.size == 1) left else left + plotWidth * index / (values.size - 1).toFloat()
+            fun yAt(value: Float): Float =
+                // Inverted: canvas y grows downward, and a falling loss must read as falling.
+                bottom - ((value - min) / span) * plotHeight
+
+            // Ticks at the ends and at even fractions between, capped so labels cannot collide on a
+            // narrow screen. Indices, not step numbers, so a run with irregular step reporting still
+            // puts every tick on a real data point.
+            val tickCount = minOf(MAX_X_TICKS, values.size)
+            val tickIndices = if (tickCount <= 1) {
+                listOf(0)
+            } else {
+                (0 until tickCount).map { it * (values.size - 1) / (tickCount - 1) }
+            }
+            for (index in tickIndices.distinct()) {
+                val x = xAt(index)
+                drawLine(
+                    axis,
+                    Offset(x, bottom),
+                    Offset(x, bottom + TICK_LENGTH.toPx()),
+                    strokeWidth = stroke,
+                )
+                val label = measurer.measure(steps[index].toString(), tickStyle)
+                // Centred on the tick, then nudged inward at the edges so the first and last labels
+                // stay inside the canvas instead of being clipped by it.
+                val half = label.size.width / 2f
+                val labelX = (x - half).coerceIn(0f, size.width - label.size.width)
+                drawText(
+                    textLayoutResult = label,
+                    color = tickInk,
+                    topLeft = Offset(labelX, bottom + TICK_LENGTH.toPx() + 2.dp.toPx()),
+                )
+            }
+
+            val path = Path()
+            values.forEachIndexed { i, v ->
+                val x = xAt(i)
+                val y = yAt(v)
+                if (i == 0) path.moveTo(x, y) else path.lineTo(x, y)
+            }
+            drawPath(path, color, style = Stroke(width = 2.dp.toPx(), cap = StrokeCap.Round))
+
+            // The endpoint, so the current value is locatable on the curve.
+            drawCircle(color, radius = 4.dp.toPx(), center = Offset(xAt(values.size - 1), yAt(values.last())))
+        }
+
+        Text(
+            "step",
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+        )
+    }
+}
+
+/** Room under the plot for the tick marks and their labels. */
+private val X_AXIS_GUTTER = 18.dp
+
+private val TICK_LENGTH = 3.dp
+
+/** Enough to place a point, few enough that the labels never collide at phone width. */
+private const val MAX_X_TICKS = 5
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelBar.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelBar.kt
new file mode 100644
index 0000000..242e08e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelBar.kt
@@ -0,0 +1,367 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.DownloadUi
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftDisplayName
+import com.martinkorelic.mobiletransformers.app.ModelActivity
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.app.ui.theme.statusColors
+
+/**
+ * A one-line answer to "what is loaded, is it busy, and what can it do", pinned under the app bar on
+ * every screen.
+ *
+ * ### Why the app needed this
+ *
+ * The loaded model was reported in exactly one place — a "Current model" card partway down the Models
+ * screen. Everywhere else the model was invisible, so the answer to "why did Chat just refuse me" or
+ * "is this the package I trained" required navigating away from the thing that raised the question.
+ * Worse, a pull in progress was equally invisible: leaving Models mid-download looked exactly like no
+ * download running.
+ *
+ * ### Three things this got wrong, all now fixed
+ *
+ * - **The dot was painted `primary` when loaded**, and `primary` in this theme is the project red. A
+ *   healthy, idle model therefore showed the colour every user reads as "stop" — while a model that
+ *   was genuinely busy showed exactly the same thing, because [ModelState] cannot tell those apart.
+ *   It takes [ModelActivity] now: green when the model is free, red while it works.
+ * - **The chips were `AssistChip`s**, which are 32dp tall touch targets with 16dp of internal padding
+ *   each, built for actions. Four of them ate a third of the bar to say "text-generation, train,
+ *   rag" — labels, not buttons, and nothing happened when you pressed one. They are flat badges now.
+ * - **The repo id was ellipsised to one line.** `mobiletransformers/functiongemma-270m-it` is the
+ *   answer to "which model am I talking to", and it was the part of the bar most likely to be cut.
+ */
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
+@Composable
+fun ModelBar(
+    state: ModelState,
+    activity: ModelActivity,
+    download: DownloadUi?,
+    onUnload: () -> Unit,
+    onGoToModels: () -> Unit,
+) {
+    var sheetOpen by remember { mutableStateOf(false) }
+
+    Column(
+        Modifier
+            .fillMaxWidth()
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .clickable { sheetOpen = true }
+            .padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalArrangement = Arrangement.spacedBy(6.dp),
+    ) {
+        Row(
+            verticalAlignment = Alignment.Top,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            StatusDot(state, activity, Modifier.padding(top = 5.dp))
+            Column(Modifier.weight(1f)) {
+                Text(
+                    text = when (state) {
+                        is ModelState.None -> "No model loaded"
+                        is ModelState.Loading -> state.repoId
+                        is ModelState.Failed -> state.repoId
+                        is ModelState.Loaded -> state.model.repoId
+                    },
+                    style = MaterialTheme.typography.labelLarge,
+                    // Wraps rather than truncates: a repo id cut at "mobiletransformers/functiong…"
+                    // does not identify a model. Two lines is enough for every id in the catalog.
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                )
+                Text(
+                    statusLine(state, activity),
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            if (state is ModelState.Loaded) {
+                Badge(state.model.capabilities.engine.name, Modifier.padding(top = 2.dp))
+            }
+        }
+
+        when (state) {
+            is ModelState.Loaded -> {
+                val c = state.model.capabilities
+                // FlowRow, so a package with five capabilities wraps instead of pushing the last one
+                // off the right edge.
+                FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    verticalArrangement = Arrangement.spacedBy(4.dp),
+                ) {
+                    // Only what this package can actually do. A chip that is present but greyed out
+                    // would say "almost" about a capability that is simply absent.
+                    c.task.taskType?.let { Badge(it.wire) }
+                    if (c.supportsToolCalling) Badge("tools")
+                    if (c.supportsTraining) Badge("train")
+                    if (c.supportsRag) Badge("rag")
+                    if (c.supportsClassification) Badge("classify")
+                    // Which fine-tuning technique this package carries. MARS is the project's own
+                    // method, and until now nothing in the app said which one you were running.
+                    c.primaryPeftMethod?.let { Badge(peftDisplayName(it)) }
+                }
+            }
+
+            is ModelState.Loading -> {
+                // The download that used to be visible only on the screen that started it.
+                if (download != null) {
+                    Text(
+                        "${downloadPhaseLabel(download.phase, download.waitingForConstraints)} · ${download.summary}",
+                        style = MaterialTheme.typography.bodySmall,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
+                val fraction = download?.fraction
+                if (fraction != null) {
+                    LinearProgressIndicator(progress = { fraction }, modifier = Modifier.fillMaxWidth())
+                } else {
+                    LinearProgressIndicator(Modifier.fillMaxWidth())
+                }
+            }
+
+            is ModelState.Failed -> Text(
+                state.reason,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.error,
+                maxLines = 3,
+                overflow = TextOverflow.Ellipsis,
+            )
+
+            is ModelState.None -> Text(
+                "Tap to see how to load one",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+    HorizontalDivider()
+
+    if (sheetOpen) {
+        ModalBottomSheet(onDismissRequest = { sheetOpen = false }) {
+            ModelDetail(
+                state = state,
+                activity = activity,
+                onUnload = { sheetOpen = false; onUnload() },
+                onGoToModels = { sheetOpen = false; onGoToModels() },
+            )
+        }
+    }
+}
+
+/**
+ * Green when the model can take work, red while it cannot.
+ *
+ * The rule the user asked for, and the only one a single dot can carry: *busy* covers loading,
+ * generating, training and merging alike, because from the outside they are the same fact — asking
+ * for something now will queue behind what is already running.
+ */
+@Composable
+internal fun statusColorFor(state: ModelState, activity: ModelActivity): Color {
+    val status = MaterialTheme.statusColors
+    return when {
+        state is ModelState.Failed -> status.failed
+        state is ModelState.None -> status.idle
+        state is ModelState.Loading -> status.busy
+        activity.isBusy -> status.busy
+        else -> status.ready
+    }
+}
+
+/** The words beside the dot, so the colour is never the only carrier of the state. */
+internal fun statusLine(state: ModelState, activity: ModelActivity): String = when (state) {
+    is ModelState.None -> "nothing loaded"
+    is ModelState.Loading -> "loading"
+    is ModelState.Failed -> "failed to load"
+    is ModelState.Loaded -> loadedStatusLine(activity)
+}
+
+/**
+ * The loaded case, split out so it is reachable from a test.
+ *
+ * A `ModelState.Loaded` carries a real `MobileTransformerModel`, which owns a native session — there
+ * is no way to construct one on the JVM, and `ModelState` is sealed to the main source set so it
+ * cannot be faked either. The branch that matters most would otherwise be the one branch with no
+ * coverage.
+ */
+internal fun loadedStatusLine(activity: ModelActivity): String =
+    if (activity.isBusy) "busy · ${activity.label}" else "ready"
+
+@Composable
+private fun StatusDot(state: ModelState, activity: ModelActivity, modifier: Modifier = Modifier) {
+    val color = statusColorFor(state, activity)
+    val description = statusLine(state, activity)
+    Box(
+        modifier
+            .size(10.dp)
+            .clip(CircleShape)
+            .background(color)
+            // Colour alone is not a status for anyone who cannot distinguish red from green.
+            .semantics { contentDescription = description },
+    )
+}
+
+/**
+ * A capability label.
+ *
+ * Not a chip: nothing happens when you press it. `AssistChip` gave each of these a 32dp height and
+ * 16dp of horizontal padding — the geometry of a button — so four labels consumed a third of the bar
+ * and invited a tap that does nothing.
+ */
+@Composable
+private fun Badge(label: String, modifier: Modifier = Modifier) {
+    Text(
+        label,
+        style = MaterialTheme.typography.labelSmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = modifier
+            .border(1.dp, MaterialTheme.colorScheme.outlineVariant, RoundedCornerShape(4.dp))
+            .padding(horizontal = 6.dp, vertical = 1.dp),
+    )
+}
+
+/** Everything the bar had to abbreviate, plus the actions that belong with it. */
+@Composable
+private fun ModelDetail(
+    state: ModelState,
+    activity: ModelActivity,
+    onUnload: () -> Unit,
+    onGoToModels: () -> Unit,
+) {
+    Column(
+        Modifier.fillMaxWidth().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        when (state) {
+            is ModelState.Loaded -> {
+                val c = state.model.capabilities
+                Text(state.model.repoId, style = MaterialTheme.typography.titleMedium)
+                DetailRow("status", statusLine(state, activity))
+                DetailRow("task", c.task.declaredTask ?: "not declared by this package")
+                DetailRow("architecture", c.task.modelType ?: "unknown")
+                DetailRow("engine", c.engine.name)
+                DetailRow("engines available here", c.availableEngines.joinToString())
+                DetailRow("features installed", c.availableFeatures.joinToString().ifEmpty { "none" })
+                DetailRow("training", if (c.supportsTraining) "yes" else "no train/ stage installed")
+                DetailRow(
+                    "fine-tuning method",
+                    c.peftMethods.joinToString { peftDisplayName(it) }
+                        .ifEmpty { "not declared by this package" },
+                )
+                DetailRow(
+                    "graph precision",
+                    // Deliberately named separately from the variant id: `cpu-int4` ships an fp32
+                    // graph, and the measured figure is the only honest one.
+                    c.graphPrecision ?: "not measured by this export",
+                )
+                DetailRow("retrieval", if (c.supportsRag) "yes" else "no embedding stage installed")
+                DetailRow(
+                    "tool calling",
+                    if (c.supportsToolCalling) {
+                        "yes — ${c.toolCalling.dialect.name.lowercase()} grammar"
+                    } else {
+                        "this model has no tool-call grammar of its own; calls are still parsed as " +
+                            "JSON, which is what fine-tuning here teaches"
+                    },
+                )
+                DetailRow(
+                    "classification",
+                    when {
+                        c.supportsClassification -> "${c.task.labelCount} labels"
+                        c.isClassifier -> "classifier, but the package names no labels"
+                        else -> "not a classification model"
+                    },
+                )
+                DetailRow("scheduled training", if (c.supportsScheduledTraining) "yes" else "no")
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    OutlinedButton(onClick = onUnload) { Text("Unload") }
+                    TextButton(onClick = onGoToModels) { Text("Manage models") }
+                }
+            }
+
+            is ModelState.Loading -> {
+                Text("Loading ${state.repoId}", style = MaterialTheme.typography.titleMedium)
+                Text(
+                    "A first pull is 1–4 GB and needs roughly its own size again free while it " +
+                        "installs. Progress resumes if it is interrupted.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                TextButton(onClick = onGoToModels) { Text("Go to Models") }
+            }
+
+            is ModelState.Failed -> {
+                Text("Could not load ${state.repoId}", style = MaterialTheme.typography.titleMedium)
+                // Verbatim: the SDK's exceptions name the missing feature or artifact.
+                Text(state.reason, style = MaterialTheme.typography.bodyMedium)
+                TextButton(onClick = onGoToModels) { Text("Go to Models") }
+            }
+
+            is ModelState.None -> {
+                Text("No model loaded", style = MaterialTheme.typography.titleMedium)
+                Text(
+                    "Nothing else in the app can do anything until a package is installed. Pick one " +
+                        "from the catalog on the Models screen, or enter any Hub repo id.",
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+                TextButton(onClick = onGoToModels) { Text("Go to Models") }
+            }
+        }
+    }
+}
+
+@Composable
+private fun DetailRow(label: String, value: String) {
+    Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        Text(
+            label,
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.weight(0.45f),
+        )
+        Text(value, style = MaterialTheme.typography.bodySmall, modifier = Modifier.weight(0.55f))
+    }
+}
+
+/** Mirrors `DownloadProgress.Phase` without importing it into the composable layer. */
+internal fun downloadPhaseLabel(phase: String, waitingForConstraints: Boolean = false): String = when {
+    // Checked FIRST: an enqueued job still reports whatever phase it last reached, so matching on
+    // the phase alone renders an indefinite wait as an active download.
+    waitingForConstraints -> "Waiting for Wi-Fi"
+    phase == "Resolving" -> "Resolving"
+    phase == "Verifying" -> "Verifying"
+    phase == "Installing" -> "Installing"
+    else -> "Downloading"
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelsScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelsScreen.kt
new file mode 100644
index 0000000..8c61575
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/ModelsScreen.kt
@@ -0,0 +1,381 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.ModelCatalog
+import com.martinkorelic.mobiletransformers.app.ModelState
+import com.martinkorelic.mobiletransformers.app.viewmodels.ModelsViewModel
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftDisplayName
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+
+/**
+ * Where a model comes from: pick one from the catalog, or name any exported package.
+ *
+ * The first destination for a reason: the previous sample app assumed an `adb push`ed package, so a
+ * real user had no way to reach any other feature.
+ *
+ * **Two tabs, not three.** "Catalog" and "Installed" are the two questions a user actually has — what
+ * can I get, and what do I have. Pulling an arbitrary repo id is a third *answer* to the first
+ * question, not a peer of it: it is what you do when the shelf does not carry what you want, which is
+ * an integrator's need rather than a first-run one. It now sits behind a disclosure at the bottom of
+ * Catalog, where it is reachable without being one of the three things the screen appears to be about.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun ModelsScreen(vm: ModelsViewModel) {
+    var tab by remember { mutableIntStateOf(0) }
+    val download by vm.download.collectAsState()
+
+    Column(Modifier.fillMaxSize()) {
+        SubTabs(listOf("Catalog", "Installed"), tab) { tab = it }
+
+        // Shown above every tab: a pull started from the Catalog tab must stay visible when the user
+        // switches to Installed to watch it appear.
+        download?.let {
+            DownloadCard(
+                it,
+                onCancel = vm::cancelDownload,
+                onUseMobileData = vm::retryWithoutWifiRequirement,
+            )
+        }
+
+        when (tab) {
+            0 -> CatalogTab(vm)
+            else -> InstalledTab(vm)
+        }
+    }
+}
+
+@Composable
+private fun DownloadCard(
+    d: com.martinkorelic.mobiletransformers.app.DownloadUi,
+    onCancel: () -> Unit,
+    onUseMobileData: () -> Unit,
+) {
+    Section(downloadPhaseLabel(d.phase, d.waitingForConstraints)) {
+        Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            if (d.waitingForConstraints) {
+                // An indefinite wait needs a way out of itself. Downloads default to Wi-Fi only, and
+                // the switch that governs that lives inside the Advanced disclosure further down —
+                // which a user who arrived by tapping Install on a catalog card has never opened. So
+                // the escape hatch is offered here, where the wait is actually visible.
+                Text(
+                    "Nothing is downloading. This pull is set to Wi-Fi only and the phone is not on " +
+                        "Wi-Fi, so it is queued rather than failed — it will start on its own once " +
+                        "Wi-Fi is back.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                ActionRow {
+                    Button(onClick = onUseMobileData) { Text("Download on mobile data") }
+                    OutlinedButton(onClick = onCancel) { Text("Cancel") }
+                }
+                return@Section
+            }
+
+            // Bytes first: with a two-file plan whose second file is 99% of the package, the file
+            // counter sits at "1 / 2" for essentially the whole download.
+            Text(d.summary, style = MaterialTheme.typography.bodyMedium)
+            Text(
+                "${d.filesDone} / ${d.filesTotal} files · ${d.path}",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            val fraction = d.fraction
+            if (fraction != null) {
+                LinearProgressIndicator(progress = { fraction }, modifier = Modifier.fillMaxWidth())
+            } else {
+                // Null until the plan is resolved — an indeterminate bar is the honest rendering of
+                // "the total is not known yet".
+                LinearProgressIndicator(Modifier.fillMaxWidth())
+            }
+            ActionRow { OutlinedButton(onClick = onCancel) { Text("Cancel") } }
+        }
+    }
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun CatalogTab(vm: ModelsViewModel) {
+    val context = LocalContext.current
+    val entries = remember { ModelCatalog.load(context) }
+    val ui by vm.ui.collectAsState()
+    val state by vm.modelState.collectAsState()
+
+    LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        item {
+            ScreenIntro(
+                "Packages exported for on-device use. A first pull is hundreds of megabytes to a few " +
+                    "gigabytes and needs roughly its own size again free while it installs — it " +
+                    "resumes if interrupted, so leaving the app mid-download is safe.",
+            )
+        }
+
+        if (entries.isEmpty()) {
+            item {
+                EmptyState(
+                    title = "The catalog is empty",
+                    detail = "assets/model_catalog.json is missing or malformed. Use 'Advanced: pull " +
+                        "any package' at the bottom of this screen to name one directly.",
+                )
+            }
+        }
+
+        items(entries) { entry ->
+            Card(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 4.dp)) {
+                Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    Text(entry.displayName, style = MaterialTheme.typography.titleSmall)
+                    Text(entry.repoId, style = MaterialTheme.typography.labelSmall)
+                    Text(entry.description, style = MaterialTheme.typography.bodySmall)
+
+                    // Four assist chips do not fit one phone-width row once `sizeLabel` is a real
+                    // figure ("3.9 GB") and `task` is "text-generation".
+                    FlowRow(
+                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        AssistChip(onClick = {}, label = { Text(entry.sizeLabel) })
+                        AssistChip(onClick = {}, label = { Text(entry.task) })
+                        if (entry.supportsTraining) AssistChip(onClick = {}, label = { Text("train") })
+                        if (entry.supportsRag) AssistChip(onClick = {}, label = { Text("rag") })
+                        if (entry.peft.isNotBlank()) {
+                            AssistChip(onClick = {}, label = { Text(peftDisplayName(entry.peft)) })
+        }
+                    }
+
+                    if (entry.recommendedFor.isNotBlank()) {
+                        Text(
+                            "Good for: ${entry.recommendedFor}",
+                            style = MaterialTheme.typography.bodySmall,
+                        )
+                    }
+
+                    // Each blocked case names its own cause. "Install failed" would collapse three
+                    // different problems — not published, no credentials, network — into one.
+                    val blocked: String? = when {
+                        !entry.published ->
+                            "Not published to the Hub yet — export it with `mobiletransformers " +
+                                "export` and push, or pick another entry."
+                        entry.requiresToken && !vm.hasHfToken ->
+                            "This is a private repo and this build carries no HF_TOKEN, so the pull " +
+                                "would fail with 401. Rebuild with HF_TOKEN=… to reach it."
+                        else -> null
+                    }
+                    blocked?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+
+                    ActionRow {
+                        Button(
+                            onClick = { vm.installFromCatalog(entry) },
+                            enabled = blocked == null && state !is ModelState.Loading,
+                        ) { Text("Install & load") }
+                    }
+                }
+            }
+        }
+
+        ui.message?.let { item { Section("Note") { Text(it) } } }
+
+        // The former third tab. Below the shelf rather than beside it: naming a repo id is what you do
+        // when the catalog does not carry what you want.
+        item { PullByIdPanel(vm) }
+    }
+}
+
+@Composable
+private fun InstalledTab(vm: ModelsViewModel) {
+    val ui by vm.ui.collectAsState()
+    val model by vm.modelState.collectAsState()
+
+    LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        item {
+            ScreenIntro(
+                "Packages already on this device. Loading one opens a native session; only one is " +
+                    "loaded at a time, so loading a second closes the first.",
+            )
+        }
+
+        if (ui.isEmpty) {
+            item {
+                EmptyState(
+                    title = "Nothing installed yet",
+                    detail = "Install one from the Catalog tab. On device the cache lives in the " +
+                        "app's files dir; a package pushed with `make device-package` also shows up " +
+                        "here.",
+                )
+            }
+        }
+
+        items(ui.installed) { row ->
+            Card(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 4.dp)) {
+                Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                    Text(row.repoId, style = MaterialTheme.typography.titleSmall)
+                    Text(row.subtitle, style = MaterialTheme.typography.bodySmall)
+                    ActionRow {
+                        OutlinedButton(
+                            onClick = {
+                                // The repo id this package was INSTALLED from, recorded at install
+                                // time. Loading by `baseModelId` — what this used to do — asks for
+                                // the upstream model instead, which sanitizes to a different and
+                                // absent cache directory, and reports the package as not installed.
+                                vm.loadSelected(row.repoId)
+                            },
+                            enabled = model !is ModelState.Loading,
+                        ) { Text("Load") }
+                    }
+                }
+            }
+        }
+
+        item {
+            // Padded: every other control on this screen sits inside a Section (16dp), so a bare
+            // ActionRow put these two buttons hard against the left edge of the display.
+            ActionRow(Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) {
+                OutlinedButton(onClick = vm::refresh) { Text("Refresh") }
+                OutlinedButton(onClick = vm::unload, enabled = model is ModelState.Loaded) {
+                    Text("Unload current")
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Pull any exported package by repo id.
+ *
+ * Was the third tab. Its four-sentence manifest/download-group paragraph is now one sentence plus a
+ * [Details] disclosure — the content is all load-bearing (each sentence exists because the behaviour
+ * it describes otherwise reads as a bug), but stacked above the controls it buried them.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun PullByIdPanel(vm: ModelsViewModel) {
+    val ui by vm.ui.collectAsState()
+    val model by vm.modelState.collectAsState()
+    var expanded by remember { mutableStateOf(false) }
+
+    Column(Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) {
+        TextButton(onClick = { expanded = !expanded }, contentPadding = PaddingValues(0.dp)) {
+            Text(
+                if (expanded) "Advanced: pull any package  ▾" else "Advanced: pull any package  ▸",
+                style = MaterialTheme.typography.labelLarge,
+            )
+        }
+        if (!expanded) return@Column
+
+        Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+            Text(
+                "Any repo holding an exported MobileTransformers package.",
+                style = MaterialTheme.typography.bodySmall,
+            )
+            Details(
+                "The repo needs a mobiletransformers_manifest.json at its root — a plain Hugging Face " +
+                    "model id fails on the first request, because the manifest is what plans the " +
+                    "download.",
+            )
+
+            TextField("Repo id", ui.repoId, vm::onRepoIdChanged)
+
+            LabeledSwitch(
+                "Also request training",
+                ui.requestTraining,
+                vm::onTrainingRequestedChanged,
+            )
+            LabeledSwitch(
+                "Also request retrieval (~91 MB encoder)",
+                ui.requestRag,
+                vm::onRagRequestedChanged,
+            )
+            LabeledSwitch("Download over Wi-Fi only", ui.wifiOnly, vm::onWifiOnlyChanged)
+
+            Details {
+                Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                    Text(
+                        "Requesting training fails closed when the package has no train/ stage. That " +
+                            "is deliberate, not a bug — a silent downgrade to inference-only would be " +
+                            "discovered much later, on the Train screen.",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                    Text(
+                        "Retrieval is a separate download group. Without it no embedding encoder is " +
+                            "fetched, and Chat's grounding cannot work — so it is asked here, where " +
+                            "the cost is visible, rather than discovered later.",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                    Text(
+                        "Pulls run in the background and survive leaving the app. With Wi-Fi only on, " +
+                            "one started on mobile data waits rather than failing.",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                }
+            }
+
+            Text("Engine", style = MaterialTheme.typography.titleSmall)
+            FlowRow(
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                InferenceEngine.entries.forEach { e ->
+                    FilterChip(
+                        selected = ui.engine == e,
+                        onClick = { vm.onEngineChanged(e) },
+                        label = { Text(e.name) },
+                    )
+                }
+            }
+            Details(
+                "Fixed at load, so switching means reloading. Most packages are Native-only: GenAI " +
+                    "additionally needs the variant's manifest to declare it, and Gemma-3 packages " +
+                    "(FunctionGemma included) are exported through optimum rather than the GenAI " +
+                    "builder, so they declare native alone. Choosing GenAI for one of those fails " +
+                    "closed at load, naming the declaration, rather than quietly handing back Native.",
+            )
+
+            Text(
+                if (vm.hasHfToken) {
+                    "HF_TOKEN present — private and gated repos are reachable."
+                } else {
+                    "No HF_TOKEN in this build. Public repos work as-is; a private one fails with 401."
+                },
+                style = MaterialTheme.typography.bodySmall,
+            )
+
+            ActionRow {
+                Button(
+                    onClick = { vm.loadSelected() },
+                    enabled = model !is ModelState.Loading,
+                ) { Text("Pull & load") }
+                OutlinedButton(onClick = vm::unload, enabled = model is ModelState.Loaded) {
+                    Text("Unload")
+                }
+            }
+
+            ui.message?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/RetrievalScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/RetrievalScreen.kt
new file mode 100644
index 0000000..fe55b90
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/RetrievalScreen.kt
@@ -0,0 +1,202 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.app.viewmodels.RetrievalViewModel
+import com.martinkorelic.mobiletransformers.runtime.RetrievalMatch
+
+/**
+ * Retrieval with nothing generated on top of it: a query, and the passages closest to it.
+ *
+ * Every result carries its similarity score, because the score is what makes the screen falsifiable.
+ * "The top result looks relevant" is an impression; a top result at 0.71 against a second at 0.38 is
+ * a ranking you can argue with — and a set of four results all within 0.02 of each other says the
+ * store has nothing useful in it, which is a different problem from a wrong answer.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun RetrievalScreen(vm: RetrievalViewModel) {
+    val ui by vm.ui.collectAsState()
+    val state by vm.modelState.collectAsState()
+
+    val pickDocument = rememberLauncherForActivityResult(
+        ActivityResultContracts.OpenDocument(),
+    ) { uri -> uri?.let(vm::ingest) }
+
+    Column(Modifier.fillMaxWidth().verticalScroll(rememberScrollState())) {
+        ScreenIntro(
+            "Search the documents you have ingested. This is retrieval on its own — nothing is " +
+                "generated, so what you see is exactly what a grounded answer would be built from.",
+        )
+
+        ModelGate(state, needs = "Retrieval needs a package with an embedding stage.") { model ->
+            if (!model.capabilities.supportsRag) {
+                EmptyState(
+                    title = "This package has no embedding stage",
+                    detail = "Retrieval needs one, and it is a separate download group. Re-pull this " +
+                        "model from the Models screen with RAG requested.",
+                )
+                return@ModelGate
+            }
+
+            Section("Documents") {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    Text(
+                        if (ui.ingestedDocuments.isEmpty()) {
+                            "The store starts empty, so a search now returns nothing. Add the sample " +
+                                "set — four short documents on separate subjects, so the ranking has " +
+                                "something to tell apart."
+                        } else {
+                            "In the store: ${ui.ingestedDocuments.joinToString(", ")}"
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                    ActionRow {
+                        Button(onClick = vm::ingestSamples, enabled = !ui.ingesting) {
+                            Text(if (ui.ingesting) "Ingesting…" else "Add sample documents")
+                        }
+                        OutlinedButton(
+                            onClick = {
+                                pickDocument.launch(
+                                    arrayOf("text/*", "text/markdown", "application/json"),
+                                )
+                            },
+                            enabled = !ui.ingesting,
+                        ) { Text("Pick a file…") }
+                    }
+                    if (ui.ingesting) LinearProgressIndicator(Modifier.fillMaxWidth())
+                    ui.note?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+                }
+            }
+
+            Section("Query") {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    TextField("Search for", ui.query, vm::onQueryChanged)
+                    ActionRow {
+                        Button(
+                            onClick = vm::search,
+                            enabled = !ui.searching && ui.query.isNotBlank(),
+                        ) { Text(if (ui.searching) "Searching…" else "Search") }
+                        OutlinedButton(
+                            onClick = vm::clear,
+                            enabled = ui.matches.isNotEmpty(),
+                        ) { Text("Clear") }
+                    }
+                    // Each of these has its best match in a different bundled document, so tapping
+                    // through them shows the ranking discriminating rather than always winning.
+                    Text("Try:", style = MaterialTheme.typography.labelSmall)
+                    FlowRow(
+                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        vm.exampleQueries.forEach { example ->
+                            AssistChip(
+                                onClick = { vm.useExample(example) },
+                                label = { Text(example, style = MaterialTheme.typography.labelSmall) },
+                            )
+                        }
+                    }
+                }
+            }
+
+            if (ui.searching) LinearProgressIndicator(Modifier.fillMaxWidth().padding(16.dp))
+
+            if (ui.matches.isNotEmpty()) {
+                Section("${ui.matches.size} closest passages · ${ui.queryTimeMs} ms") {
+                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        Text(
+                            "for \"${ui.searchedQuery}\"",
+                            style = MaterialTheme.typography.labelSmall,
+                        )
+                        val best = ui.matches.first().score
+                        ui.matches.forEachIndexed { index, match ->
+                            MatchCard(index + 1, match, best)
+                        }
+                    }
+                }
+            }
+
+            if (ui.foundNothing) {
+                EmptyState(
+                    title = "Nothing matched",
+                    // These two look identical in an empty result list and need opposite fixes.
+                    detail = if (ui.searchedWithEmptyStore) {
+                        "The store was empty when this ran — retrieval searches only what you have " +
+                            "ingested. Add the sample documents above and search again."
+                    } else {
+                        "There are documents in the store, but nothing in them was close enough to " +
+                            "the query. Try one of the suggested searches to see the ranking work."
+                    },
+                )
+            }
+
+            ui.error?.let { Section("Error") { Text(it) } }
+        }
+    }
+}
+
+/**
+ * One result: its rank, its score, and a bar showing the score **relative to the best match**.
+ *
+ * Relative rather than absolute because cosine similarities over a small store cluster in a narrow
+ * band — a set of raw 0.3–0.4 bars all look equally short and equally uninformative. Scaling against
+ * the top hit makes the gap between first and second visible, which is the thing worth seeing.
+ */
+@Composable
+private fun MatchCard(rank: Int, match: RetrievalMatch, bestScore: Double) {
+    Card(
+        Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant,
+            contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
+        ),
+    ) {
+        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Row(
+                Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                // The source file, not only the rank: "which of my documents did this come from" is
+                // the first question asked of any hit, and the store has carried the answer since
+                // ingestion. Blank for a hit from a store that predates the provenance fields.
+                Text(
+                    if (match.title.isBlank()) "#$rank" else "#$rank · ${match.title}",
+                    style = MaterialTheme.typography.labelSmall,
+                )
+                Text("score %.3f".format(match.score), style = MaterialTheme.typography.labelSmall)
+            }
+            val fraction = if (bestScore > 0.0) (match.score / bestScore).coerceIn(0.0, 1.0) else 0.0
+            LinearProgressIndicator(
+                progress = { fraction.toFloat() },
+                modifier = Modifier.fillMaxWidth().height(4.dp),
+            )
+            Text(match.text, style = MaterialTheme.typography.bodySmall)
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/TrainScreen.kt b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/TrainScreen.kt
new file mode 100644
index 0000000..09e64fc
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/java/com/martinkorelic/mobiletransformers/app/views/TrainScreen.kt
@@ -0,0 +1,281 @@
+package com.martinkorelic.mobiletransformers.app.views
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.app.viewmodels.StartDelay
+import com.martinkorelic.mobiletransformers.app.viewmodels.TrainViewModel
+
+/** The training lifecycle: status, charts, events, cancel, resume, merge, scheduling. */
+@Composable
+fun TrainScreen(vm: TrainViewModel) {
+    val state by vm.modelState.collectAsState()
+    var tab by remember { mutableIntStateOf(0) }
+
+    ModelGate(state, needs = "Training needs a package exported with TRAIN=1.") { model ->
+        Column(Modifier.fillMaxSize()) {
+            SubTabs(listOf("Run", "Progress", "Schedule"), tab) { tab = it }
+            when (tab) {
+                0 -> RunTab(vm, model)
+                1 -> ProgressTab(vm)
+                else -> ScheduleTab(vm, model)
+            }
+        }
+    }
+}
+
+@Composable
+private fun RunTab(vm: TrainViewModel, model: MobileTransformerModel) {
+    val ui by vm.ui.collectAsState()
+
+    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {
+        ScreenIntro(
+            "Fine-tune on this device. Order: install the sample dataset, Start, then Merge. Only the " +
+                "LoRA adapter trains, so this is minutes rather than hours — but it is still minutes. " +
+                "Watch the loss curve on the Progress tab.",
+        )
+
+        if (!model.capabilities.supportsTraining) {
+            EmptyState(
+                title = "This package cannot train",
+                detail = "No train/ stage is installed. Pull or export one with TRAIN=1 — the buttons " +
+                    "below would fail closed.",
+            )
+        }
+
+        Section("Data") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(
+                    "Model packages ship no training data — the task belongs with the data, and the " +
+                        "data is yours. This installs a small tool-call set generated from the same " +
+                        "allowlist the Tool calls screen declares, so what the model learns is " +
+                        "exactly what the validator there accepts.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                ActionRow {
+                    Button(
+                        onClick = vm::installSampleDataset,
+                        enabled = !ui.running && model.capabilities.supportsTraining,
+                    ) { Text("Install sample dataset") }
+                }
+                ui.datasetNote?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+            }
+        }
+
+        Section("Run") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(ui.status, style = MaterialTheme.typography.titleSmall)
+                if (ui.canResume) {
+                    Text(
+                        "A checkpoint exists — starting again resumes from it while resumeFromState " +
+                            "is on (Configuration → Training).",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                }
+                ActionRow {
+                    Button(
+                        onClick = vm::start,
+                        enabled = !ui.running && model.capabilities.supportsTraining,
+                    ) { Text(if (ui.running) "Training…" else "Start") }
+                    OutlinedButton(onClick = vm::cancel, enabled = ui.running) { Text("Cancel") }
+                    OutlinedButton(onClick = vm::merge, enabled = !ui.running) { Text("Merge") }
+                }
+                Text(
+                    "Cancel is cooperative: the native loop breaks at the next step boundary and a " +
+                        "checkpoint is written, so cancelling is resumable rather than lossy. Merge " +
+                        "writes the learned adapter into the inference graph — until then, Chat is " +
+                        "still generating from the base weights.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+            }
+        }
+
+        ui.error?.let { Section("Error") { Text(it) } }
+    }
+}
+
+/**
+ * The curve and the log, in that order.
+ *
+ * The log is the chart's table view: every value the curve draws is also readable as a number, which
+ * is what keeps the chart an enhancement rather than the only way to read the run.
+ */
+@Composable
+private fun ProgressTab(vm: TrainViewModel) {
+    val ui by vm.ui.collectAsState()
+
+    Column(Modifier.fillMaxSize()) {
+        RunStatusCard(ui)
+
+        TrainingCharts(ui.points, Modifier.padding(top = 12.dp))
+
+        Text(
+            "Events",
+            style = MaterialTheme.typography.titleSmall,
+            modifier = Modifier.padding(start = 16.dp, top = 16.dp, bottom = 4.dp),
+        )
+        if (ui.events.isEmpty()) {
+            Text(
+                "Nothing yet. Start a run on the Run tab.",
+                style = MaterialTheme.typography.bodySmall,
+                modifier = Modifier.padding(horizontal = 16.dp),
+            )
+        }
+        LazyColumn(Modifier.weight(1f).fillMaxWidth()) {
+            items(ui.events) { e ->
+                Text(
+                    e,
+                    style = MaterialTheme.typography.bodySmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 2.dp),
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Where the run is, at the top of the tab that exists to answer that.
+ *
+ * The Progress tab opened straight onto a loss chart, and the status line — the one that says
+ * "preparing", "step 42 of 108", "failed: …" — was a single `bodyMedium` on the *Run* tab, which is
+ * the tab you leave to come here. So the screen dedicated to watching a run was the one place that
+ * did not say what the run was doing, and an empty chart meant both "not started" and "starting".
+ */
+@Composable
+private fun RunStatusCard(ui: com.martinkorelic.mobiletransformers.app.viewmodels.TrainUiState) {
+    val last = ui.points.lastOrNull()
+    Card(
+        Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = if (ui.error != null) {
+                MaterialTheme.colorScheme.errorContainer
+            } else {
+                MaterialTheme.colorScheme.surfaceVariant
+            },
+        ),
+    ) {
+        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Text(
+                ui.error ?: ui.status,
+                style = MaterialTheme.typography.titleMedium,
+            )
+            if (ui.running) {
+                LinearProgressIndicator(Modifier.fillMaxWidth())
+            }
+            Row(horizontalArrangement = Arrangement.spacedBy(20.dp)) {
+                Stat("step", last?.step?.toString() ?: "—")
+                Stat("loss", last?.let { "%.4f".format(it.loss) } ?: "—")
+                Stat("lr", last?.let { "%.2e".format(it.learningRate) } ?: "—")
+                Stat("ms/step", last?.stepDurationMs?.toString() ?: "—")
+            }
+        }
+    }
+}
+
+@Composable
+private fun Stat(label: String, value: String) {
+    Column {
+        Text(
+            label,
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Text(value, style = MaterialTheme.typography.bodyMedium)
+    }
+}
+
+@Composable
+private fun ScheduleTab(vm: TrainViewModel, model: MobileTransformerModel) {
+    val ui by vm.ui.collectAsState()
+    val scheduled by vm.scheduledRuns.collectAsState()
+
+    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {
+        ScreenIntro(
+            "Hand the run to the system instead of running it now. Chunks execute only while the " +
+                "device is charging and idle, and each chunk re-checks that before starting — so " +
+                "unplugging pauses the run rather than failing it.",
+        )
+
+        Section("Schedule a run") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(
+                    "Each chunk re-enters the queue when it finishes, restoring globalStep, epoch and " +
+                        "the LR schedule from training_state.json — the same mechanism that survives " +
+                        "the app's process being killed.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                ChipPicker(
+                    label = "Start",
+                    options = StartDelay.entries,
+                    selected = ui.startDelay,
+                    optionLabel = { it.label },
+                    onSelect = vm::onStartDelayChanged,
+                )
+                Text(
+                    "A delay is a floor, not an appointment: Android batches deferrable work and Doze " +
+                        "can hold it longer. Charging is still the real gate — the delay only moves " +
+                        "the earliest moment it is checked.",
+                    style = MaterialTheme.typography.bodySmall,
+                )
+                ActionRow {
+                    Button(
+                        onClick = vm::schedule,
+                        enabled = model.capabilities.supportsScheduledTraining,
+                    ) { Text("Schedule") }
+                    OutlinedButton(
+                        onClick = vm::cancelSchedule,
+                        enabled = scheduled.isNotEmpty(),
+                    ) { Text("Cancel scheduled") }
+                }
+                ui.scheduled?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+            }
+        }
+
+        Section("Queue") {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                if (scheduled.isEmpty()) {
+                    Text(
+                        "Nothing queued. A scheduled run appears here with its state, so " +
+                            "\"waiting for the charger\" is distinguishable from \"not scheduled\".",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                } else {
+                    scheduled.forEach { run ->
+                        Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+                            Text(run.stateLabel, style = MaterialTheme.typography.bodyMedium)
+                            Text(run.detail, style = MaterialTheme.typography.bodySmall)
+                        }
+                    }
+                }
+            }
+        }
+
+        ui.error?.let { Section("Error") { Text(it) } }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-hdpi/ic_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-hdpi/ic_logo.png
new file mode 100644
index 0000000..59d0591
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-hdpi/ic_logo.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-mdpi/ic_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-mdpi/ic_logo.png
new file mode 100644
index 0000000..12e7073
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-mdpi/ic_logo.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xhdpi/ic_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xhdpi/ic_logo.png
new file mode 100644
index 0000000..2c109b7
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xhdpi/ic_logo.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxhdpi/ic_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxhdpi/ic_logo.png
new file mode 100644
index 0000000..c0a9a1f
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxhdpi/ic_logo.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxxhdpi/ic_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxxhdpi/ic_logo.png
new file mode 100644
index 0000000..e5aa60f
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable-xxxhdpi/ic_logo.png differ
diff --git a/android/ORTransformer/app/src/main/res/drawable/better_logo.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable/better_logo.xml
similarity index 100%
rename from android/ORTransformer/app/src/main/res/drawable/better_logo.xml
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/drawable/better_logo.xml
diff --git a/android/ORTransformer/app/src/main/res/drawable/fri_logo.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/drawable/fri_logo.png
similarity index 100%
rename from android/ORTransformer/app/src/main/res/drawable/fri_logo.png
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/drawable/fri_logo.png
diff --git a/android/ORTransformer/app/src/main/res/layout/activity_main.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/layout/activity_main.xml
similarity index 100%
rename from android/ORTransformer/app/src/main/res/layout/activity_main.xml
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/layout/activity_main.xml
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..3702909
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Cut from docs/assets/mobiletransformers_logo.png — see docs/assets/README.md before replacing it.
+
+  `foreground` is scaled into the 66dp safe zone: the launcher masks this 108dp canvas to a
+  circle/squircle/rounded square and only that centre is guaranteed to survive, so art that fills the
+  canvas loses its edges on most phones.
+
+  `monochrome` is the logo's dark line art alone, not a filled silhouette — a filled silhouette of a
+  sticker is a featureless blob, whereas the outlines, eyes, smile and phone frame stay recognisable
+  at icon size.
+-->
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background" />
+    <foreground android:drawable="@mipmap/ic_launcher_foreground" />
+    <monochrome android:drawable="@mipmap/ic_launcher_monochrome" />
+</adaptive-icon>
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
new file mode 100644
index 0000000..3702909
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Cut from docs/assets/mobiletransformers_logo.png — see docs/assets/README.md before replacing it.
+
+  `foreground` is scaled into the 66dp safe zone: the launcher masks this 108dp canvas to a
+  circle/squircle/rounded square and only that centre is guaranteed to survive, so art that fills the
+  canvas loses its edges on most phones.
+
+  `monochrome` is the logo's dark line art alone, not a filled silhouette — a filled silhouette of a
+  sticker is a featureless blob, whereas the outlines, eyes, smile and phone frame stay recognisable
+  at icon size.
+-->
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background" />
+    <foreground android:drawable="@mipmap/ic_launcher_foreground" />
+    <monochrome android:drawable="@mipmap/ic_launcher_monochrome" />
+</adaptive-icon>
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher.webp
new file mode 100644
index 0000000..4fa1cde
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_foreground.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..7604532
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_foreground.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_monochrome.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_monochrome.png
new file mode 100644
index 0000000..e17536d
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_monochrome.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_round.webp
new file mode 100644
index 0000000..45b2296
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher.webp
new file mode 100644
index 0000000..a92eb8a
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_foreground.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..58ed5b8
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_foreground.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_monochrome.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_monochrome.png
new file mode 100644
index 0000000..04d5730
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_monochrome.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_round.webp
new file mode 100644
index 0000000..43c8c80
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher.webp
new file mode 100644
index 0000000..b341343
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..a646a87
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_monochrome.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_monochrome.png
new file mode 100644
index 0000000..3cafcd1
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_monochrome.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
new file mode 100644
index 0000000..d4e71b4
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher.webp
new file mode 100644
index 0000000..0ec776b
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..b01db88
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_monochrome.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_monochrome.png
new file mode 100644
index 0000000..e0b5502
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_monochrome.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
new file mode 100644
index 0000000..696a6c3
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
new file mode 100644
index 0000000..3bfc612
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..f7b8108
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_monochrome.png b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_monochrome.png
new file mode 100644
index 0000000..8007f9d
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_monochrome.png differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
new file mode 100644
index 0000000..3971f95
Binary files /dev/null and b/android/MobileTransformers/MobileTransformersApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/values-night/themes.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/values-night/themes.xml
new file mode 100644
index 0000000..ab7fb59
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/values-night/themes.xml
@@ -0,0 +1,17 @@
+<resources xmlns:tools="http://schemas.android.com/tools">
+    <!-- The dark counterpart. See values/themes.xml for why this layer exists at all. -->
+    <style name="Theme.MobileTransformersApp" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
+        <item name="colorPrimary">@color/brand_primary_dark</item>
+        <item name="colorPrimaryVariant">@color/brand_primary_dark</item>
+        <item name="colorOnPrimary">@color/black</item>
+        <item name="colorSecondary">@color/brand_primary_dark</item>
+        <item name="colorSecondaryVariant">@color/brand_primary_dark</item>
+        <item name="colorOnSecondary">@color/black</item>
+
+        <item name="android:statusBarColor">@color/brand_surface_container_dark</item>
+        <item name="android:navigationBarColor">@color/brand_surface_container_dark</item>
+        <item name="android:windowLightStatusBar" tools:targetApi="m">false</item>
+        <item name="android:windowLightNavigationBar" tools:targetApi="o_mr1">false</item>
+        <item name="android:windowBackground">@color/brand_surface_dark</item>
+    </style>
+</resources>
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/values/colors.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/colors.xml
new file mode 100644
index 0000000..19f9c9a
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/colors.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Colours for the XML/View layer only. The app's real palette lives in Compose
+  (`ui/theme/Theme.kt`), which owns four schemes — FRI and Better, each light and dark.
+
+  These exist because the window is painted before Compose composes: on a cold start the system draws
+  `Theme.MobileTransformersApp` for a beat, and if that disagrees with the Compose theme the launch
+  flashes the wrong colour. They are keyed to the FRI scheme, which is what `MainActivity` selects.
+
+  The Android Studio template's `purple_200/500/700` and `teal_200/700` were removed on 2026-08-17:
+  nothing but themes.xml referenced them, and `colorPrimaryVariant` -> `purple_700` was what painted a
+  strip of #3700B3 above the app bar in both day and night.
+-->
+<resources>
+    <!-- FRI light scheme: `primary` and `surfaceContainer` from Theme.kt. -->
+    <color name="brand_primary">#FFE03229</color>
+    <color name="brand_surface">#FFFDFBFB</color>
+    <color name="brand_surface_container">#FFF5F0EF</color>
+
+    <!-- FRI dark scheme, same two roles. -->
+    <color name="brand_primary_dark">#FFFFB4AA</color>
+    <color name="brand_surface_dark">#FF141313</color>
+    <color name="brand_surface_container_dark">#FF201F1F</color>
+
+    <color name="black">#FF000000</color>
+    <color name="white">#FFFFFFFF</color>
+</resources>
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/values/ic_launcher_background.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/ic_launcher_background.xml
new file mode 100644
index 0000000..caeda95
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/ic_launcher_background.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  The adaptive launcher icon's background layer.
+
+  Taken from the logo's own outline colour (#171E22). It is dark deliberately: the mark carries a
+  white sticker outline, which vanishes completely on a light background — on white the icon reads as
+  a yellow blob with no silhouette. Generated resources reference this, so changing it here changes
+  the icon everywhere.
+-->
+<resources>
+    <color name="ic_launcher_background">#171E22</color>
+</resources>
diff --git a/android/ORTransformer/app/src/main/res/values/strings.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/strings.xml
similarity index 75%
rename from android/ORTransformer/app/src/main/res/values/strings.xml
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/values/strings.xml
index e3be857..aca2673 100644
--- a/android/ORTransformer/app/src/main/res/values/strings.xml
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/strings.xml
@@ -1,5 +1,5 @@
 <resources>
-    <string name="app_name">ORTTransformer</string>
+    <string name="app_name">MobileTransformers</string>
     <string name="title_activity_inference_screen">InferenceScreen</string>
     <string name="title_activity_training_screen">TrainingScreen</string>
 </resources>
\ No newline at end of file
diff --git a/android/MobileTransformers/MobileTransformersApp/src/main/res/values/themes.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/themes.xml
new file mode 100644
index 0000000..20a87a4
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/main/res/values/themes.xml
@@ -0,0 +1,27 @@
+<resources xmlns:tools="http://schemas.android.com/tools">
+    <!--
+      The window theme, which only governs what is drawn BEFORE and AROUND Compose: the cold-start
+      window and the system bars. Everything inside the app is themed by `ui/theme/Theme.kt`.
+
+      The status bar colour is also set at runtime from the live Compose scheme, because there are
+      four schemes and one XML value cannot be right for all of them. This is the pre-composition
+      value, keyed to FRI light so the launch does not flash a different colour.
+    -->
+    <style name="Theme.MobileTransformersApp" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
+        <item name="colorPrimary">@color/brand_primary</item>
+        <item name="colorPrimaryVariant">@color/brand_primary</item>
+        <item name="colorOnPrimary">@color/white</item>
+        <item name="colorSecondary">@color/brand_primary</item>
+        <item name="colorSecondaryVariant">@color/brand_primary</item>
+        <item name="colorOnSecondary">@color/white</item>
+
+        <!-- Matches `TopAppBar`, which paints itself from `surfaceContainer`, so the status bar and
+             the app bar read as one surface rather than as a seam. -->
+        <item name="android:statusBarColor">@color/brand_surface_container</item>
+        <item name="android:navigationBarColor">@color/brand_surface_container</item>
+        <!-- A light bar needs dark icons, or the clock and battery vanish into it. -->
+        <item name="android:windowLightStatusBar" tools:targetApi="m">true</item>
+        <item name="android:windowLightNavigationBar" tools:targetApi="o_mr1">true</item>
+        <item name="android:windowBackground">@color/brand_surface</item>
+    </style>
+</resources>
diff --git a/android/ORTransformer/app/src/main/res/xml/backup_rules.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/xml/backup_rules.xml
similarity index 100%
rename from android/ORTransformer/app/src/main/res/xml/backup_rules.xml
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/xml/backup_rules.xml
diff --git a/android/ORTransformer/app/src/main/res/xml/data_extraction_rules.xml b/android/MobileTransformers/MobileTransformersApp/src/main/res/xml/data_extraction_rules.xml
similarity index 100%
rename from android/ORTransformer/app/src/main/res/xml/data_extraction_rules.xml
rename to android/MobileTransformers/MobileTransformersApp/src/main/res/xml/data_extraction_rules.xml
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/DownloadPhaseLabelTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/DownloadPhaseLabelTest.kt
new file mode 100644
index 0000000..819930b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/DownloadPhaseLabelTest.kt
@@ -0,0 +1,64 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.views.downloadPhaseLabel
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * What the download card and the model bar say a pull is doing.
+ *
+ * ### The defect
+ *
+ * Downloads default to Wi-Fi only. With no Wi-Fi, WorkManager parks the worker in `ENQUEUED` and it
+ * waits — correct, deliberate behaviour, and the reason `ModelHolder` went to the trouble of mapping
+ * that state to the sentence `"waiting for Wi-Fi"`.
+ *
+ * [downloadPhaseLabel] then threw it away. It matched `Resolving`/`Verifying`/`Installing` and sent
+ * **everything else** to `"Downloading"` — so the app displayed an active download, with a progress
+ * bar, that never advanced. The one state the sentence existed to distinguish from a stall was
+ * rendered as a stall.
+ *
+ * Both halves were individually right; nothing tested the seam. Reported from a real phone on
+ * 2026-08-17, not by any suite.
+ *
+ * ### Why the flag, and why it is checked first
+ *
+ * An enqueued job still reports whatever phase it last reached, so a waiting pull can legitimately
+ * carry `phase == "Downloading"`. Matching on the phase string alone cannot distinguish the two —
+ * which is why [DownloadUi.waitingForConstraints] is a boolean and why it takes precedence.
+ */
+class DownloadPhaseLabelTest {
+
+    @Test
+    fun `a job waiting on its network constraint says so, whatever phase it last reached`() {
+        // The exact shape that broke: the worker is parked, but the last phase it reported was a
+        // download in progress. Matching the phase alone renders this as "Downloading".
+        assertEquals(
+            "Waiting for Wi-Fi",
+            downloadPhaseLabel("Downloading", waitingForConstraints = true),
+        )
+        assertEquals(
+            "Waiting for Wi-Fi",
+            downloadPhaseLabel("Resolving", waitingForConstraints = true),
+        )
+    }
+
+    @Test
+    fun `a running job reports its real phase`() {
+        assertEquals("Resolving", downloadPhaseLabel("Resolving", waitingForConstraints = false))
+        assertEquals("Verifying", downloadPhaseLabel("Verifying", waitingForConstraints = false))
+        assertEquals("Installing", downloadPhaseLabel("Installing", waitingForConstraints = false))
+    }
+
+    @Test
+    fun `an unrecognized phase still reads as downloading rather than as a raw enum name`() {
+        // The `else` branch is deliberate: the SDK's phase vocabulary can grow, and a user should see
+        // "Downloading" rather than `RUNNING` or `ENQUEUED`.
+        assertEquals("Downloading", downloadPhaseLabel("SomeFuturePhase", waitingForConstraints = false))
+    }
+
+    @Test
+    fun `the default keeps existing callers on the running path`() {
+        assertEquals("Downloading", downloadPhaseLabel("Downloading"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ModelStatusTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ModelStatusTest.kt
new file mode 100644
index 0000000..ff3879e
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ModelStatusTest.kt
@@ -0,0 +1,66 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.views.loadedStatusLine
+import com.martinkorelic.mobiletransformers.app.views.statusLine
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * What the model bar's indicator says.
+ *
+ * ### The defect
+ *
+ * The dot was painted from [ModelState] alone: `Loaded -> colorScheme.primary`. In this theme
+ * `primary` is the project red, so a healthy idle model showed the colour every user reads as
+ * "stop" — and a model that was genuinely mid-generation showed exactly the same thing, because
+ * `ModelState` cannot distinguish the two. The one question a status light exists to answer, "can I
+ * ask it something right now", had no representation anywhere in the app.
+ *
+ * The colour itself needs a composition to resolve, so what is pinned here is the state machine
+ * behind it — [ModelActivity.isBusy] and the words that must accompany the colour, since a red/green
+ * dot is not a status for anyone who cannot tell red from green.
+ */
+class ModelStatusTest {
+
+    @Test
+    fun idleIsTheOnlyNonBusyActivity() {
+        assertFalse(ModelActivity.Idle.isBusy)
+        for (activity in ModelActivity.entries - ModelActivity.Idle) {
+            assertTrue("$activity must count as busy", activity.isBusy)
+        }
+    }
+
+    @Test
+    fun everyKindOfWorkIsRepresented() {
+        // Generating, training and merging all occupy the same native session, and all three used to
+        // be invisible. If a fourth kind of work is added it belongs here, not in a new flag.
+        val names = ModelActivity.entries.map { it.name }.toSet()
+        assertTrue(names.containsAll(setOf("Loading", "Generating", "Training", "Merging", "Ingesting")))
+    }
+
+    @Test
+    fun theWordsMatchTheState() {
+        assertEquals("nothing loaded", statusLine(ModelState.None, ModelActivity.Idle))
+        assertEquals("loading", statusLine(ModelState.Loading("org/model"), ModelActivity.Loading))
+        assertEquals("failed to load", statusLine(ModelState.Failed("org/model", "no such file"), ModelActivity.Idle))
+    }
+
+    @Test
+    fun aLoadedIdleModelReportsReady() {
+        // The case the old dot got wrong: free, and painted with the theme's red.
+        assertEquals("ready", loadedStatusLine(ModelActivity.Idle))
+    }
+
+    @Test
+    fun aBusyLoadedModelNamesWhatItIsDoing() {
+        // "busy" alone would be a smaller lie than the old dot but still a lie: the user's next
+        // question is always "busy with what", and training and generating have very different waits.
+        for (activity in ModelActivity.entries - ModelActivity.Idle) {
+            val line = loadedStatusLine(activity)
+            assertTrue("'$line' should start with busy", line.startsWith("busy · "))
+            assertTrue("'$line' should name the activity", line.endsWith(activity.label))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/NavigationStateTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/NavigationStateTest.kt
new file mode 100644
index 0000000..e503fd1
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/NavigationStateTest.kt
@@ -0,0 +1,188 @@
+package com.martinkorelic.mobiletransformers.app
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * What the drawer offers, and what it says about what it will not do yet.
+ *
+ * The states that matter here are the ones hardest to reach by hand on a device — no package
+ * installed, a package with no train stage, a failed load — and therefore the ones most likely to rot
+ * unnoticed. They are also the first thing a new user meets, so an unhelpful answer here is the whole
+ * first impression.
+ */
+class NavigationStateTest {
+
+    @Test
+    fun withNoModelOnlyTheEntryPointsAreEnabled() {
+        val state = ModelState.None
+
+        // Models is where a model comes from and About explains the app; both have to work before
+        // anything is loaded, or a fresh install is a dead end.
+        assertEquals(Availability.Enabled, Destination.Models.availability(state))
+        assertEquals(Availability.Enabled, Destination.About.availability(state))
+
+        for (d in listOf(Destination.Chat, Destination.Retrieval, Destination.Train, Destination.Federated)) {
+            val availability = d.availability(state)
+            assertTrue("$d should be blocked with no model", availability is Availability.Blocked)
+            // The reason is the instruction — it has to say what to do, not merely that something is wrong.
+            assertTrue(
+                "$d's reason does not say where to go",
+                (availability as Availability.Blocked).reason.contains("Models"),
+            )
+        }
+    }
+
+    @Test
+    fun aFailedLoadNamesTheModelThatFailed() {
+        val availability = Destination.Chat.availability(ModelState.Failed("org/pkg", "no inference stage"))
+        assertTrue(availability is Availability.Blocked)
+        assertTrue((availability as Availability.Blocked).reason.contains("org/pkg"))
+    }
+
+    @Test
+    fun loadingSaysSoRatherThanLookingBroken() {
+        val availability = Destination.Chat.availability(ModelState.Loading("org/pkg"))
+        assertTrue(availability is Availability.Blocked)
+        assertTrue((availability as Availability.Blocked).reason.contains("loading"))
+    }
+
+    /**
+     * Nothing is hidden while no model is loaded.
+     *
+     * Hiding is reserved for "this package cannot do that" — an empty drawer on first launch would
+     * remove the only thing the app can tell a new user, which is what the app is for.
+     */
+    @Test
+    fun theDrawerIsCompleteBeforeAnythingIsLoaded() {
+        assertEquals(Destination.entries.toList(), visibleDestinations(ModelState.None))
+    }
+
+    @Test
+    fun aDestinationThatIsStillVisibleIsNotRedirectedAwayFrom() {
+        assertEquals(Destination.Chat, redirectFor(Destination.Chat, ModelState.None))
+        assertEquals(Destination.Train, redirectFor(Destination.Train, ModelState.Loading("x")))
+    }
+
+    // ------------------------------------------------------------------ per-package capabilities
+
+    /**
+ * Classify exists only for a package that classifies **and** names its labels.
+ *
+ * The second half is the part worth pinning. A classification graph with no `id2label` runs fine
+ * and answers `LABEL_3`, so keying the destination on `isClassifier` alone would offer a screen of
+ * probability bars against labels that mean nothing — see `RuntimeCapabilities.supportsClassification`.
+ */
+    @Test
+    fun classifyAppearsOnlyForAClassifierThatNamesItsLabels() {
+        assertEquals(Availability.Enabled, Destination.Classify.availabilityFor(classifier()))
+        assertEquals(Availability.Hidden, Destination.Classify.availabilityFor(classifierWithoutLabels()))
+        assertEquals(Availability.Hidden, Destination.Classify.availabilityFor(decoder()))
+}
+
+    /** The inverse: an encoder has no generative head, so the generative screens go away. */
+    @Test
+    fun theGenerativeScreensAreHiddenOnAClassifier() {
+        assertEquals("Chat must hide on a classifier", Availability.Hidden, Destination.Chat.availabilityFor(classifier()))
+        assertEquals("Chat must show on a decoder", Availability.Enabled, Destination.Chat.availabilityFor(decoder()))
+        }
+
+    /**
+ * A plain embedding model is not a classifier and cannot generate either.
+ *
+ * The check used to be `isClassifier`, which covered a `text-classification` encoder and missed
+ * `feature-extraction` — so `all-MiniLM-L6-v2` pulled on its own was offered a chat box for a
+ * head it does not have. It is exactly the package the Retrieval screen exists to serve.
+ */
+    @Test
+    fun chatIsHiddenForAPlainEmbeddingModelToo() {
+        assertEquals(Availability.Hidden, Destination.Chat.availabilityFor(embeddingEncoder()))
+        }
+
+    /** Retrieval needs the embedding stage and nothing else — not a generative head. */
+    @Test
+    fun retrievalFollowsTheEmbeddingStageRatherThanTheTask() {
+        assertEquals(
+            "an encoder with an embedding stage must offer Retrieval",
+            Availability.Enabled,
+            Destination.Retrieval.availabilityFor(embeddingEncoder(rag = true)),
+            )
+        assertEquals(
+            "a decoder with RAG installed must offer Retrieval",
+            Availability.Enabled,
+            Destination.Retrieval.availabilityFor(caps(decoderTask(), rag = true)),
+            )
+        // Blocked, not Hidden: RAG is a download group away, so the reason IS the instruction.
+            assertTrue(
+            "a package with no embedding stage must explain how to get one",
+            Destination.Retrieval.availabilityFor(decoder()) is Availability.Blocked,
+            )
+        }
+
+    /**
+ * Loading a classifier while sitting on Chat must move the user somewhere that exists — the
+ * destination they are on has just left the drawer, and the drawer is behind the screen.
+ */
+    @Test
+    fun aClassifierAndADecoderNeverOfferTheSameScreens() {
+        val forClassifier = Destination.entries.filter { it.availabilityFor(classifier()) !is Availability.Hidden }
+        val forDecoder = Destination.entries.filter { it.availabilityFor(decoder()) !is Availability.Hidden }
+
+        assertTrue(Destination.Classify in forClassifier)
+        assertTrue(Destination.Classify !in forDecoder)
+        assertTrue(Destination.Chat in forDecoder)
+        assertTrue(Destination.Chat !in forClassifier)
+        }
+
+    private fun caps(
+        task: com.martinkorelic.mobiletransformers.packages.PackageTask,
+        training: Boolean = true,
+        rag: Boolean = false,
+) = com.martinkorelic.mobiletransformers.runtime.RuntimeCapabilities(
+        engine = com.martinkorelic.mobiletransformers.runtime.InferenceEngine.NATIVE,
+        supportsTraining = training,
+        supportsMerge = false,
+        supportsRag = rag,
+        supportsEmbedding = rag,
+        task = task,
+            )
+
+    private fun decoderTask() = com.martinkorelic.mobiletransformers.packages.PackageTask(
+        declaredTask = "text-generation-with-past",
+        modelType = "llama",
+            )
+
+    /** `feature-extraction`: an embedding model with no head of any kind. */
+    private fun embeddingEncoder(rag: Boolean = true) = caps(
+        com.martinkorelic.mobiletransformers.packages.PackageTask(
+            declaredTask = "feature-extraction",
+            modelType = "bert",
+),
+        rag = rag,
+            )
+
+    private fun classifier() = caps(
+        com.martinkorelic.mobiletransformers.packages.PackageTask(
+            declaredTask = "text-classification",
+            modelType = "bert",
+            id2label = mapOf(0 to "negative", 1 to "positive"),
+),
+            )
+
+    /** Runs, but every prediction would read `LABEL_n`. */
+    private fun classifierWithoutLabels() = caps(
+        com.martinkorelic.mobiletransformers.packages.PackageTask(
+            declaredTask = "text-classification",
+            modelType = "bert",
+            id2label = emptyMap(),
+),
+            )
+
+    private fun decoder() = caps(
+        com.martinkorelic.mobiletransformers.packages.PackageTask(
+            declaredTask = "text-generation-with-past",
+            modelType = "llama",
+),
+            )
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/PeftDisplayNameTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/PeftDisplayNameTest.kt
new file mode 100644
index 0000000..7b34b9b
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/PeftDisplayNameTest.kt
@@ -0,0 +1,66 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftDisplayName
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftOf
+import com.martinkorelic.mobiletransformers.app.viewmodels.peftOptions
+import com.martinkorelic.mobiletransformers.config.PeftConfig
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * PEFT methods are spelled `LoRA` and `MARS` for a reader and `lora`/`mars` on the wire.
+ *
+ * The separation is the whole point of these tests. The lowercase forms are the `PEFTMethod` enum
+ * mirrored from Python and pinned by `make parity`, they are what a package manifest's `peftMethods`
+ * field contains, and they are what [peftOf] matches on. The obvious "fix" for the casing — editing
+ * the strings in [peftOptions] — would look right on screen and silently break the picker, because
+ * `peftOf("MARS-opt0", …)` falls through to its `else` branch and hands back **LoRA**.
+ *
+ * So: one test that the display is pretty, and one that the wire values underneath are untouched.
+ */
+class PeftDisplayNameTest {
+
+    @Test
+    fun `acronyms are spelled the way they are written`() {
+        assertEquals("LoRA", peftDisplayName("lora"))
+        assertEquals("MARS", peftDisplayName("mars"))
+        assertEquals("LoRA-XS", peftDisplayName("lora-xs"))
+        assertEquals("MARS-opt0", peftDisplayName("mars-opt0"))
+        assertEquals("MARS-opt1", peftDisplayName("mars-opt1"))
+        assertEquals("MARS-quantized", peftDisplayName("mars-quantized"))
+    }
+
+    @Test
+    fun `the picker's options are still WIRE values, not display names`() {
+        // If this fails, someone prettied `peftOptions` itself. See the class docstring: the picker
+        // would keep rendering correctly and quietly select LoRA for every MARS variant.
+        peftOptions.forEach { option ->
+            assertEquals("peftOptions must hold lowercase wire values", option.lowercase(), option)
+        }
+        assertTrue("lora" in peftOptions)
+    }
+
+    @Test
+    fun `every option round-trips through peftOf to a distinct config`() {
+        // The guarantee the wire values exist to provide, asserted end to end rather than assumed.
+        assertTrue(peftOf("lora", 8, 16) is PeftConfig.Lora)
+        assertTrue(peftOf("mars-opt0", 8, 16) is PeftConfig.MarsOpt0)
+        assertTrue(peftOf("mars-opt1", 8, 16) is PeftConfig.MarsOpt1)
+        assertTrue(peftOf("mars-quantized", 8, 16) is PeftConfig.MarsQuantized)
+    }
+
+    @Test
+    fun `a display name fed back to peftOf does NOT resolve - which is why options stay wire`() {
+        // Not a wish, a demonstration: this is exactly what breaks if the two are conflated.
+        val fromDisplay = peftOf(peftDisplayName("mars-opt1"), 8, 16)
+        assertTrue("a display name falls through to the LoRA default", fromDisplay is PeftConfig.Lora)
+        assertNotEquals(peftOf("mars-opt1", 8, 16)::class, fromDisplay::class)
+    }
+
+    @Test
+    fun `an unknown method shows its wire value rather than being guessed at`() {
+        assertEquals("some-future-method", peftDisplayName("some-future-method"))
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/RetrievalCardTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/RetrievalCardTest.kt
new file mode 100644
index 0000000..a49e728
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/RetrievalCardTest.kt
@@ -0,0 +1,51 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.viewmodels.RetrievalCard
+import com.martinkorelic.mobiletransformers.app.viewmodels.SourceCard
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * The line the retrieval turn leads with, before the answer it produced.
+ *
+ * It is the whole claim of that message — everything else is behind a "Show passages" toggle — so it
+ * has to be accurate about the two numbers that differ: passages are chunks, documents are files,
+ * and one file routinely contributes several chunks.
+ */
+class RetrievalCardTest {
+
+    private fun card(vararg passages: Pair<String, String>) = RetrievalCard(
+        passages = passages.map { (title, text) -> SourceCard(text, 0.5, title) },
+        documents = passages.map { it.first }.filter { it.isNotBlank() }.distinct(),
+    )
+
+    @Test
+    fun itCountsChunksAndFilesSeparately() {
+        val c = card("notes.md" to "one", "notes.md" to "two", "setup.txt" to "three")
+        assertEquals("Found 3 passages in 2 documents", c.headline)
+    }
+
+    @Test
+    fun singularsReadAsSentences() {
+        assertEquals("Found 1 passage in 1 document", card("notes.md" to "only").headline)
+    }
+
+    @Test
+    fun nothingRetrievedSaysWhatThatMeansForTheAnswer() {
+        // "0 passages" is a number; what the reader needs is that the answer about to appear is not
+        // grounded in anything, which is the difference between a wrong answer and an unsupported one.
+        assertEquals(
+            "No matching passages — the answer will be ungrounded",
+            RetrievalCard(passages = emptyList(), documents = emptyList()).headline,
+        )
+    }
+
+    @Test
+    fun unattributedPassagesDropTheDocumentClauseRatherThanInventOne() {
+        val c = RetrievalCard(
+            passages = listOf(SourceCard("a", 0.5), SourceCard("b", 0.4)),
+            documents = emptyList(),
+        )
+        assertEquals("Found 2 passages", c.headline)
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ShowcaseStateTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ShowcaseStateTest.kt
new file mode 100644
index 0000000..c572e02
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/ShowcaseStateTest.kt
@@ -0,0 +1,139 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.viewmodels.EnginePickerState
+import com.martinkorelic.mobiletransformers.app.viewmodels.InstalledRow
+import com.martinkorelic.mobiletransformers.app.viewmodels.ModelsUiState
+import com.martinkorelic.mobiletransformers.constants.SamplingMethod
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The showcase app's **pure** state logic, on the JVM with no device.
+ *
+ * The app module had no test source set at all before this rewrite, which is part of why its screens
+ * could drift into driving the engine layer unnoticed. These cover the parts that decide what a user
+ * sees when things are absent or disabled — the states that are hardest to reach by hand on a device
+ * (no package installed, no GenAI, no training stage) and therefore the ones most likely to rot.
+ */
+class ShowcaseStateTest {
+
+    @After
+    fun tearDown() = AppConfig.reset()
+
+    @Test
+    fun theEmptyStateIsWhatAFreshInstallShows() {
+        assertTrue(ModelsUiState().isEmpty)
+        assertFalse(ModelsUiState(installed = listOf(row())).isEmpty)
+    }
+
+    /**
+     * A manifest-less directory still loads but can report no variants. Saying so is the difference
+     * between "this package is odd" and a user wondering why the variant list is blank.
+     */
+    @Test
+    fun anInstalledRowExplainsItselfIncludingTheLegacyCase() {
+        val modern = row(baseModelId = "HuggingFaceTB/SmolLM2-135M-Instruct", variants = listOf("cpu-int4"))
+        assertTrue(modern.subtitle.contains("HuggingFaceTB/SmolLM2-135M-Instruct"))
+        assertTrue(modern.subtitle.contains("cpu-int4"))
+        assertFalse(modern.subtitle.contains("legacy"))
+
+        // The base model is secondary now that the row's title is the repo it was installed from, so
+        // an absent one is simply omitted rather than announced as "unknown". What still has to be
+        // said is why such a package offers no variants.
+        val legacy = row(baseModelId = null, variants = emptyList(), hasManifest = false)
+        assertFalse(legacy.subtitle.contains("base:"))
+        assertTrue(legacy.subtitle.contains("legacy layout"))
+    }
+
+    /**
+     * The Load regression, at the level the screen sees it.
+     *
+     * The row's load key must be the repo it was installed from, never the manifest's `baseModelId` —
+     * loading by the latter resolves to a different, absent cache directory and reports an installed
+     * package as missing.
+     */
+    @Test
+    fun anInstalledRowLoadsByTheRepoItWasInstalledFrom() {
+        val r = row(repoId = "mobiletransformers/functiongemma-270m-it", baseModelId = "google/functiongemma-270m-it")
+        assertEquals("mobiletransformers/functiongemma-270m-it", r.repoId)
+        assertNotEquals(r.repoId, r.baseModelId)
+    }
+
+    @Test
+    fun sizeIsReportedInMegabytes() {
+        assertEquals(150L, row(sizeBytes = 150L * 1024 * 1024).sizeMb)
+    }
+
+    /**
+     * The picker must explain a missing GenAI rather than silently offering one engine. Native is the
+     * guaranteed floor, so its presence is never the thing being tested — the note is.
+     */
+    @Test
+    fun theEnginePickerExplainsAMissingGenAiAndStaysQuietWhenItIsThere() {
+        val nativeOnly = EnginePickerState(
+            selected = InferenceEngine.NATIVE,
+            available = setOf(InferenceEngine.NATIVE),
+        )
+        assertNotNull(nativeOnly.genAiNote)
+        assertTrue(nativeOnly.genAiNote!!.contains("genai_config.json"))
+
+        val both = EnginePickerState(
+            selected = InferenceEngine.NATIVE,
+            available = setOf(InferenceEngine.NATIVE, InferenceEngine.GENAI),
+        )
+        assertNull("no note is needed when GenAI is actually selectable", both.genAiNote)
+    }
+
+    /**
+     * Config edits round-trip through the public types, and reset restores the SDK's own defaults
+     * rather than the app's idea of them.
+     */
+    @Test
+    fun configurationEditsRoundTripAndResetRestoresSdkDefaults() {
+        val defaultTokens = AppConfig.generation.value.maxNewTokens
+        val defaultSteps = AppConfig.train.value.gradientAccumulationSteps
+
+        AppConfig.updateGeneration { it.copy(maxNewTokens = 4096) }
+        AppConfig.updateGeneration { it.copy(sampling = it.sampling.copy(method = SamplingMethod.TOP_P)) }
+        AppConfig.updateTrain { it.copy(gradientAccumulationSteps = 1) }
+        AppConfig.updateDataset { it.copy(task = "mobile_actions") }
+
+        assertEquals(4096, AppConfig.generation.value.maxNewTokens)
+        assertEquals(SamplingMethod.TOP_P, AppConfig.generation.value.sampling.method)
+        assertEquals(1, AppConfig.train.value.gradientAccumulationSteps)
+        assertEquals("mobile_actions", AppConfig.dataset.value.task)
+
+        AppConfig.reset()
+
+        assertEquals(defaultTokens, AppConfig.generation.value.maxNewTokens)
+        assertEquals(defaultSteps, AppConfig.train.value.gradientAccumulationSteps)
+        assertNull(AppConfig.dataset.value.task)
+    }
+
+    /**
+     * A row is identified by the repo it was **installed from**, which is a different value from the
+     * `baseModelId` the manifest records — see [InstalledRow.repoId]. The default here keeps them
+     * distinct on purpose, so a test that confuses the two fails instead of passing by coincidence.
+     */
+    private fun row(
+        repoId: String = "org/installed-package",
+        baseModelId: String? = "base/model",
+        variants: List<String> = listOf("cpu-int4"),
+        sizeBytes: Long = 1024,
+        hasManifest: Boolean = true,
+    ) = InstalledRow(
+        repoId = repoId,
+        sanitizedRepoId = "org__installed-package",
+        baseModelId = baseModelId,
+        variantIds = variants,
+        sizeBytes = sizeBytes,
+        hasManifest = hasManifest,
+    )
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnMarkerCleaningTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnMarkerCleaningTest.kt
new file mode 100644
index 0000000..fac58e7
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnMarkerCleaningTest.kt
@@ -0,0 +1,91 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.viewmodels.ChatViewModel
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * What a reader sees when a chat model emits its own scaffolding.
+ *
+ * Every template in this app's catalog ends a turn with a marker, and for ChatML models that marker
+ * (`<|im_end|>`) *is* the eos token — so it arrives as the last token of a completely ordinary
+ * reply. The engines suppress it at the emit site now; this is the net under that, and the layer
+ * that also handles a model which keeps talking past its turn and starts playing both parts.
+ *
+ * SmolLM2 showed `<|im_end|>` in the Chat bubble, which is what these assertions are about.
+ */
+class TurnMarkerCleaningTest {
+
+    private fun clean(raw: String) = ChatViewModel.cleanTurnMarkers(raw)
+
+    @Test
+    fun theChatMlEndMarkerNeverReachesTheBubble() {
+        assertEquals("Paris is the capital of France.", clean("Paris is the capital of France.<|im_end|>"))
+    }
+
+    @Test
+    fun aModelPlayingBothPartsIsCutAtItsOwnTurnEnd() {
+        assertEquals(
+            "The Eiffel Tower is in Paris.",
+            clean("The Eiffel Tower is in Paris.<|im_end|>\n<|im_start|>user\nAnd Rome?<|im_end|>"),
+        )
+        assertEquals(
+            "It is 4.",
+            clean("It is 4.<end_of_turn><start_of_turn>user\nwhat about 3+3<end_of_turn>"),
+        )
+    }
+
+    @Test
+    fun aRoleLabelTheModelCompletedForItselfIsStripped() {
+        // Gemma's prompt ends with `<start_of_turn>model\n` and the model often re-emits the label.
+        assertEquals("Done.", clean("model\nDone.<end_of_turn>"))
+        assertEquals("Done.", clean("assistant\nDone.<|im_end|>"))
+        // ...but only as its own line: "model" is an ordinary word, and a reply that opens with it
+        // must survive intact. `removePrefix("model")` on its own got this wrong.
+        assertEquals("model weights are stored on device.", clean("model weights are stored on device."))
+        assertEquals("models are exported by optimum.", clean("models are exported by optimum."))
+    }
+
+    @Test
+    fun ordinaryTextIsUntouched() {
+        assertEquals("2 + 2 = 4", clean("2 + 2 = 4"))
+        assertEquals("", clean("   "))
+        // A partially streamed marker is still incomplete text, not a marker — cutting early here
+        // would make the streaming bubble flicker on every token that starts with `<`.
+        assertEquals("almost <|im_en", clean("almost <|im_en"))
+    }
+
+    /**
+     * Cleaning is for DISPLAY; the accumulator behind it must stay raw.
+     *
+     * Feeding `clean()` its own output token by token — `clean(shown + token)` — drops any newline a
+     * token ends with, because `trim()` sees it as trailing. Every list item and paragraph break in a
+     * streamed answer ends a token that way, so the next token runs straight onto the previous line.
+     * This asserts the shape the view models actually use.
+     */
+    @Test
+    fun streamingCleansForDisplayWithoutEatingTheAccumulatorsNewlines() {
+        val tokens = listOf("Steps:\n", "1. pull\n", "2. train\n", "3. merge", "<|im_end|>")
+
+        val raw = StringBuilder()
+        var shown = ""
+        for (token in tokens) {
+            raw.append(token)
+            shown = clean(raw.toString())
+        }
+        assertEquals("Steps:\n1. pull\n2. train\n3. merge", shown)
+
+        // The shape that loses them, kept here so the difference is visible rather than asserted about.
+        var wrong = ""
+        for (token in tokens) wrong = clean(wrong + token)
+        assertEquals("Steps:1. pull2. train3. merge", wrong)
+    }
+
+    @Test
+    fun everyMarkerInTheListIsActuallyStripped() {
+        // A list that silently stopped matching would pass every case above except this one.
+        for (marker in ChatViewModel.TURN_MARKERS) {
+            assertEquals("answer for $marker", "answer", clean("answer$marker trailing"))
+        }
+    }
+}
diff --git a/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnStatsTest.kt b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnStatsTest.kt
new file mode 100644
index 0000000..2961aeb
--- /dev/null
+++ b/android/MobileTransformers/MobileTransformersApp/src/test/java/com/martinkorelic/mobiletransformers/app/TurnStatsTest.kt
@@ -0,0 +1,78 @@
+package com.martinkorelic.mobiletransformers.app
+
+import com.martinkorelic.mobiletransformers.app.viewmodels.TurnStats
+import com.martinkorelic.mobiletransformers.runtime.GenerationResult
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The per-turn line under an assistant message.
+ *
+ * Chat reported `"N tokens · X tok/s"` and nothing about the window, so the number that predicts the
+ * next turn being truncated was the one number missing. Context used is prompt **plus** completion:
+ * reporting only the completion understates it by the whole conversation so far, which is precisely
+ * the part that grows.
+ */
+class TurnStatsTest {
+
+    private fun result(
+        tokens: Int = 37,
+        rate: Double = 4.2,
+        promptTokens: Int = 475,
+        limit: Int = 32768,
+    ) = GenerationResult(
+        text = "hello",
+        tokenCount = tokens,
+        avgTokensPerSecond = rate,
+        promptTokenCount = promptTokens,
+        contextLimit = limit,
+    )
+
+    @Test
+    fun contextUsedIsPromptPlusCompletion() {
+        assertEquals(512, result().contextUsedTokens)
+    }
+
+    @Test
+    fun theLineCarriesSpeedAndWindow() {
+        val line = TurnStats.of(result())!!.render()
+
+        assertTrue(line, line.contains("37 tokens"))
+        assertTrue(line, line.contains("4.2 tok/s"))
+        assertTrue("the window is the point of the change: $line", line.contains("32,768"))
+        assertTrue("and how full it is: $line", line.contains("2%"))
+    }
+
+    @Test
+    fun aPackageDeclaringNoContextLimitStillReportsWhatItKnows() {
+        // contextLimit is 0 for a package whose tokenizer config declares no model_max_length.
+        // Inventing a denominator would be worse than omitting the percentage.
+        val line = TurnStats.of(result(limit = 0))!!.render()
+
+        assertTrue(line, line.contains("512 tokens"))
+        assertFalse("no percentage without a limit: $line", line.contains("%"))
+    }
+
+    @Test
+    fun anUnmeasuredRateIsOmittedRatherThanShownAsZero() {
+        val line = TurnStats.of(result(rate = 0.0))!!.render()
+
+        assertFalse("0.0 tok/s is a measurement that was not taken, not a speed: $line", line.contains("tok/s"))
+    }
+
+    @Test
+    fun thereAreNoStatsWhenThereWasNoGeneration() {
+        assertNull(TurnStats.of(null as GenerationResult?))
+    }
+
+    @Test
+    fun aNearlyFullWindowIsVisible() {
+        // The case the line exists for.
+        val line = TurnStats.of(result(promptTokens = 31_000, tokens = 500, limit = 32_768))!!.render()
+
+        assertTrue(line, line.contains("96%"))
+    }
+}
diff --git a/android/ORTransformer/build.gradle.kts b/android/MobileTransformers/build.gradle.kts
similarity index 100%
rename from android/ORTransformer/build.gradle.kts
rename to android/MobileTransformers/build.gradle.kts
diff --git a/android/ORTransformer/gradle.properties b/android/MobileTransformers/gradle.properties
similarity index 77%
rename from android/ORTransformer/gradle.properties
rename to android/MobileTransformers/gradle.properties
index 97a23a8..b2c78be 100644
--- a/android/ORTransformer/gradle.properties
+++ b/android/MobileTransformers/gradle.properties
@@ -20,4 +20,10 @@ kotlin.code.style=official
 # Enables namespacing of each library's R class so that its R class includes only the
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
-android.nonTransitiveRClass=true
\ No newline at end of file
+android.nonTransitiveRClass=true
+
+# --- Publication coordinates (#30/#32) ---------------------------------------------------------
+# `version` MUST equal `pyproject.toml`'s [project] version — the release gate asserts it
+# (tests/unit/test_version_sites.py). Override for a snapshot/CI build with -Pversion=<x>.
+group=com.martinkorelic.mobiletransformers
+version=0.2.0
diff --git a/android/MobileTransformers/gradle/libs.versions.toml b/android/MobileTransformers/gradle/libs.versions.toml
new file mode 100644
index 0000000..013e17e
--- /dev/null
+++ b/android/MobileTransformers/gradle/libs.versions.toml
@@ -0,0 +1,67 @@
+[versions]
+activityCompose = "1.9.2"
+agp = "8.5.1"
+gson = "2.11.0"
+kotlin = "1.9.0"
+coreKtx = "1.13.1"
+junit = "4.13.2"
+# Robolectric 4.12.x targets AGP 8.x / JDK 17 and provides Android SDK 34 stubs.
+robolectric = "4.12.2"
+junitVersion = "1.2.1"
+espressoCore = "3.6.1"
+appcompat = "1.7.0"
+material = "1.12.0"
+constraintlayout = "2.1.4"
+lifecycleRuntimeKtx = "2.8.4"
+composeBom = "2024.04.01"
+pebble = "3.2.2"
+objectbox = "4.3.0"
+okhttp = "4.12.0"
+work = "2.9.1"
+coroutines = "1.8.1"
+testRunner = "1.6.2"
+
+[libraries]
+androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activityCompose" }
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-material3 = { module = "androidx.compose.material3:material3" }
+androidx-ui-tooling = { module = "androidx.compose.ui:ui-tooling" }
+androidx-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" }
+gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
+# The showcase app's screens are ViewModel-driven so their state mapping is JVM-testable without a device.
+androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycleRuntimeKtx" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+# The drawer, the model bar and the chat/tool-call cards are read at a glance from their icons; the
+# base `material-icons-core` set that ships with material3 does not carry them.
+androidx-material-icons-extended = { group = "androidx.compose.material", name = "material-icons-extended" }
+androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
+androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
+pebble = { module = "io.pebbletemplates:pebble", version.ref = "pebble" }
+objectbox-android = { group = "io.objectbox", name = "objectbox.android", version.ref = "objectbox" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
+androidx-work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }
+# #34 device leg: TestListenableWorkerBuilder + WorkManagerTestInitHelper, so a scheduled training
+# chunk can be driven directly on hardware without waiting on real charging/idle constraints.
+androidx-work-testing = { group = "androidx.work", name = "work-testing", version.ref = "work" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+android-library = { id = "com.android.library", version.ref = "agp" }
+objectbox = { id = "io.objectbox", version.ref = "objectbox"}
+
diff --git a/android/ORTransformer/gradle/wrapper/gradle-wrapper.jar b/android/MobileTransformers/gradle/wrapper/gradle-wrapper.jar
similarity index 100%
rename from android/ORTransformer/gradle/wrapper/gradle-wrapper.jar
rename to android/MobileTransformers/gradle/wrapper/gradle-wrapper.jar
diff --git a/android/ORTransformer/gradle/wrapper/gradle-wrapper.properties b/android/MobileTransformers/gradle/wrapper/gradle-wrapper.properties
similarity index 100%
rename from android/ORTransformer/gradle/wrapper/gradle-wrapper.properties
rename to android/MobileTransformers/gradle/wrapper/gradle-wrapper.properties
diff --git a/android/ORTransformer/gradlew b/android/MobileTransformers/gradlew
similarity index 100%
rename from android/ORTransformer/gradlew
rename to android/MobileTransformers/gradlew
diff --git a/android/ORTransformer/gradlew.bat b/android/MobileTransformers/gradlew.bat
similarity index 100%
rename from android/ORTransformer/gradlew.bat
rename to android/MobileTransformers/gradlew.bat
diff --git a/android/ORTransformer/settings.gradle.kts b/android/MobileTransformers/settings.gradle.kts
similarity index 86%
rename from android/ORTransformer/settings.gradle.kts
rename to android/MobileTransformers/settings.gradle.kts
index cd8a443..5a7a108 100644
--- a/android/ORTransformer/settings.gradle.kts
+++ b/android/MobileTransformers/settings.gradle.kts
@@ -26,6 +26,6 @@ dependencyResolutionManagement {
     }
 }
 
-rootProject.name = "ORTTransformer"
-include(":app")
-include(":ORTransformersMobile")
+rootProject.name = "MobileTransformers"
+include(":MobileTransformersApp")
+include(":MobileTransformers")
diff --git a/android/ORTransformer/ORTransformersMobile/build.gradle.kts b/android/ORTransformer/ORTransformersMobile/build.gradle.kts
deleted file mode 100644
index 298d56e..0000000
--- a/android/ORTransformer/ORTransformersMobile/build.gradle.kts
+++ /dev/null
@@ -1,71 +0,0 @@
-plugins {
-    alias(libs.plugins.android.library)
-    alias(libs.plugins.jetbrains.kotlin.android)
-    alias(libs.plugins.objectbox)
-}
-
-android {
-    namespace = "com.martinkorelic.ortmobile"
-    compileSdk = 34
-
-    sourceSets {
-        getByName("main") {
-            jniLibs.srcDirs("libs")
-        }
-    }
-
-    defaultConfig {
-        minSdk = 24
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        consumerProguardFiles("consumer-rules.pro")
-        externalNativeBuild {
-            cmake {
-                cppFlags += "-std=c++17"
-                arguments += "-DJSON_BuildTests=OFF"
-            }
-        }
-        ndk {
-            abiFilters += listOf("arm64-v8a", "x86_64")
-        }
-    }
-
-    buildTypes {
-        release {
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-    externalNativeBuild {
-        cmake {
-            path("src/main/cpp/CMakeLists.txt")
-            version = "3.22.1"
-        }
-    }
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-dependencies {
-
-    // ONNX Runtime GenAI implementation
-    implementation(files("./src/main/aarLibs/onnxruntime-genai.aar"))
-
-    implementation(libs.pebble)
-    implementation(libs.gson)
-
-    implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.appcompat)
-    implementation(libs.material)
-
-    testImplementation(libs.junit)
-    androidTestImplementation(libs.androidx.junit)
-    androidTestImplementation(libs.androidx.espresso.core)
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/androidTest/java/com/martinkorelic/ortmobile/ExampleInstrumentedTest.kt b/android/ORTransformer/ORTransformersMobile/src/androidTest/java/com/martinkorelic/ortmobile/ExampleInstrumentedTest.kt
deleted file mode 100644
index 0f2f034..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/androidTest/java/com/martinkorelic/ortmobile/ExampleInstrumentedTest.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("com.martinkorelic.ortmobile.test", appContext.packageName)
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/AndroidManifest.xml b/android/ORTransformer/ORTransformersMobile/src/main/AndroidManifest.xml
deleted file mode 100644
index a5918e6..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-</manifest>
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/native-lib.cpp b/android/ORTransformer/ORTransformersMobile/src/main/cpp/native-lib.cpp
deleted file mode 100644
index 41231c0..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/native-lib.cpp
+++ /dev/null
@@ -1,629 +0,0 @@
-//
-// Created by martinkorelic on 31/08/2024
-//
-
-#include <jni.h>
-#include <string>
-#include "onnxruntime/onnxruntime_training_cxx_api.h"
-#include "inference.h"
-#include "tokenization.h"
-#include "train.h"
-#include "utils.h"
-#include "sampling.h"
-#include <android/log.h>
-#include "proto/onnx.pb.h"
-
-#define LOG_TAG "ORTTransformerMobile"
-
-extern "C" JNIEXPORT jstring JNICALL
-Java_com_martinkorelic_ortmobile_MainActivity_stringFromJNI(
-        JNIEnv* env,
-        jobject /* this */) {
-    std::string hello = "Hello from C++";
-    return env->NewStringUTF(hello.c_str());
-}
-
-void ReleaseTrainingSession(jlong session, jboolean saveCheckpoint) {
-    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    if (saveCheckpoint) {
-        // Include optimizer state?
-        Ort::CheckpointState::SaveCheckpoint(session_cache->checkpoint_state, session_cache->artifact_paths.checkpoint_path, true);
-    }
-
-    delete session_cache;
-    session_cache = nullptr;
-}
-
-void ReleaseWeightSession(jlong session) {
-    auto *session_cache = reinterpret_cast<WeightSessionCache *>(session);
-
-    delete session_cache;
-    session_cache = nullptr;
-}
-
-void ReleaseTokenizerSession(jlong session) {
-    auto *session_cache = reinterpret_cast<TokenizerSessionCache *>(session);
-
-    delete session_cache;
-    session_cache = nullptr;
-}
-
-extern "C"
-JNIEXPORT float JNICALL
-/**
- * Performs the training step with the gradient update and optimizer step.
- * Attention mask, position ids and labels are created from the given input ids.
- *
- * @param env
- * @param session
- * @param input_ids
- * @param batch_size
- * @param sequence_length
- *
- * @return Loss value
- */
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_performTraining(
-        JNIEnv *env, jobject /* this */,
-        jlong session,
-        jlongArray input_ids, jlongArray labels, jlongArray attention_mask, jint batch_size, jint sequence_length) {
-    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    // Get the input_ids array from the Java environment
-    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
-    jlong* label_elements = env->GetLongArrayElements(labels, nullptr);
-    jlong* attention_elements = env->GetLongArrayElements(attention_mask, nullptr);
-
-    // Calculate the total size for the input data based on batch_size and sequence_length
-    size_t total_size = batch_size * sequence_length;
-
-    // Allocate memory for attention mask, position ids, and labels (assuming labels are provided here)
-    //std::vector<int64_t> attention_mask(total_size, 1);  // Initialized with 1s
-    std::vector<int64_t> position_ids(total_size);
-    //std::vector<int64_t> labels(total_size, 0);
-
-    // Populate position ids (0 to sequence_length - 1 for each batch element)
-    for (int64_t i = 0; i < batch_size; ++i) {
-        for (int64_t j = 0; j < sequence_length; ++j) {
-            position_ids[i * sequence_length + j] = j;
-        }
-    }
-
-    // Prepare attention_mask and position_ids as jlongArrays to return to Java if needed
-    //jlongArray attention_mask_array = env->NewLongArray(total_size);
-    //jlongArray position_ids_array = env->NewLongArray(total_size);
-    //jlongArray labels_array = env->NewLongArray(total_size);
-
-    // Copy the vectors to the Java arrays
-    //env->SetLongArrayRegion(attention_mask_array, 0, total_size, attention_mask.data());
-    //env->SetLongArrayRegion(position_ids_array, 0, total_size, position_ids.data());
-    //env->SetLongArrayRegion(labels_array, 0, total_size, labels.data());
-
-    // If need be prepare labels
-    //utils::initialize_labels(input_ids_elements, labels.data(), batch_size, sequence_length);
-
-    // Update the model parameters using this batch of inputs.
-    float loss = training::train_step(session_cache, input_ids_elements,
-                                attention_elements, position_ids.data(), label_elements, batch_size, sequence_length);
-
-    env->ReleaseLongArrayElements(input_ids, input_ids_elements, JNI_ABORT);
-    env->ReleaseLongArrayElements(labels, label_elements, JNI_ABORT);
-    env->ReleaseLongArrayElements(attention_mask, attention_elements, JNI_ABORT);
-
-    return loss;
-}
-
-extern "C"
-JNIEXPORT jlong JNICALL
-/**
- * Creates the training session from the given artifact paths.
- *
- * @param env
- * @param thiz
- * @param checkpoint_path
- * @param train_model_path
- * @param eval_model_path
- * @param optimizer_model_path
- * @param cache_dir_path
- * @param requires_grad
- *
- * @return Training session native model handle.
- */
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_createTrainingSession(JNIEnv *env, jobject thiz,
-                                                           jstring checkpoint_path,
-                                                           jstring train_model_path,
-                                                           jstring eval_model_path,
-                                                           jstring optimizer_model_path,
-                                                           jstring cache_dir_path,
-                                                           jobjectArray requires_grad,
-                                                           jstring memory_config_id,
-                                                           jstring core_config_id,
-                                                           jstring execution_provider,
-                                                           jboolean enable_profiling) {
-
-    // Get the size of the input array
-    jsize arrayLength = env->GetArrayLength(requires_grad);
-
-    std::unique_ptr<TrainingSessionCache> session_cache = std::make_unique<TrainingSessionCache>(
-            utils::JString2String(env, checkpoint_path),
-            utils::JString2String(env, train_model_path),
-            utils::JString2String(env, eval_model_path),
-            utils::JString2String(env, optimizer_model_path),
-            utils::JString2String(env, cache_dir_path),
-            utils::JString2String(env, memory_config_id),
-            utils::JString2String(env, core_config_id),
-            utils::JString2String(env, execution_provider),
-            enable_profiling);
-
-    for (jsize i = 0; i < arrayLength; ++i) {
-        auto jstr = (jstring) (env->GetObjectArrayElement(requires_grad, i));
-        const char *cstr = env->GetStringUTFChars(jstr, nullptr);
-        session_cache->requires_grad.emplace_back(cstr);
-
-        // Release the string
-        env->ReleaseStringUTFChars(jstr, cstr);
-        env->DeleteLocalRef(jstr);
-    }
-
-    return reinterpret_cast<long>(session_cache.release());
-}
-
-
-
-extern "C" JNIEXPORT jlong JNICALL
-/**
- * Creates normal inference session from the given inference model path.
- * This inference is a custom made inference which is ready to be used for generation with KV caching.
- *
- * If load_merged_weights is enabled:
- * 1. Transfer the weights to the inference session options with the weights from the weights that were merged and saved.
- * 2. Load the inference model
- * 3. The model is ready for inference with the merged weights.
- *
- * @param env
- * @param inference_model_path
- * @param inference_model_name
- * @param load_merged_weights - Whether to load merged weights from ".../inference/merged"
- * @return
- */
-Java_com_martinkorelic_ortmobile_ORTGeneratorNative_createInferenceSession(
-        JNIEnv *env, jobject /* this */,
-        jstring inference_model_path,
-        jstring inference_model_name,
-        jstring cache_dir_path,
-        jboolean load_merged_weights,
-        jstring core_config_id,
-        jstring memory_config_id,
-        jstring execution_provider,
-        jboolean enable_profiling
-        ) {
-
-    // If we load from merged weights, then we assume it is stored in the same directory as the inference model
-    // -> inference_model_path/merged
-    std::unique_ptr<InferenceSessionCache> session_cache = std::make_unique<InferenceSessionCache>(
-            utils::JString2String(env, inference_model_path),
-            utils::JString2String(env, inference_model_name),
-            utils::JString2String(env, cache_dir_path),
-            utils::JString2String(env, memory_config_id),
-            utils::JString2String(env, core_config_id),
-            utils::JString2String(env, execution_provider),
-            load_merged_weights,
-            enable_profiling);
-
-    session_cache->initializeKVCache(1);
-
-    return reinterpret_cast<long>(session_cache.release());
-}
-
-extern "C" JNIEXPORT void JNICALL
-/**
- * Deletes the current inference session.
- *
- * @param env
- * @param session
- */
-Java_com_martinkorelic_ortmobile_ORTGeneratorNative_releaseInferenceSession(
-        JNIEnv *env, jobject /* this */,
-        jlong session) {
-    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
-
-    delete session_cache->inference_session;
-    delete session_cache;
-    session_cache = nullptr;
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_releaseTrainingSession(
-        JNIEnv *env, jobject,
-        jlong session, jboolean saveCheckpoint) {
-    ReleaseTrainingSession(session, saveCheckpoint);
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-/**
- * Utility function, example of inspecting weights in the model from the checkpoint state.
- * */
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_inspectWeights(JNIEnv *env, jobject thiz,
-                                                            jlong session, jstring layer) {
-    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    Ort::Value parameter = session_cache->checkpoint_state.GetParameter(utils::JString2String(env, layer));
-
-    auto type_info = parameter.GetTypeInfo();
-    auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
-
-    // Get tensor dimensions
-    std::vector<int64_t> dimensions = tensor_info.GetShape();
-    // Get the data type
-    ONNXTensorElementDataType dtype = tensor_info.GetElementType();
-
-    __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Type: type=%u", dtype);
-    for (auto dim: dimensions) {
-        __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Dimension: type=%ld", dim);
-    }
-}
-
-
-extern "C"
-JNIEXPORT jstring JNICALL
-/**
- * Export model for inference from the training session.
- *
- * @param env
- * @param thiz
- * @param session - Current training session native model handle
- * @return
- */
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_exportModelForInference(JNIEnv *env, jobject thiz,
-                                                                   jlong session) {
-    auto *session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-    session_cache->training_session.ExportModelForInferencing(session_cache->artifact_paths.inference_model_path, {"logits"});
-    return env->NewStringUTF(session_cache->artifact_paths.inference_model_path.c_str());
-}
-
-
-extern "C"
-JNIEXPORT jint JNICALL
-/**
- * Performs the inference step using the exported model for inference.
- *
- * @param env
- * @param thiz
- * @param session
- * @param input_ids
- * @param attention_mask
- * @param position_ids
- * @param sequence_length
- * @param past_sequence_length
- * @param vocab_size
- *
- * @return Next token id
- */
-Java_com_martinkorelic_ortmobile_ORTGeneratorNative_performInferenceStep(JNIEnv *env, jobject thiz,
-                                                                  jlong session,
-                                                                  jlongArray input_ids,
-                                                                  jlongArray attention_mask,
-                                                                  jlongArray position_ids,
-                                                                  jint batch_size,
-                                                                  jint sequence_length,
-                                                                  jint past_sequence_length,
-                                                                  jint vocab_size
-                                                                  ) {
-    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
-
-    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
-    jlong* attention_mask_elements = env->GetLongArrayElements(attention_mask, nullptr);
-    jlong* position_ids_elements = env->GetLongArrayElements(position_ids, nullptr);
-
-    // Forward pass
-    auto logits = inference::generateWithKVCache(session_cache,
-                                   input_ids_elements,
-                                   attention_mask_elements,
-                                   position_ids_elements,
-                                   batch_size,
-                                   sequence_length,
-                                   past_sequence_length);
-
-    int best_index = sampling::sampleNextToken(logits, past_sequence_length, vocab_size, session_cache->sampling_config, session_cache->random_generator);
-
-    return best_index;
-}
-
-extern "C"
-JNIEXPORT jlong JNICALL
-Java_com_martinkorelic_ortmobile_ORTTokenizerNative_createTokenizerSession(JNIEnv *env,
-                                                                          jobject thiz,
-                                                                          jstring jTokenizerFile) {
-    // Convert Java string to C++ string
-    const char *tokenizer_file = env->GetStringUTFChars(jTokenizerFile, nullptr);
-    std::unique_ptr<TokenizerSessionCache> tokenizer = std::make_unique<TokenizerSessionCache>(tokenizer_file);
-
-    // Release the Java string memory
-    env->ReleaseStringUTFChars(jTokenizerFile, tokenizer_file);
-
-    // Return the handle (cast the unique pointer to `jlong`)
-    return reinterpret_cast<jlong>(tokenizer.release());
-}
-
-
-extern "C"
-JNIEXPORT jintArray JNICALL
-Java_com_martinkorelic_ortmobile_ORTTokenizerNative_tokenizeString(JNIEnv *env, jobject thiz,
-                                                                  jlong tokenizer_model,
-                                                                  jstring sequence) {
-    // Convert Java string to C++ string
-    const char *text = env->GetStringUTFChars(sequence, nullptr);
-
-    std::vector<int32_t> tokens = tokenization::tokenize(tokenizer_model, text);
-
-    // Release the Java string memory
-    env->ReleaseStringUTFChars(sequence, text);
-    jintArray token_array = env->NewIntArray(tokens.size());
-    env->SetIntArrayRegion(token_array, 0, tokens.size(), reinterpret_cast<const jint *>(tokens.data()));
-    return token_array;
-}
-
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_martinkorelic_ortmobile_ORTTokenizerNative_decodeString(JNIEnv *env, jobject thiz,
-                                                                  jlong tokenizer_model,
-                                                                  jintArray sequence) {
-
-    // Convert Java int array to C++ vector
-    jsize length = env->GetArrayLength(sequence);
-    std::vector<int32_t> token_ids(length);
-    env->GetIntArrayRegion(sequence, 0, length, reinterpret_cast<jint *>(token_ids.data()));
-
-    // Decode the token IDs
-    std::string decoded_text = tokenization::decode(tokenizer_model, token_ids);
-
-    // Convert C++ string to Java string
-    return env->NewStringUTF(decoded_text.c_str());
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTTokenizerNative_releaseTokenizerSession(JNIEnv *env, jobject thiz, jlong tokenizer_model) {
-    ReleaseTokenizerSession(tokenizer_model);
-}
-
-extern "C"
-JNIEXPORT jstring JNICALL
-Java_com_martinkorelic_ortmobile_ORTTokenizerNative_decodeToken(JNIEnv *env, jobject thiz,
-                                                               jlong tokenizer_model,
-                                                               jint token_id) {
-
-    // Decode the token IDs
-    std::string decoded_text = tokenization::decodeToken(tokenizer_model, token_id);
-
-    // Convert C++ string to Java string
-    return env->NewStringUTF(decoded_text.c_str());
-}
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_optimizerStep(JNIEnv *env, jobject thiz,
-                                                                jlong session) {
-    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    return training::optimizer_step(session_cache);
-}
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_setLearningRate(JNIEnv *env, jobject thiz,
-                                                                  jlong session,
-                                                                  jfloat learning_rate) {
-    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    session_cache->SetLearningRate(learning_rate);
-}
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_saveModel(JNIEnv *env, jobject thiz,
-                                                            jlong session, jboolean saveOptimizer) {
-    auto* session_cache = reinterpret_cast<TrainingSessionCache *>(session);
-
-    Ort::CheckpointState::SaveCheckpoint(session_cache->checkpoint_state, session_cache->artifact_paths.checkpoint_path, saveOptimizer);
-}
-
-extern "C"
-JNIEXPORT jboolean JNICALL
-/**
- * Merges and exports the weights which are then ready for inference session.
- *
- * @param env
- * @param thiz
- * @param session
- */
-Java_com_martinkorelic_ortmobile_ORTTrainerNative_mergeExportWeights(JNIEnv *env, jobject thiz,
-                                                                     jlong session,
-                                                                     jstring peft_mapping_path,
-                                                                     jstring merger_models_directory,
-                                                                     jstring output_directory) {
-    try {
-        auto* session_cache = reinterpret_cast<TrainingSessionCache*>(session);
-
-        // Convert Java strings to C++ strings
-        const char* peft_path_cstr = env->GetStringUTFChars(peft_mapping_path, nullptr);
-        const char* merger_models_dir_cstr = env->GetStringUTFChars(merger_models_directory, nullptr);
-        const char* output_dir_cstr = env->GetStringUTFChars(output_directory, nullptr);
-
-        std::string peft_path(peft_path_cstr);
-        std::string merger_models_dir(merger_models_dir_cstr);
-        std::string output_dir(output_dir_cstr);
-
-        // Release Java strings
-        env->ReleaseStringUTFChars(peft_mapping_path, peft_path_cstr);
-        env->ReleaseStringUTFChars(merger_models_directory, merger_models_dir_cstr);
-        env->ReleaseStringUTFChars(output_directory, output_dir_cstr);
-
-        // Perform weight merging
-        bool success = session_cache->weight_merger->merge_and_export_weights(
-                session_cache->checkpoint_state,
-                peft_path,
-                merger_models_dir,
-                output_dir
-        );
-
-        // Destroy the old WeightMerger instance and create a new one for next time
-        session_cache->weight_merger.reset();
-        session_cache->weight_merger = nullptr;
-        session_cache->weight_merger = std::make_unique<WeightMerger>();
-
-        return success ? JNI_TRUE : JNI_FALSE;
-
-    } catch (const std::exception& e) {
-        LOGE("Error in mergeExportWeights: %s", e.what());
-        return JNI_FALSE;
-    }
-}
-
-// Additional JNI function to configure sampling parameters
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTGeneratorNative_setSamplingConfig(JNIEnv *env, jobject thiz,
-                                                                      jlong session,
-                                                                      jint sampling_method,
-                                                                      jfloat temperature,
-                                                                      jint top_k,
-                                                                      jfloat top_p,
-                                                                      jint random_seed) {
-    auto *session_cache = reinterpret_cast<InferenceSessionCache *>(session);
-
-    auto method = static_cast<sampling::SamplingMethod>(sampling_method);
-
-    session_cache->setSamplingConfig(method, temperature, top_k, top_p, random_seed);
-}
-
-extern "C"
-JNIEXPORT jlong JNICALL
-Java_com_martinkorelic_ortmobile_ORTRetriever_createEmbeddingSession(JNIEnv *env, jobject thiz,
-                                                                     jstring embedding_model_path,
-                                                                     jstring embedding_model_name,
-                                                                     jstring cache_dir_path,
-                                                                     jstring memory_config_id,
-                                                                     jstring core_config_id,
-                                                                     jstring execution_provider,
-                                                                     jboolean enable_profiling) {
-    try {
-        // Convert Java strings to C++ strings
-        const char *model_path_chars = env->GetStringUTFChars(embedding_model_path, nullptr);
-        const char *model_name_chars = env->GetStringUTFChars(embedding_model_name, nullptr);
-        const char *cache_path_chars = env->GetStringUTFChars(cache_dir_path, nullptr);
-        const char *memory_config_chars = env->GetStringUTFChars(memory_config_id, nullptr);
-        const char *core_config_chars = env->GetStringUTFChars(core_config_id, nullptr);
-        const char *execution_provider_chars = env->GetStringUTFChars(execution_provider, nullptr);
-
-        std::string model_path_str(model_path_chars);
-        std::string model_name_str(model_name_chars);
-        std::string cache_path_str(cache_path_chars);
-        std::string memory_config_str(memory_config_chars);
-        std::string core_config_str(core_config_chars);
-        std::string execution_provider_str(execution_provider_chars);
-
-        // Release Java string references
-        env->ReleaseStringUTFChars(embedding_model_path, model_path_chars);
-        env->ReleaseStringUTFChars(embedding_model_name, model_name_chars);
-        env->ReleaseStringUTFChars(cache_dir_path, cache_path_chars);
-        env->ReleaseStringUTFChars(memory_config_id, memory_config_chars);
-        env->ReleaseStringUTFChars(core_config_id, core_config_chars);
-        env->ReleaseStringUTFChars(execution_provider, execution_provider_chars);
-
-        LOGI("Creating embedding session with model: %s", model_name_str.c_str());
-
-        // Create the embedding session cache
-        auto *embedding_session = new EmbeddingSessionCache(
-                model_path_str,
-                model_name_str,
-                cache_path_str,
-                memory_config_str,
-                core_config_str,
-                execution_provider_str,
-                static_cast<bool>(enable_profiling)
-        );
-
-        LOGI("Embedding session created successfully");
-
-        // Return the pointer as jlong
-        return reinterpret_cast<jlong>(embedding_session);
-
-    } catch (const std::exception &e) {
-        LOGE("Failed to create embedding session: %s", e.what());
-
-        // Throw Java exception
-        jclass exception_class = env->FindClass("java/lang/RuntimeException");
-        if (exception_class != nullptr) {
-            env->ThrowNew(exception_class, e.what());
-        }
-
-        return 0;
-    }
-}
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_martinkorelic_ortmobile_ORTRetriever_releaseEmbeddingSession(JNIEnv *env, jobject thiz, jlong session) {
-    try {
-
-        auto *session_cache = reinterpret_cast<EmbeddingSessionCache *>(session);
-
-        delete session_cache->embedding_session;
-        delete session_cache;
-        session_cache = nullptr;
-
-    } catch (const std::exception& e) {
-        LOGE("Failed to destroy embedding session: %s", e.what());
-    }
-}
-
-extern "C"
-JNIEXPORT jfloatArray JNICALL
-/**
- * Performs the inference step using the exported model for inference.
- *
- * @param env
- * @param thiz
- * @param session
- * @param input_ids
- * @param attention_mask
- * @param token_type_ids
- * @param sequence_length
- *
- * @return Next token id
- */
-Java_com_martinkorelic_ortmobile_ORTRetriever_performEmbeddingStep(JNIEnv *env, jobject thiz,
-        jlong session,
-        jlongArray input_ids,
-        jlongArray attention_mask,
-        jlongArray token_type_ids,
-        jint batch_size,
-        jint sequence_length,
-        jint embedding_dim) {
-    auto *session_cache = reinterpret_cast<EmbeddingSessionCache *>(session);
-
-    jlong* input_ids_elements = env->GetLongArrayElements(input_ids, nullptr);
-    jlong* attention_mask_elements = env->GetLongArrayElements(attention_mask, nullptr);
-    jlong* token_type_ids_elements = env->GetLongArrayElements(token_type_ids, nullptr);
-
-    // Forward pass
-    auto embedding_vector = inference::generateEmbedding(session_cache,
-                                        input_ids_elements,
-                                     attention_mask_elements,
-                                     token_type_ids_elements,
-                                                 batch_size,
-                                                 sequence_length);
-
-    jint total_size = batch_size * embedding_dim;
-    jfloatArray result = env->NewFloatArray(total_size);
-    if (!result) {
-        LOGE("Failed to create result float array");
-        // Clean up the embedding vector if it was dynamically allocated
-        delete[] embedding_vector; // or appropriate cleanup based on your memory management
-        return nullptr;
-    }
-
-    // Copy data to Java array
-    env->SetFloatArrayRegion(result, 0, total_size, embedding_vector);
-
-    return result;
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnx-genai.cpp b/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnx-genai.cpp
deleted file mode 100644
index 742e007..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnx-genai.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-//
-// Deprecated ONNX GenAI functions, due to incompatibility with ORTransformersMobile functionalities
-//
-// Created by martinkorelic on 20. 07. 25.
-//
-
-//#include "onnxruntime-genai/ort_genai.h"
-//#include "onnxruntime-genai/ort_genai_c.h"
-//
-
-//    std::string genAiInferenceStep(GenAISessionCache* session_cache) {
-//
-//        session_cache->generator->ComputeLogits();
-//        session_cache->generator->GenerateNextToken();
-//
-//        const auto num_tokens = session_cache->generator->GetSequenceCount(0);
-//        const auto new_token = session_cache->generator->GetSequenceData(0)[num_tokens - 1];
-//        return session_cache->tokenizer_stream->Decode(new_token);
-//    }
-
-//extern "C" JNIEXPORT void JNICALL
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_releaseWeightSession(
-//        JNIEnv *env, jobject,
-//jlong weight_session) {
-//ReleaseWeightSession(weight_session);
-//}
-
-//
-//extern "C" JNIEXPORT jlong JNICALL
-///**
-// * Caches the trainable layer weights from training session for later use. Releases the training session.
-// *
-// * @param env
-// * @param inference_model_path
-// * @return
-// */
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_cacheSessionWeights(
-//        JNIEnv *env, jobject /* this */,
-//        jlong train_session,
-//        jobjectArray requires_grad
-//) {
-//
-//    auto *train_session_cache = reinterpret_cast<TrainingSessionCache *>(train_session);
-//
-//    // Get the size of the input array
-//    jsize arrayLength = env->GetArrayLength(requires_grad);
-//
-//    std::vector<std::string> requires_grad_names;
-//    for (jsize i = 0; i < arrayLength; ++i) {
-//        auto jstr = (jstring) (env->GetObjectArrayElement(requires_grad, i));
-//        const char *cstr = env->GetStringUTFChars(jstr, nullptr);
-//        requires_grad_names.emplace_back(cstr);
-//
-//        // Release the string
-//        env->ReleaseStringUTFChars(jstr, cstr);
-//        env->DeleteLocalRef(jstr);
-//    }
-//
-//    std::unique_ptr<WeightSessionCache> weight_session_cache = std::make_unique<WeightSessionCache>();
-//
-//    // Load the extracted weights into the inference session
-//    LoadWeightsToMemory(weight_session_cache, train_session_cache->checkpoint_state, requires_grad_names);
-//
-//    // Release the current training session, save the checkpoints
-//    ReleaseTrainingSession(train_session, true);
-//    train_session_cache = nullptr;
-//
-//    return reinterpret_cast<long>(weight_session_cache.release());
-//}
-
-//extern "C" JNIEXPORT void JNICALL
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_releaseGenAISession(
-//        JNIEnv *env, jobject,
-//jlong genai_session) {
-//ReleaseGenAISession(genai_session);
-//}
-
-//void ReleaseGenAISession(jlong session) {
-//    auto *session_cache = reinterpret_cast<GenAISessionCache *>(session);
-//    //OgaDestroyGenerator(session_cache->generator.get());
-//    //OgaDestroyGeneratorParams(session_cache->generatorParams.get());
-//    //OgaDestroyModel(session_cache->model.get());
-//    //OgaDestroyTokenizer(session_cache->tokenizer.get());
-//    //OgaDestroyTokenizerStream(session_cache->tokenizer_stream.get());
-//    delete session_cache;
-//    session_cache = nullptr;
-//}
-
-//extern "C" JNIEXPORT jlong JNICALL
-///**
-// * Creates the GenAI session from the cached weights.
-// *
-// * @param env
-// * @param inference_model_path
-// * @return
-// */
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_createGenAISession(
-//        JNIEnv *env, jobject /* this */,
-//        jlong weight_cache,
-//        jstring genai_path
-//) {
-//
-//    auto *weight_session_cache = reinterpret_cast<WeightSessionCache *>(weight_cache);
-//
-//    __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Loading grad weight inputs...");
-//
-//    std::unique_ptr<GenAISessionCache> genai_session_cache = std::make_unique<GenAISessionCache>(
-//            weight_session_cache,
-//            utils::JString2String(env, genai_path)
-//    );
-//    __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "Preloaded grad weight inputs.");
-//
-//    return reinterpret_cast<long>(genai_session_cache.release());
-//}
-
-//extern "C"
-//JNIEXPORT void JNICALL
-///**
-// * Initializes the GenAI inference with a new prompt.
-// * Uses KV caching and generation configuration provided from the file.
-// *
-// * @param env
-// * @param thiz
-// * @param genai_session - GenAI cached session
-// * @param prompt - New prompt
-// */
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_initializeGenAIInference(JNIEnv *env, jobject thiz,
-//        jlong genai_session, jstring prompt) {
-//auto *session_cache = reinterpret_cast<GenAISessionCache *>(genai_session);
-//
-//auto sequences = OgaSequences::Create();
-//session_cache->tokenizer->Encode(utils::JString2String(env, prompt).c_str(), *sequences);
-//session_cache->generatorParams->SetInputSequences(*sequences);
-//session_cache->generator = OgaGenerator::Create(*session_cache->model, *session_cache->generatorParams);
-//}
-//
-//
-//extern "C"
-//JNIEXPORT jstring JNICALL
-///**
-// * Performs the inference step using the exported model for GenAI inference.
-// *
-// * @param env
-// * @param thiz
-// * @param session
-// * @param input_ids
-// * @param attention_mask
-// * @param position_ids
-// * @param sequence_length
-// * @param vocab_size
-// *
-// * @return Next token string
-// */
-//Java_com_martinkorelic_ortmobile_ORTGenAINative_performGenAIInferenceStep(JNIEnv *env, jobject thiz,
-//jlong genai_session) {
-//auto *session_cache = reinterpret_cast<GenAISessionCache *>(genai_session);
-//
-//if (session_cache->generator->IsDone()) {
-//// TODO : Release generator after each session?
-////OgaDestroyGenerator(session_cache->generator.get());
-//return env->NewStringUTF("[STOP]");
-//}
-//
-//auto next_token = inference::genAiInferenceStep(session_cache);
-//
-//return env->NewStringUTF(next_token.c_str());
-//}
-
-
-//struct GenAISessionCache {
-//    std::unique_ptr<OgaModel> model;
-//    std::unique_ptr<OgaGenerator> generator;
-//    std::unique_ptr<OgaGeneratorParams> generatorParams;
-//    std::unique_ptr<OgaTokenizer> tokenizer;
-//    std::unique_ptr<OgaTokenizerStream> tokenizer_stream;
-//
-//    GenAISessionCache(WeightSessionCache *weight_cache,
-//                      const std::string &genai_folder_path) {
-//        model = OgaModel::Create(genai_folder_path.c_str());
-//        generatorParams = OgaGeneratorParams::Create(*model);
-//
-//        std::string text = "Hello, this is a message for the world. How is your day?";
-//        auto sequences = OgaSequences::Create();
-//
-//        tokenizer = std::unique_ptr<OgaTokenizer>(OgaTokenizer::Create(*model));
-//        tokenizer_stream = std::unique_ptr<OgaTokenizerStream>(OgaTokenizerStream::Create(*tokenizer));
-//
-//        tokenizer->Encode(text.c_str(), *sequences);
-//        generatorParams->SetInputSequences(*sequences);
-//
-//        generator = OgaGenerator::Create(*model, *generatorParams);
-//    }
-//};
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai.h
deleted file mode 100644
index 4a83b69..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai.h
+++ /dev/null
@@ -1,359 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <memory>
-#include <stdexcept>
-#include <vector>
-
-#if __cplusplus >= 202002L
-#include <span>
-#endif
-
-#include "ort_genai_c.h"
-
-// GenAI C++ API
-//
-// This is a zero cost wrapper around the C API, and provides for a set of C++ classes with automatic resource management
-
-/* A simple end to end example of how to generate an answer from a prompt:
- *
- * auto model = OgaModel::Create("phi-2");
- * auto tokenizer = OgaTokenizer::Create(*model);
- *
- * auto sequences = OgaSequences::Create();
- * tokenizer->Encode("A great recipe for Kung Pao chicken is ", *sequences);
- *
- * auto params = OgaGeneratorParams::Create(*model);
- * params->SetInputSequences(*sequences);
- * params->SetSearchOption("max_length", 200);
- *
- * auto output_sequences = model->Generate(*params);
- * auto out_string = tokenizer->Decode(output_sequences->Get(0));
- *
- * std::cout << "Output: " << std::endl << out_string << std::endl;
- */
-
-// The types defined in this file are to give us zero overhead C++ style interfaces around an opaque C pointer.
-// For example, there is no actual 'OgaModel' type defined anywhere, so we create a fake definition here
-// that lets users have a C++ style OgaModel type that can be held in a std::unique_ptr.
-//
-// This OgaAbstract struct is to prevent accidentally trying to use them by value.
-struct OgaAbstract {
-  OgaAbstract() = delete;
-  OgaAbstract(const OgaAbstract&) = delete;
-  void operator=(const OgaAbstract&) = delete;
-};
-
-struct OgaResult : OgaAbstract {
-  const char* GetError() const { return OgaResultGetError(this); }
-  static void operator delete(void* p) { OgaDestroyResult(reinterpret_cast<OgaResult*>(p)); }
-};
-
-// This is used to turn OgaResult return values from the C API into std::runtime_error exceptions
-inline void OgaCheckResult(OgaResult* result) {
-  if (result) {
-    std::unique_ptr<OgaResult> p_result{result};  // Take ownership so it's destroyed properly
-    throw std::runtime_error(p_result->GetError());
-  }
-}
-
-struct OgaModel : OgaAbstract {
-  static std::unique_ptr<OgaModel> Create(const char* config_path) {
-    OgaModel* p;
-    OgaCheckResult(OgaCreateModel(config_path, &p));
-    return std::unique_ptr<OgaModel>(p);
-  }
-
-  std::unique_ptr<OgaSequences> Generate(const OgaGeneratorParams& params) const {
-    OgaSequences* p;
-    OgaCheckResult(OgaGenerate(this, &params, &p));
-    return std::unique_ptr<OgaSequences>(p);
-  }
-
-  static void operator delete(void* p) { OgaDestroyModel(reinterpret_cast<OgaModel*>(p)); }
-};
-
-struct OgaString {
-  OgaString(const char* p) : p_{p} {}
-  ~OgaString() { OgaDestroyString(p_); }
-
-  operator const char*() const { return p_; }
-
-  const char* p_;
-};
-
-struct OgaSequences : OgaAbstract {
-  static std::unique_ptr<OgaSequences> Create() {
-    OgaSequences* p;
-    OgaCheckResult(OgaCreateSequences(&p));
-    return std::unique_ptr<OgaSequences>(p);
-  }
-
-  size_t Count() const {
-    return OgaSequencesCount(this);
-  }
-
-  size_t SequenceCount(size_t index) const {
-    return OgaSequencesGetSequenceCount(this, index);
-  }
-
-  const int32_t* SequenceData(size_t index) const {
-    return OgaSequencesGetSequenceData(this, index);
-  }
-
-#if __cplusplus >= 202002L
-  std::span<const int32_t> Get(size_t index) const {
-    return {SequenceData(index), SequenceCount(index)};
-  }
-#endif
-
-  static void operator delete(void* p) { OgaDestroySequences(reinterpret_cast<OgaSequences*>(p)); }
-};
-
-struct OgaTokenizer : OgaAbstract {
-  static std::unique_ptr<OgaTokenizer> Create(const OgaModel& model) {
-    OgaTokenizer* p;
-    OgaCheckResult(OgaCreateTokenizer(&model, &p));
-    return std::unique_ptr<OgaTokenizer>(p);
-  }
-
-  void Encode(const char* str, OgaSequences& sequences) const {
-    OgaCheckResult(OgaTokenizerEncode(this, str, &sequences));
-  }
-
-  OgaString Decode(const int32_t* tokens_data, size_t tokens_length) const {
-    const char* p;
-    OgaCheckResult(OgaTokenizerDecode(this, tokens_data, tokens_length, &p));
-    return p;
-  }
-
-#if __cplusplus >= 202002L
-  OgaString Decode(std::span<const int32_t> tokens) const {
-    const char* p;
-    OgaCheckResult(OgaTokenizerDecode(this, tokens.data(), tokens.size(), &p));
-    return p;
-  }
-#endif
-
-  static void operator delete(void* p) { OgaDestroyTokenizer(reinterpret_cast<OgaTokenizer*>(p)); }
-};
-
-struct OgaTokenizerStream : OgaAbstract {
-  static std::unique_ptr<OgaTokenizerStream> Create(const OgaTokenizer& tokenizer) {
-    OgaTokenizerStream* p;
-    OgaCheckResult(OgaCreateTokenizerStream(&tokenizer, &p));
-    return std::unique_ptr<OgaTokenizerStream>(p);
-  }
-
-  static std::unique_ptr<OgaTokenizerStream> Create(const OgaMultiModalProcessor& processor) {
-    OgaTokenizerStream* p;
-    OgaCheckResult(OgaCreateTokenizerStreamFromProcessor(&processor, &p));
-    return std::unique_ptr<OgaTokenizerStream>(p);
-  }
-
-  /*
-   * Decode a single token in the stream. If this results in a word being generated, it will be returned in 'out'.
-   * The caller is responsible for concatenating each chunk together to generate the complete result.
-   * 'out' is valid until the next call to OgaTokenizerStreamDecode or when the OgaTokenizerStream is destroyed
-   */
-  const char* Decode(int32_t token) {
-    const char* out;
-    OgaCheckResult(OgaTokenizerStreamDecode(this, token, &out));
-    return out;
-  }
-
-  static void operator delete(void* p) { OgaDestroyTokenizerStream(reinterpret_cast<OgaTokenizerStream*>(p)); }
-};
-
-struct OgaGeneratorParams : OgaAbstract {
-  static std::unique_ptr<OgaGeneratorParams> Create(const OgaModel& model) {
-    OgaGeneratorParams* p;
-    OgaCheckResult(OgaCreateGeneratorParams(&model, &p));
-    return std::unique_ptr<OgaGeneratorParams>(p);
-  }
-
-  void SetSearchOption(const char* name, double value) {
-    OgaCheckResult(OgaGeneratorParamsSetSearchNumber(this, name, value));
-  }
-
-  void SetSearchOptionBool(const char* name, bool value) {
-    OgaCheckResult(OgaGeneratorParamsSetSearchBool(this, name, value));
-  }
-
-  void SetInputIDs(const int32_t* input_ids, size_t input_ids_count, size_t sequence_length, size_t batch_size) {
-    OgaCheckResult(OgaGeneratorParamsSetInputIDs(this, input_ids, input_ids_count, sequence_length, batch_size));
-  }
-
-  void SetInputSequences(const OgaSequences& sequences) {
-    OgaCheckResult(OgaGeneratorParamsSetInputSequences(this, &sequences));
-  }
-
-  void SetModelInput(const char* name, OgaTensor& tensor) {
-    OgaCheckResult(OgaGeneratorParamsSetModelInput(this, name, &tensor));
-  }
-
-  void SetInputs(OgaNamedTensors& named_tensors) {
-    OgaCheckResult(OgaGeneratorParamsSetInputs(this, &named_tensors));
-  }
-
-  void TryGraphCaptureWithMaxBatchSize(int max_batch_size) {
-    OgaCheckResult(OgaGeneratorParamsTryGraphCaptureWithMaxBatchSize(this, max_batch_size));
-  }
-
-  static void operator delete(void* p) { OgaDestroyGeneratorParams(reinterpret_cast<OgaGeneratorParams*>(p)); }
-};
-
-struct OgaGenerator : OgaAbstract {
-  static std::unique_ptr<OgaGenerator> Create(const OgaModel& model, const OgaGeneratorParams& params) {
-    OgaGenerator* p;
-    OgaCheckResult(OgaCreateGenerator(&model, &params, &p));
-    return std::unique_ptr<OgaGenerator>(p);
-  }
-
-  bool IsDone() const {
-    return OgaGenerator_IsDone(this);
-  }
-
-  void ComputeLogits() {
-    OgaCheckResult(OgaGenerator_ComputeLogits(this));
-  }
-
-  void GenerateNextToken() {
-    OgaCheckResult(OgaGenerator_GenerateNextToken(this));
-  }
-
-  size_t GetSequenceCount(size_t index) const {
-    return OgaGenerator_GetSequenceCount(this, index);
-  }
-
-  const int32_t* GetSequenceData(size_t index) const {
-    return OgaGenerator_GetSequenceData(this, index);
-  }
-
-  std::unique_ptr<OgaTensor> GetOutput(const char* name) {
-    OgaTensor* out;
-    OgaCheckResult(OgaGenerator_GetOutput(this, name, &out));
-    return std::unique_ptr<OgaTensor>(out);
-  }
-
-#if __cplusplus >= 202002L
-  std::span<const int32_t> GetSequence(size_t index) const {
-    return {GetSequenceData(index), GetSequenceCount(index)};
-  }
-#endif
-
-  static void operator delete(void* p) { OgaDestroyGenerator(reinterpret_cast<OgaGenerator*>(p)); }
-};
-
-struct OgaTensor : OgaAbstract {
-#if __cplusplus >= 202002L
-  static std::unique_ptr<OgaTensor> Create(void* data, std::span<const int64_t> shape, OgaElementType element_type) {
-    OgaTensor* p;
-    OgaCheckResult(OgaCreateTensorFromBuffer(data, shape.data(), shape.size(), element_type, &p));
-    return std::unique_ptr<OgaTensor>(p);
-  }
-#endif
-  static std::unique_ptr<OgaTensor> Create(void* data, const int64_t* shape_dims, size_t shape_dims_count, OgaElementType element_type) {
-    OgaTensor* p;
-    OgaCheckResult(OgaCreateTensorFromBuffer(data, shape_dims, shape_dims_count, element_type, &p));
-    return std::unique_ptr<OgaTensor>(p);
-  }
-
-  OgaElementType Type() {
-    OgaElementType type;
-    OgaCheckResult(OgaTensorGetType(this, &type));
-    return type;
-  }
-
-  std::vector<int64_t> Shape() {
-    size_t size;
-    OgaCheckResult(OgaTensorGetShapeRank(this, &size));
-    std::vector<int64_t> shape(size);
-    OgaCheckResult(OgaTensorGetShape(this, shape.data(), shape.size()));
-    return shape;
-  }
-
-  void* Data() {
-    void* data;
-    OgaCheckResult(OgaTensorGetData(this, &data));
-    return data;
-  }
-
-  static void operator delete(void* p) { OgaDestroyTensor(reinterpret_cast<OgaTensor*>(p)); }
-};
-
-struct OgaImages : OgaAbstract {
-  static std::unique_ptr<OgaImages> Load(const char* image_path) {
-    OgaImages* p;
-    OgaCheckResult(OgaLoadImage(image_path, &p));
-    return std::unique_ptr<OgaImages>(p);
-  }
-
-  static void operator delete(void* p) { OgaDestroyImages(reinterpret_cast<OgaImages*>(p)); }
-};
-
-struct OgaNamedTensors : OgaAbstract {
-  static void operator delete(void* p) { OgaDestroyNamedTensors(reinterpret_cast<OgaNamedTensors*>(p)); }
-};
-
-struct OgaMultiModalProcessor : OgaAbstract {
-  static std::unique_ptr<OgaMultiModalProcessor> Create(const OgaModel& model) {
-    OgaMultiModalProcessor* p;
-    OgaCheckResult(OgaCreateMultiModalProcessor(&model, &p));
-    return std::unique_ptr<OgaMultiModalProcessor>(p);
-  }
-
-  std::unique_ptr<OgaNamedTensors> ProcessImages(const char* str, const OgaImages* images = nullptr) const {
-    OgaNamedTensors* p;
-    OgaCheckResult(OgaProcessorProcessImages(this, str, images, &p));
-    return std::unique_ptr<OgaNamedTensors>(p);
-  }
-
-  OgaString Decode(const int32_t* tokens_data, size_t tokens_length) const {
-    const char* p;
-    OgaCheckResult(OgaProcessorDecode(this, tokens_data, tokens_length, &p));
-    return p;
-  }
-
-#if __cplusplus >= 202002L
-  OgaString Decode(std::span<const int32_t> tokens) const {
-    const char* p;
-    OgaCheckResult(OgaProcessorDecode(this, tokens.data(), tokens.size(), &p));
-    return p;
-  }
-#endif
-
-  static void operator delete(void* p) { OgaDestroyMultiModalProcessor(reinterpret_cast<OgaMultiModalProcessor*>(p)); }
-};
-
-struct OgaHandle {
-  OgaHandle() = default;
-  ~OgaHandle() noexcept {
-    OgaShutdown();
-  }
-};
-
-// Global Oga functions
-namespace Oga {
-
-inline void SetLogBool(const char* name, bool value) {
-  OgaCheckResult(OgaSetLogBool(name, value));
-}
-
-inline void SetLogString(const char* name, const char* value) {
-  OgaCheckResult(OgaSetLogString(name, value));
-}
-
-inline void SetCurrentGpuDeviceId(int device_id) {
-  OgaCheckResult(OgaSetCurrentGpuDeviceId(device_id));
-}
-
-inline int GetCurrentGpuDeviceId() {
-  int device_id;
-  OgaCheckResult(OgaGetCurrentGpuDeviceId(&device_id));
-  return device_id;
-}
-
-}  // namespace Oga
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai_c.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai_c.h
deleted file mode 100644
index 16b9875..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/onnxruntime-genai/ort_genai_c.h
+++ /dev/null
@@ -1,319 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <stdint.h>
-#include <cstddef>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef _WIN32
-#ifdef BUILDING_ORT_GENAI_C
-#define OGA_EXPORT __declspec(dllexport)
-#else
-#define OGA_EXPORT __declspec(dllimport)
-#endif
-#define OGA_API_CALL _stdcall
-#else
-// To make symbols visible on macOS/iOS
-#ifdef __APPLE__
-#define OGA_EXPORT __attribute__((visibility("default")))
-#else
-#define OGA_EXPORT
-#endif
-#define OGA_API_CALL
-#endif
-
-// ONNX Runtime Generative AI C API
-// This API is not thread safe.
-
-typedef enum OgaElementType {
-  OgaElementType_undefined,
-  OgaElementType_float32,  // maps to c type float
-  OgaElementType_uint8,    // maps to c type uint8_t
-  OgaElementType_int8,     // maps to c type int8_t
-  OgaElementType_uint16,   // maps to c type uint16_t
-  OgaElementType_int16,    // maps to c type int16_t
-  OgaElementType_int32,    // maps to c type int32_t
-  OgaElementType_int64,    // maps to c type int64_t
-  OgaElementType_string,   // string type (not currently supported by Oga)
-  OgaElementType_bool,     // maps to c type bool
-  OgaElementType_float16,  // IEEE 752-2008 binary16 format, 1 sign bit, 5 bit exponent, 10 bit fraction
-  OgaElementType_float64,  // maps to c type double
-  OgaElementType_uint32,   // maps to c type uint32_t
-  OgaElementType_uint64,   // maps to c type uint64_t
-} OgaElementType;
-
-typedef struct OgaResult OgaResult;
-typedef struct OgaGeneratorParams OgaGeneratorParams;
-typedef struct OgaGenerator OgaGenerator;
-typedef struct OgaModel OgaModel;
-// OgaSequences is an array of token arrays where the number of token arrays can be obtained using
-// OgaSequencesCount and the number of tokens in each token array can be obtained using OgaSequencesGetSequenceCount.
-typedef struct OgaSequences OgaSequences;
-typedef struct OgaTokenizer OgaTokenizer;
-typedef struct OgaTokenizerStream OgaTokenizerStream;
-typedef struct OgaTensor OgaTensor;
-typedef struct OgaImages OgaImages;
-typedef struct OgaNamedTensors OgaNamedTensors;
-typedef struct OgaMultiModalProcessor OgaMultiModalProcessor;
-
-/* \brief Call this on process exit to cleanly shutdown the genai library & its onnxruntime usage
- */
-OGA_EXPORT void OGA_API_CALL OgaShutdown();
-
-/*
- * \param[in] result OgaResult that contains the error message.
- * \return Error message contained in the OgaResult. The const char* is owned by the OgaResult
- *         and can will be freed when the OgaResult is destroyed.
- */
-OGA_EXPORT const char* OGA_API_CALL OgaResultGetError(const OgaResult* result);
-
-/*
- * \param[in] Set logging options, see logging.h 'struct LogItems' for the list of available options
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaSetLogBool(const char* name, bool value);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaSetLogString(const char* name, const char* value);
-
-/*
- * \param[in] result OgaResult to be destroyed.
- */
-OGA_EXPORT void OGA_API_CALL OgaDestroyResult(OgaResult*);
-OGA_EXPORT void OGA_API_CALL OgaDestroyString(const char*);
-OGA_EXPORT void OGA_API_CALL OgaDestroyNamedTensors(OgaNamedTensors*);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateSequences(OgaSequences** out);
-
-/*
- * \param[in] sequences OgaSequences to be destroyed.
- */
-OGA_EXPORT void OGA_API_CALL OgaDestroySequences(OgaSequences* sequences);
-
-/*
- * \brief Returns the number of sequences in the OgaSequences
- * \param[in] sequences
- * \return The number of sequences in the OgaSequences
- */
-OGA_EXPORT size_t OGA_API_CALL OgaSequencesCount(const OgaSequences* sequences);
-
-/*
- * \brief Returns the number of tokens in the sequence at the given index
- * \param[in] sequences
- * \return The number of tokens in the sequence at the given index
- */
-OGA_EXPORT size_t OGA_API_CALL OgaSequencesGetSequenceCount(const OgaSequences* sequences, size_t sequence_index);
-
-/*
- * \brief Returns a pointer to the sequence data at the given index. The number of tokens in the sequence
- *        is given by OgaSequencesGetSequenceCount
- * \param[in] sequences
- * \return The pointer to the sequence data at the given index. The pointer is valid until the OgaSequences is destroyed.
- */
-OGA_EXPORT const int32_t* OGA_API_CALL OgaSequencesGetSequenceData(const OgaSequences* sequences, size_t sequence_index);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaLoadImage(const char* image_path, OgaImages** images);
-
-OGA_EXPORT void OGA_API_CALL OgaDestroyImages(OgaImages* images);
-
-/*
- * \brief Creates a model from the given configuration directory and device type.
- * \param[in] config_path The path to the model configuration directory. The path is expected to be encoded in UTF-8.
- * \param[in] device_type The device type to use for the model.
- * \param[out] out The created model.
- * \return OgaResult containing the error message if the model creation failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateModel(const char* config_path, OgaModel** out);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateModelWithInitializers(const char* config_path, OgaModel** out, const std::unordered_map<std::string, OrtValue>& initializers);
-
-/*
- * \brief Destroys the given model.
- * \param[in] model The model to be destroyed.
- */
-OGA_EXPORT void OGA_API_CALL OgaDestroyModel(OgaModel* model);
-
-/*
- * \brief Generates an array of token arrays from the model execution based on the given generator params.
- * \param[in] model The model to use for generation.
- * \param[in] generator_params The parameters to use for generation.
- * \param[out] out The generated sequences of tokens. The caller is responsible for freeing the sequences using OgaDestroySequences
- *             after it is done using the sequences.
- * \return OgaResult containing the error message if the generation failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerate(const OgaModel* model, const OgaGeneratorParams* generator_params, OgaSequences** out);
-
-/*
- * \brief Creates a OgaGeneratorParams from the given model.
- * \param[in] model The model to use for generation.
- * \param[out] out The created generator params.
- * \return OgaResult containing the error message if the generator params creation failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateGeneratorParams(const OgaModel* model, OgaGeneratorParams** out);
-
-/*
- * \brief Destroys the given generator params.
- * \param[in] generator_params The generator params to be destroyed.
- */
-OGA_EXPORT void OGA_API_CALL OgaDestroyGeneratorParams(OgaGeneratorParams* generator_params);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetSearchNumber(OgaGeneratorParams* generator_params, const char* name, double value);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetSearchBool(OgaGeneratorParams* generator_params, const char* name, bool value);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsTryGraphCaptureWithMaxBatchSize(OgaGeneratorParams* generator_params, int32_t max_batch_size);
-
-/*
- * \brief Sets the input ids for the generator params. The input ids are used to seed the generation.
- * \param[in] generator_params The generator params to set the input ids on.
- * \param[in] input_ids The input ids array of size input_ids_count = batch_size * sequence_length.
- * \param[in] input_ids_count The total number of input ids.
- * \param[in] sequence_length The sequence length of the input ids.
- * \param[in] batch_size The batch size of the input ids.
- * \return OgaResult containing the error message if the setting of the input ids failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetInputIDs(OgaGeneratorParams* generator_params, const int32_t* input_ids,
-                                                                 size_t input_ids_count, size_t sequence_length, size_t batch_size);
-
-/*
- * \brief Sets the input id sequences for the generator params. The input id sequences are used to seed the generation.
- * \param[in] generator_params The generator params to set the input ids on.
- * \param[in] sequences The input id sequences.
- * \return OgaResult containing the error message if the setting of the input id sequences failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetInputSequences(OgaGeneratorParams* generator_params, const OgaSequences* sequences);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetInputs(OgaGeneratorParams* generator_params, const OgaNamedTensors* named_tensors);
-
-/*
- * \brief For additional model inputs that genai does not handle, this lets the user set their values. For example LoRA models handle
- * fine tuning through model inputs. This lets the user supply the fine tuning inputs, while genai handles the standard inputs.
- * \param[in] generator_params The generator params to set the input on
- * \param[in] name Name of the model input (this must match the model's input name)
- * \param[in] tensor The OgaTensor of the input data
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetModelInput(OgaGeneratorParams* generator_params, const char* name, OgaTensor* tensor);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGeneratorParamsSetWhisperInputFeatures(OgaGeneratorParams*, OgaTensor* tensor);
-
-/*
- * \brief Creates a generator from the given model and generator params.
- * \param[in] model The model to use for generation.
- * \param[in] params The parameters to use for generation.
- * \param[out] out The created generator.
- * \return OgaResult containing the error message if the generator creation failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateGenerator(const OgaModel* model, const OgaGeneratorParams* params, OgaGenerator** out);
-
-/*
- * \brief Destroys the given generator.
- * \param[in] generator The generator to be destroyed.
- */
-OGA_EXPORT void OGA_API_CALL OgaDestroyGenerator(OgaGenerator* generator);
-
-/*
- * \brief Returns true if the generator has finished generating all the sequences.
- * \param[in] generator The generator to check if it is done with generating all sequences.
- * \return True if the generator has finished generating all the sequences, false otherwise.
- */
-OGA_EXPORT bool OGA_API_CALL OgaGenerator_IsDone(const OgaGenerator* generator);
-
-/*
- * \brief Computes the logits from the model based on the input ids and the past state. The computed logits are stored in the generator.
- * \param[in] generator The generator to compute the logits for.
- * \return OgaResult containing the error message if the computation of the logits failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_ComputeLogits(OgaGenerator* generator);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GenerateNextToken(OgaGenerator* generator);
-
-/*
- * \brief Returns a copy of the model output identified by the given name as an OgaTensor on CPU. The buffer is owned by returned OgaTensor
- *       and will be released when the OgaTensor is destroyed
- * \param[in] generator The generator to run the GetOutput on the name provided and the out pointer to store the output
- * \return OgaResult containing the error message if the computation failed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGenerator_GetOutput(const OgaGenerator* oga_generator, const char* name, OgaTensor** out);
-
-/*
- * \brief Returns the number of tokens in the sequence at the given index.
- * \param[in] generator The generator to get the count of the tokens for the sequence at the given index.
- * \return The number tokens in the sequence at the given index.
- */
-OGA_EXPORT size_t OGA_API_CALL OgaGenerator_GetSequenceCount(const OgaGenerator* generator, size_t index);
-
-/*
- * \brief Returns a pointer to the sequence data at the given index. The number of tokens in the sequence
- *        is given by OgaGenerator_GetSequenceCount
- * \param[in] generator The generator to get the sequence data for the sequence at the given index.
- * \return The pointer to the sequence data at the given index. The sequence data is owned by the OgaGenerator
- *         and will be freed when the OgaGenerator is destroyed. The caller must copy the data if it needs to
- *         be used after the OgaGenerator is destroyed.
- */
-OGA_EXPORT const int32_t* OGA_API_CALL OgaGenerator_GetSequenceData(const OgaGenerator* generator, size_t index);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizer(const OgaModel* model, OgaTokenizer** out);
-OGA_EXPORT void OGA_API_CALL OgaDestroyTokenizer(OgaTokenizer*);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateMultiModalProcessor(const OgaModel* model, OgaMultiModalProcessor** out);
-
-OGA_EXPORT void OGA_API_CALL OgaDestroyMultiModalProcessor(OgaMultiModalProcessor* processor);
-
-/* Encodes a single string and adds the encoded sequence of tokens to the OgaSequences. The OgaSequences must be freed with OgaDestroySequences
-   when it is no longer needed.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerEncode(const OgaTokenizer*, const char* str, OgaSequences* sequences);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorProcessImages(const OgaMultiModalProcessor*, const char* prompt, const OgaImages* images, OgaNamedTensors** input_tensors);
-
-/* Decode a single token sequence and returns a null terminated utf8 string. out_string must be freed with OgaDestroyString
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerDecode(const OgaTokenizer*, const int32_t* tokens, size_t token_count, const char** out_string);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaProcessorDecode(const OgaMultiModalProcessor*, const int32_t* tokens, size_t token_count, const char** out_string);
-
-/* OgaTokenizerStream is to decoded token strings incrementally, one token at a time.
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizerStream(const OgaTokenizer*, OgaTokenizerStream** out);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTokenizerStreamFromProcessor(const OgaMultiModalProcessor*, OgaTokenizerStream** out);
-OGA_EXPORT void OGA_API_CALL OgaDestroyTokenizerStream(OgaTokenizerStream*);
-
-/*
- * Decode a single token in the stream. If this results in a word being generated, it will be returned in 'out'.
- * The caller is responsible for concatenating each chunk together to generate the complete result.
- * 'out' is valid until the next call to OgaTokenizerStreamDecode or when the OgaTokenizerStream is destroyed
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTokenizerStreamDecode(OgaTokenizerStream*, int32_t token, const char** out);
-
-/* Create an OgaTensor from a user owned buffer. The OgaTensor does not own the memory (as it has no way to free it) so
- * the 'data' parameter must be valid for the lifetime of the OgaTensor.
- *
- * \param[in] data User supplied memory pointer, must remain valid for lifetime of the OgaTensor
- * \param[in] shape_dims Pointer to array of int64_t values that define the tensor shape, example [1 20 30] would be equivalent to a C array of [1][20][30]
- * \param[in] shape_dims_count Count of elements in the shape_dims array
- * \param[in] element_type The data type that 'data' points to.
- * \param[out] out Writes the newly created OgaTensor into this, must be destroyed with OgaDestroyTensor
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaCreateTensorFromBuffer(void* data, const int64_t* shape_dims, size_t shape_dims_count, OgaElementType element_type, OgaTensor** out);
-OGA_EXPORT void OGA_API_CALL OgaDestroyTensor(OgaTensor* tensor);
-
-/* Get the OgaElementType of the data stored in the OgaTensor
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetType(OgaTensor*, OgaElementType* out);
-
-/* Get the number of dimensions of the OgaTensor's shape, typically used to allocate a buffer of this size then calling OgaTensorGetShape with it
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetShapeRank(OgaTensor*, size_t* out);
-
-/* Copies the shape dimensions into the shape_dims parameters. shape_dims_count must match the value returned by OgaTensorGetShapeRank
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetShape(OgaTensor*, int64_t* shape_dims, size_t shape_dims_count);
-
-/* A pointer to the tensor data, it is typically cast into the actual data type of the tensor
- */
-OGA_EXPORT OgaResult* OGA_API_CALL OgaTensorGetData(OgaTensor*, void** out);
-
-OGA_EXPORT OgaResult* OGA_API_CALL OgaSetCurrentGpuDeviceId(int device_id);
-OGA_EXPORT OgaResult* OGA_API_CALL OgaGetCurrentGpuDeviceId(int* device_id);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.cc b/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.cc
deleted file mode 100644
index 18d29d4..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.cc
+++ /dev/null
@@ -1,10556 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: onnx.proto
-
-#include "onnx.pb.h"
-
-#include <algorithm>
-
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/wire_format_lite.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_AttributeProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeviceConfigurationProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_FunctionProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IntIntListEntryProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NodeDeviceConfigurationProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_OperatorSetIdProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ShardedDimProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ShardingSpecProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleShardedDimProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SparseTensorProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringStringEntryProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorAnnotation_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TensorProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorProto_Segment_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorShapeProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorShapeProto_Dimension_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TrainingInfoProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TypeProto_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_SparseTensor_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_Tensor_onnx_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ValueInfoProto_onnx_2eproto;
-namespace onnx {
-class AttributeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AttributeProto> _instance;
-} _AttributeProto_default_instance_;
-class ValueInfoProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ValueInfoProto> _instance;
-} _ValueInfoProto_default_instance_;
-class NodeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NodeProto> _instance;
-} _NodeProto_default_instance_;
-class IntIntListEntryProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<IntIntListEntryProto> _instance;
-} _IntIntListEntryProto_default_instance_;
-class NodeDeviceConfigurationProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NodeDeviceConfigurationProto> _instance;
-} _NodeDeviceConfigurationProto_default_instance_;
-class ShardingSpecProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ShardingSpecProto> _instance;
-} _ShardingSpecProto_default_instance_;
-class ShardedDimProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ShardedDimProto> _instance;
-} _ShardedDimProto_default_instance_;
-class SimpleShardedDimProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SimpleShardedDimProto> _instance;
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-} _SimpleShardedDimProto_default_instance_;
-class TrainingInfoProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TrainingInfoProto> _instance;
-} _TrainingInfoProto_default_instance_;
-class ModelProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ModelProto> _instance;
-} _ModelProto_default_instance_;
-class DeviceConfigurationProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DeviceConfigurationProto> _instance;
-} _DeviceConfigurationProto_default_instance_;
-class StringStringEntryProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StringStringEntryProto> _instance;
-} _StringStringEntryProto_default_instance_;
-class TensorAnnotationDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorAnnotation> _instance;
-} _TensorAnnotation_default_instance_;
-class GraphProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GraphProto> _instance;
-} _GraphProto_default_instance_;
-class TensorProto_SegmentDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorProto_Segment> _instance;
-} _TensorProto_Segment_default_instance_;
-class TensorProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorProto> _instance;
-} _TensorProto_default_instance_;
-class SparseTensorProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SparseTensorProto> _instance;
-} _SparseTensorProto_default_instance_;
-class TensorShapeProto_DimensionDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorShapeProto_Dimension> _instance;
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-} _TensorShapeProto_Dimension_default_instance_;
-class TensorShapeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorShapeProto> _instance;
-} _TensorShapeProto_default_instance_;
-class TypeProto_TensorDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Tensor> _instance;
-} _TypeProto_Tensor_default_instance_;
-class TypeProto_SequenceDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Sequence> _instance;
-} _TypeProto_Sequence_default_instance_;
-class TypeProto_MapDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Map> _instance;
-} _TypeProto_Map_default_instance_;
-class TypeProto_OptionalDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Optional> _instance;
-} _TypeProto_Optional_default_instance_;
-class TypeProto_SparseTensorDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_SparseTensor> _instance;
-} _TypeProto_SparseTensor_default_instance_;
-class TypeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto> _instance;
-  const ::onnx::TypeProto_Tensor* tensor_type_;
-  const ::onnx::TypeProto_Sequence* sequence_type_;
-  const ::onnx::TypeProto_Map* map_type_;
-  const ::onnx::TypeProto_Optional* optional_type_;
-  const ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
-} _TypeProto_default_instance_;
-class OperatorSetIdProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<OperatorSetIdProto> _instance;
-} _OperatorSetIdProto_default_instance_;
-class FunctionProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FunctionProto> _instance;
-} _FunctionProto_default_instance_;
-}  // namespace onnx
-static void InitDefaultsscc_info_AttributeProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_AttributeProto_default_instance_;
-    new (ptr) ::onnx::AttributeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_NodeProto_default_instance_;
-    new (ptr) ::onnx::NodeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_GraphProto_default_instance_;
-    new (ptr) ::onnx::GraphProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::AttributeProto::InitAsDefaultInstance();
-  ::onnx::NodeProto::InitAsDefaultInstance();
-  ::onnx::GraphProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_AttributeProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 7, 0, InitDefaultsscc_info_AttributeProto_onnx_2eproto}, {
-      &scc_info_TensorProto_onnx_2eproto.base,
-      &scc_info_SparseTensorProto_onnx_2eproto.base,
-      &scc_info_TypeProto_onnx_2eproto.base,
-      &scc_info_ValueInfoProto_onnx_2eproto.base,
-      &scc_info_TensorAnnotation_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,
-      &scc_info_NodeDeviceConfigurationProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_DeviceConfigurationProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_DeviceConfigurationProto_default_instance_;
-    new (ptr) ::onnx::DeviceConfigurationProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::DeviceConfigurationProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeviceConfigurationProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_DeviceConfigurationProto_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_FunctionProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_FunctionProto_default_instance_;
-    new (ptr) ::onnx::FunctionProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::FunctionProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_FunctionProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_FunctionProto_onnx_2eproto}, {
-      &scc_info_AttributeProto_onnx_2eproto.base,
-      &scc_info_OperatorSetIdProto_onnx_2eproto.base,
-      &scc_info_ValueInfoProto_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_IntIntListEntryProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_IntIntListEntryProto_default_instance_;
-    new (ptr) ::onnx::IntIntListEntryProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::IntIntListEntryProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IntIntListEntryProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_IntIntListEntryProto_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_ModelProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ModelProto_default_instance_;
-    new (ptr) ::onnx::ModelProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ModelProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<6> scc_info_ModelProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 6, 0, InitDefaultsscc_info_ModelProto_onnx_2eproto}, {
-      &scc_info_OperatorSetIdProto_onnx_2eproto.base,
-      &scc_info_AttributeProto_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,
-      &scc_info_TrainingInfoProto_onnx_2eproto.base,
-      &scc_info_FunctionProto_onnx_2eproto.base,
-      &scc_info_DeviceConfigurationProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_NodeDeviceConfigurationProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_NodeDeviceConfigurationProto_default_instance_;
-    new (ptr) ::onnx::NodeDeviceConfigurationProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::NodeDeviceConfigurationProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NodeDeviceConfigurationProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_NodeDeviceConfigurationProto_onnx_2eproto}, {
-      &scc_info_ShardingSpecProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_OperatorSetIdProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_OperatorSetIdProto_default_instance_;
-    new (ptr) ::onnx::OperatorSetIdProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::OperatorSetIdProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_OperatorSetIdProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_OperatorSetIdProto_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_ShardedDimProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ShardedDimProto_default_instance_;
-    new (ptr) ::onnx::ShardedDimProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ShardedDimProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ShardedDimProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ShardedDimProto_onnx_2eproto}, {
-      &scc_info_SimpleShardedDimProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_ShardingSpecProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ShardingSpecProto_default_instance_;
-    new (ptr) ::onnx::ShardingSpecProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ShardingSpecProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ShardingSpecProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ShardingSpecProto_onnx_2eproto}, {
-      &scc_info_IntIntListEntryProto_onnx_2eproto.base,
-      &scc_info_ShardedDimProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_SimpleShardedDimProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_SimpleShardedDimProto_default_instance_;
-    new (ptr) ::onnx::SimpleShardedDimProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::SimpleShardedDimProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleShardedDimProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SimpleShardedDimProto_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_SparseTensorProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_SparseTensorProto_default_instance_;
-    new (ptr) ::onnx::SparseTensorProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::SparseTensorProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SparseTensorProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_SparseTensorProto_onnx_2eproto}, {
-      &scc_info_TensorProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_StringStringEntryProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_StringStringEntryProto_default_instance_;
-    new (ptr) ::onnx::StringStringEntryProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::StringStringEntryProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringStringEntryProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StringStringEntryProto_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_TensorAnnotation_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorAnnotation_default_instance_;
-    new (ptr) ::onnx::TensorAnnotation();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorAnnotation::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorAnnotation_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TensorAnnotation_onnx_2eproto}, {
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TensorProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorProto_default_instance_;
-    new (ptr) ::onnx::TensorProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TensorProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TensorProto_onnx_2eproto}, {
-      &scc_info_TensorProto_Segment_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TensorProto_Segment_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorProto_Segment_default_instance_;
-    new (ptr) ::onnx::TensorProto_Segment();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorProto_Segment::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorProto_Segment_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TensorProto_Segment_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_TensorShapeProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorShapeProto_default_instance_;
-    new (ptr) ::onnx::TensorShapeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorShapeProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorShapeProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TensorShapeProto_onnx_2eproto}, {
-      &scc_info_TensorShapeProto_Dimension_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TensorShapeProto_Dimension_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorShapeProto_Dimension_default_instance_;
-    new (ptr) ::onnx::TensorShapeProto_Dimension();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorShapeProto_Dimension::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorShapeProto_Dimension_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TensorShapeProto_Dimension_onnx_2eproto}, {}};
-
-static void InitDefaultsscc_info_TrainingInfoProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TrainingInfoProto_default_instance_;
-    new (ptr) ::onnx::TrainingInfoProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TrainingInfoProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TrainingInfoProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TrainingInfoProto_onnx_2eproto}, {
-      &scc_info_AttributeProto_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TypeProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_Sequence_default_instance_;
-    new (ptr) ::onnx::TypeProto_Sequence();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_Map_default_instance_;
-    new (ptr) ::onnx::TypeProto_Map();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_Optional_default_instance_;
-    new (ptr) ::onnx::TypeProto_Optional();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_default_instance_;
-    new (ptr) ::onnx::TypeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_Sequence::InitAsDefaultInstance();
-  ::onnx::TypeProto_Map::InitAsDefaultInstance();
-  ::onnx::TypeProto_Optional::InitAsDefaultInstance();
-  ::onnx::TypeProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TypeProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TypeProto_onnx_2eproto}, {
-      &scc_info_TypeProto_Tensor_onnx_2eproto.base,
-      &scc_info_TypeProto_SparseTensor_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TypeProto_SparseTensor_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_SparseTensor_default_instance_;
-    new (ptr) ::onnx::TypeProto_SparseTensor();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_SparseTensor::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_SparseTensor_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TypeProto_SparseTensor_onnx_2eproto}, {
-      &scc_info_TensorShapeProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_TypeProto_Tensor_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_Tensor_default_instance_;
-    new (ptr) ::onnx::TypeProto_Tensor();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_Tensor::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_Tensor_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TypeProto_Tensor_onnx_2eproto}, {
-      &scc_info_TensorShapeProto_onnx_2eproto.base,}};
-
-static void InitDefaultsscc_info_ValueInfoProto_onnx_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ValueInfoProto_default_instance_;
-    new (ptr) ::onnx::ValueInfoProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ValueInfoProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ValueInfoProto_onnx_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ValueInfoProto_onnx_2eproto}, {
-      &scc_info_TypeProto_onnx_2eproto.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto.base,}};
-
-namespace onnx {
-bool AttributeProto_AttributeType_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-    case 13:
-    case 14:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AttributeProto_AttributeType_strings[15] = {};
-
-static const char AttributeProto_AttributeType_names[] =
-  "FLOAT"
-  "FLOATS"
-  "GRAPH"
-  "GRAPHS"
-  "INT"
-  "INTS"
-  "SPARSE_TENSOR"
-  "SPARSE_TENSORS"
-  "STRING"
-  "STRINGS"
-  "TENSOR"
-  "TENSORS"
-  "TYPE_PROTO"
-  "TYPE_PROTOS"
-  "UNDEFINED";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AttributeProto_AttributeType_entries[] = {
-  { {AttributeProto_AttributeType_names + 0, 5}, 1 },
-  { {AttributeProto_AttributeType_names + 5, 6}, 6 },
-  { {AttributeProto_AttributeType_names + 11, 5}, 5 },
-  { {AttributeProto_AttributeType_names + 16, 6}, 10 },
-  { {AttributeProto_AttributeType_names + 22, 3}, 2 },
-  { {AttributeProto_AttributeType_names + 25, 4}, 7 },
-  { {AttributeProto_AttributeType_names + 29, 13}, 11 },
-  { {AttributeProto_AttributeType_names + 42, 14}, 12 },
-  { {AttributeProto_AttributeType_names + 56, 6}, 3 },
-  { {AttributeProto_AttributeType_names + 62, 7}, 8 },
-  { {AttributeProto_AttributeType_names + 69, 6}, 4 },
-  { {AttributeProto_AttributeType_names + 75, 7}, 9 },
-  { {AttributeProto_AttributeType_names + 82, 10}, 13 },
-  { {AttributeProto_AttributeType_names + 92, 11}, 14 },
-  { {AttributeProto_AttributeType_names + 103, 9}, 0 },
-};
-
-static const int AttributeProto_AttributeType_entries_by_number[] = {
-  14, // 0 -> UNDEFINED
-  0, // 1 -> FLOAT
-  4, // 2 -> INT
-  8, // 3 -> STRING
-  10, // 4 -> TENSOR
-  2, // 5 -> GRAPH
-  1, // 6 -> FLOATS
-  5, // 7 -> INTS
-  9, // 8 -> STRINGS
-  11, // 9 -> TENSORS
-  3, // 10 -> GRAPHS
-  6, // 11 -> SPARSE_TENSOR
-  7, // 12 -> SPARSE_TENSORS
-  12, // 13 -> TYPE_PROTO
-  13, // 14 -> TYPE_PROTOS
-};
-
-const std::string& AttributeProto_AttributeType_Name(
-    AttributeProto_AttributeType value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          AttributeProto_AttributeType_entries,
-          AttributeProto_AttributeType_entries_by_number,
-          15, AttributeProto_AttributeType_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      AttributeProto_AttributeType_entries,
-      AttributeProto_AttributeType_entries_by_number,
-      15, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     AttributeProto_AttributeType_strings[idx].get();
-}
-bool AttributeProto_AttributeType_Parse(
-    const std::string& name, AttributeProto_AttributeType* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      AttributeProto_AttributeType_entries, 15, name, &int_value);
-  if (success) {
-    *value = static_cast<AttributeProto_AttributeType>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr AttributeProto_AttributeType AttributeProto::UNDEFINED;
-constexpr AttributeProto_AttributeType AttributeProto::FLOAT;
-constexpr AttributeProto_AttributeType AttributeProto::INT;
-constexpr AttributeProto_AttributeType AttributeProto::STRING;
-constexpr AttributeProto_AttributeType AttributeProto::TENSOR;
-constexpr AttributeProto_AttributeType AttributeProto::GRAPH;
-constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSOR;
-constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTO;
-constexpr AttributeProto_AttributeType AttributeProto::FLOATS;
-constexpr AttributeProto_AttributeType AttributeProto::INTS;
-constexpr AttributeProto_AttributeType AttributeProto::STRINGS;
-constexpr AttributeProto_AttributeType AttributeProto::TENSORS;
-constexpr AttributeProto_AttributeType AttributeProto::GRAPHS;
-constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSORS;
-constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTOS;
-constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MIN;
-constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MAX;
-constexpr int AttributeProto::AttributeType_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool TensorProto_DataType_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-    case 13:
-    case 14:
-    case 15:
-    case 16:
-    case 17:
-    case 18:
-    case 19:
-    case 20:
-    case 21:
-    case 22:
-    case 23:
-    case 24:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TensorProto_DataType_strings[25] = {};
-
-static const char TensorProto_DataType_names[] =
-  "BFLOAT16"
-  "BOOL"
-  "COMPLEX128"
-  "COMPLEX64"
-  "DOUBLE"
-  "FLOAT"
-  "FLOAT16"
-  "FLOAT4E2M1"
-  "FLOAT8E4M3FN"
-  "FLOAT8E4M3FNUZ"
-  "FLOAT8E5M2"
-  "FLOAT8E5M2FNUZ"
-  "FLOAT8E8M0"
-  "INT16"
-  "INT32"
-  "INT4"
-  "INT64"
-  "INT8"
-  "STRING"
-  "UINT16"
-  "UINT32"
-  "UINT4"
-  "UINT64"
-  "UINT8"
-  "UNDEFINED";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TensorProto_DataType_entries[] = {
-  { {TensorProto_DataType_names + 0, 8}, 16 },
-  { {TensorProto_DataType_names + 8, 4}, 9 },
-  { {TensorProto_DataType_names + 12, 10}, 15 },
-  { {TensorProto_DataType_names + 22, 9}, 14 },
-  { {TensorProto_DataType_names + 31, 6}, 11 },
-  { {TensorProto_DataType_names + 37, 5}, 1 },
-  { {TensorProto_DataType_names + 42, 7}, 10 },
-  { {TensorProto_DataType_names + 49, 10}, 23 },
-  { {TensorProto_DataType_names + 59, 12}, 17 },
-  { {TensorProto_DataType_names + 71, 14}, 18 },
-  { {TensorProto_DataType_names + 85, 10}, 19 },
-  { {TensorProto_DataType_names + 95, 14}, 20 },
-  { {TensorProto_DataType_names + 109, 10}, 24 },
-  { {TensorProto_DataType_names + 119, 5}, 5 },
-  { {TensorProto_DataType_names + 124, 5}, 6 },
-  { {TensorProto_DataType_names + 129, 4}, 22 },
-  { {TensorProto_DataType_names + 133, 5}, 7 },
-  { {TensorProto_DataType_names + 138, 4}, 3 },
-  { {TensorProto_DataType_names + 142, 6}, 8 },
-  { {TensorProto_DataType_names + 148, 6}, 4 },
-  { {TensorProto_DataType_names + 154, 6}, 12 },
-  { {TensorProto_DataType_names + 160, 5}, 21 },
-  { {TensorProto_DataType_names + 165, 6}, 13 },
-  { {TensorProto_DataType_names + 171, 5}, 2 },
-  { {TensorProto_DataType_names + 176, 9}, 0 },
-};
-
-static const int TensorProto_DataType_entries_by_number[] = {
-  24, // 0 -> UNDEFINED
-  5, // 1 -> FLOAT
-  23, // 2 -> UINT8
-  17, // 3 -> INT8
-  19, // 4 -> UINT16
-  13, // 5 -> INT16
-  14, // 6 -> INT32
-  16, // 7 -> INT64
-  18, // 8 -> STRING
-  1, // 9 -> BOOL
-  6, // 10 -> FLOAT16
-  4, // 11 -> DOUBLE
-  20, // 12 -> UINT32
-  22, // 13 -> UINT64
-  3, // 14 -> COMPLEX64
-  2, // 15 -> COMPLEX128
-  0, // 16 -> BFLOAT16
-  8, // 17 -> FLOAT8E4M3FN
-  9, // 18 -> FLOAT8E4M3FNUZ
-  10, // 19 -> FLOAT8E5M2
-  11, // 20 -> FLOAT8E5M2FNUZ
-  21, // 21 -> UINT4
-  15, // 22 -> INT4
-  7, // 23 -> FLOAT4E2M1
-  12, // 24 -> FLOAT8E8M0
-};
-
-const std::string& TensorProto_DataType_Name(
-    TensorProto_DataType value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          TensorProto_DataType_entries,
-          TensorProto_DataType_entries_by_number,
-          25, TensorProto_DataType_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      TensorProto_DataType_entries,
-      TensorProto_DataType_entries_by_number,
-      25, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     TensorProto_DataType_strings[idx].get();
-}
-bool TensorProto_DataType_Parse(
-    const std::string& name, TensorProto_DataType* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      TensorProto_DataType_entries, 25, name, &int_value);
-  if (success) {
-    *value = static_cast<TensorProto_DataType>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr TensorProto_DataType TensorProto::UNDEFINED;
-constexpr TensorProto_DataType TensorProto::FLOAT;
-constexpr TensorProto_DataType TensorProto::UINT8;
-constexpr TensorProto_DataType TensorProto::INT8;
-constexpr TensorProto_DataType TensorProto::UINT16;
-constexpr TensorProto_DataType TensorProto::INT16;
-constexpr TensorProto_DataType TensorProto::INT32;
-constexpr TensorProto_DataType TensorProto::INT64;
-constexpr TensorProto_DataType TensorProto::STRING;
-constexpr TensorProto_DataType TensorProto::BOOL;
-constexpr TensorProto_DataType TensorProto::FLOAT16;
-constexpr TensorProto_DataType TensorProto::DOUBLE;
-constexpr TensorProto_DataType TensorProto::UINT32;
-constexpr TensorProto_DataType TensorProto::UINT64;
-constexpr TensorProto_DataType TensorProto::COMPLEX64;
-constexpr TensorProto_DataType TensorProto::COMPLEX128;
-constexpr TensorProto_DataType TensorProto::BFLOAT16;
-constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FN;
-constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FNUZ;
-constexpr TensorProto_DataType TensorProto::FLOAT8E5M2;
-constexpr TensorProto_DataType TensorProto::FLOAT8E5M2FNUZ;
-constexpr TensorProto_DataType TensorProto::UINT4;
-constexpr TensorProto_DataType TensorProto::INT4;
-constexpr TensorProto_DataType TensorProto::FLOAT4E2M1;
-constexpr TensorProto_DataType TensorProto::FLOAT8E8M0;
-constexpr TensorProto_DataType TensorProto::DataType_MIN;
-constexpr TensorProto_DataType TensorProto::DataType_MAX;
-constexpr int TensorProto::DataType_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool TensorProto_DataLocation_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TensorProto_DataLocation_strings[2] = {};
-
-static const char TensorProto_DataLocation_names[] =
-  "DEFAULT"
-  "EXTERNAL";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TensorProto_DataLocation_entries[] = {
-  { {TensorProto_DataLocation_names + 0, 7}, 0 },
-  { {TensorProto_DataLocation_names + 7, 8}, 1 },
-};
-
-static const int TensorProto_DataLocation_entries_by_number[] = {
-  0, // 0 -> DEFAULT
-  1, // 1 -> EXTERNAL
-};
-
-const std::string& TensorProto_DataLocation_Name(
-    TensorProto_DataLocation value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          TensorProto_DataLocation_entries,
-          TensorProto_DataLocation_entries_by_number,
-          2, TensorProto_DataLocation_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      TensorProto_DataLocation_entries,
-      TensorProto_DataLocation_entries_by_number,
-      2, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     TensorProto_DataLocation_strings[idx].get();
-}
-bool TensorProto_DataLocation_Parse(
-    const std::string& name, TensorProto_DataLocation* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      TensorProto_DataLocation_entries, 2, name, &int_value);
-  if (success) {
-    *value = static_cast<TensorProto_DataLocation>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr TensorProto_DataLocation TensorProto::DEFAULT;
-constexpr TensorProto_DataLocation TensorProto::EXTERNAL;
-constexpr TensorProto_DataLocation TensorProto::DataLocation_MIN;
-constexpr TensorProto_DataLocation TensorProto::DataLocation_MAX;
-constexpr int TensorProto::DataLocation_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool Version_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Version_strings[13] = {};
-
-static const char Version_names[] =
-  "IR_VERSION"
-  "IR_VERSION_2017_10_10"
-  "IR_VERSION_2017_10_30"
-  "IR_VERSION_2017_11_3"
-  "IR_VERSION_2019_1_22"
-  "IR_VERSION_2019_3_18"
-  "IR_VERSION_2019_9_19"
-  "IR_VERSION_2020_5_8"
-  "IR_VERSION_2021_7_30"
-  "IR_VERSION_2023_5_5"
-  "IR_VERSION_2024_3_25"
-  "IR_VERSION_2025_05_12"
-  "_START_VERSION";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Version_entries[] = {
-  { {Version_names + 0, 10}, 12 },
-  { {Version_names + 10, 21}, 1 },
-  { {Version_names + 31, 21}, 2 },
-  { {Version_names + 52, 20}, 3 },
-  { {Version_names + 72, 20}, 4 },
-  { {Version_names + 92, 20}, 5 },
-  { {Version_names + 112, 20}, 6 },
-  { {Version_names + 132, 19}, 7 },
-  { {Version_names + 151, 20}, 8 },
-  { {Version_names + 171, 19}, 9 },
-  { {Version_names + 190, 20}, 10 },
-  { {Version_names + 210, 21}, 11 },
-  { {Version_names + 231, 14}, 0 },
-};
-
-static const int Version_entries_by_number[] = {
-  12, // 0 -> _START_VERSION
-  1, // 1 -> IR_VERSION_2017_10_10
-  2, // 2 -> IR_VERSION_2017_10_30
-  3, // 3 -> IR_VERSION_2017_11_3
-  4, // 4 -> IR_VERSION_2019_1_22
-  5, // 5 -> IR_VERSION_2019_3_18
-  6, // 6 -> IR_VERSION_2019_9_19
-  7, // 7 -> IR_VERSION_2020_5_8
-  8, // 8 -> IR_VERSION_2021_7_30
-  9, // 9 -> IR_VERSION_2023_5_5
-  10, // 10 -> IR_VERSION_2024_3_25
-  11, // 11 -> IR_VERSION_2025_05_12
-  0, // 12 -> IR_VERSION
-};
-
-const std::string& Version_Name(
-    Version value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          Version_entries,
-          Version_entries_by_number,
-          13, Version_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      Version_entries,
-      Version_entries_by_number,
-      13, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     Version_strings[idx].get();
-}
-bool Version_Parse(
-    const std::string& name, Version* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      Version_entries, 13, name, &int_value);
-  if (success) {
-    *value = static_cast<Version>(int_value);
-  }
-  return success;
-}
-bool OperatorStatus_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OperatorStatus_strings[2] = {};
-
-static const char OperatorStatus_names[] =
-  "EXPERIMENTAL"
-  "STABLE";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperatorStatus_entries[] = {
-  { {OperatorStatus_names + 0, 12}, 0 },
-  { {OperatorStatus_names + 12, 6}, 1 },
-};
-
-static const int OperatorStatus_entries_by_number[] = {
-  0, // 0 -> EXPERIMENTAL
-  1, // 1 -> STABLE
-};
-
-const std::string& OperatorStatus_Name(
-    OperatorStatus value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          OperatorStatus_entries,
-          OperatorStatus_entries_by_number,
-          2, OperatorStatus_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      OperatorStatus_entries,
-      OperatorStatus_entries_by_number,
-      2, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     OperatorStatus_strings[idx].get();
-}
-bool OperatorStatus_Parse(
-    const std::string& name, OperatorStatus* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      OperatorStatus_entries, 2, name, &int_value);
-  if (success) {
-    *value = static_cast<OperatorStatus>(int_value);
-  }
-  return success;
-}
-
-// ===================================================================
-
-void AttributeProto::InitAsDefaultInstance() {
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->t_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->g_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->sparse_tensor_ = const_cast< ::onnx::SparseTensorProto*>(
-      ::onnx::SparseTensorProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->tp_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class AttributeProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<AttributeProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_ref_attr_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 8u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 1024u;
-  }
-  static void set_has_f(HasBits* has_bits) {
-    (*has_bits)[0] |= 512u;
-  }
-  static void set_has_i(HasBits* has_bits) {
-    (*has_bits)[0] |= 256u;
-  }
-  static void set_has_s(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static const ::onnx::TensorProto& t(const AttributeProto* msg);
-  static void set_has_t(HasBits* has_bits) {
-    (*has_bits)[0] |= 16u;
-  }
-  static const ::onnx::GraphProto& g(const AttributeProto* msg);
-  static void set_has_g(HasBits* has_bits) {
-    (*has_bits)[0] |= 32u;
-  }
-  static const ::onnx::SparseTensorProto& sparse_tensor(const AttributeProto* msg);
-  static void set_has_sparse_tensor(HasBits* has_bits) {
-    (*has_bits)[0] |= 128u;
-  }
-  static const ::onnx::TypeProto& tp(const AttributeProto* msg);
-  static void set_has_tp(HasBits* has_bits) {
-    (*has_bits)[0] |= 64u;
-  }
-};
-
-const ::onnx::TensorProto&
-AttributeProto::_Internal::t(const AttributeProto* msg) {
-  return *msg->t_;
-}
-const ::onnx::GraphProto&
-AttributeProto::_Internal::g(const AttributeProto* msg) {
-  return *msg->g_;
-}
-const ::onnx::SparseTensorProto&
-AttributeProto::_Internal::sparse_tensor(const AttributeProto* msg) {
-  return *msg->sparse_tensor_;
-}
-const ::onnx::TypeProto&
-AttributeProto::_Internal::tp(const AttributeProto* msg) {
-  return *msg->tp_;
-}
-AttributeProto::AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  floats_(arena),
-  ints_(arena),
-  strings_(arena),
-  tensors_(arena),
-  graphs_(arena),
-  type_protos_(arena),
-  sparse_tensors_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.AttributeProto)
-}
-AttributeProto::AttributeProto(const AttributeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      floats_(from.floats_),
-      ints_(from.ints_),
-      strings_(from.strings_),
-      tensors_(from.tensors_),
-      graphs_(from.graphs_),
-      type_protos_(from.type_protos_),
-      sparse_tensors_(from.sparse_tensors_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  s_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_s()) {
-    s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_s(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  ref_attr_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_ref_attr_name()) {
-    ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ref_attr_name(),
-      GetArena());
-  }
-  if (from._internal_has_t()) {
-    t_ = new ::onnx::TensorProto(*from.t_);
-  } else {
-    t_ = nullptr;
-  }
-  if (from._internal_has_g()) {
-    g_ = new ::onnx::GraphProto(*from.g_);
-  } else {
-    g_ = nullptr;
-  }
-  if (from._internal_has_tp()) {
-    tp_ = new ::onnx::TypeProto(*from.tp_);
-  } else {
-    tp_ = nullptr;
-  }
-  if (from._internal_has_sparse_tensor()) {
-    sparse_tensor_ = new ::onnx::SparseTensorProto(*from.sparse_tensor_);
-  } else {
-    sparse_tensor_ = nullptr;
-  }
-  ::memcpy(&i_, &from.i_,
-    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
-    reinterpret_cast<char*>(&i_)) + sizeof(type_));
-  // @@protoc_insertion_point(copy_constructor:onnx.AttributeProto)
-}
-
-void AttributeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  s_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ref_attr_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&t_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&type_) -
-      reinterpret_cast<char*>(&t_)) + sizeof(type_));
-}
-
-AttributeProto::~AttributeProto() {
-  // @@protoc_insertion_point(destructor:onnx.AttributeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void AttributeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  s_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ref_attr_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete t_;
-  if (this != internal_default_instance()) delete g_;
-  if (this != internal_default_instance()) delete tp_;
-  if (this != internal_default_instance()) delete sparse_tensor_;
-}
-
-void AttributeProto::ArenaDtor(void* object) {
-  AttributeProto* _this = reinterpret_cast< AttributeProto* >(object);
-  (void)_this;
-}
-void AttributeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void AttributeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const AttributeProto& AttributeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void AttributeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.AttributeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  floats_.Clear();
-  ints_.Clear();
-  strings_.Clear();
-  tensors_.Clear();
-  graphs_.Clear();
-  type_protos_.Clear();
-  sparse_tensors_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x000000ffu) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      s_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000008u) {
-      ref_attr_name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000010u) {
-      GOOGLE_DCHECK(t_ != nullptr);
-      t_->Clear();
-    }
-    if (cached_has_bits & 0x00000020u) {
-      GOOGLE_DCHECK(g_ != nullptr);
-      g_->Clear();
-    }
-    if (cached_has_bits & 0x00000040u) {
-      GOOGLE_DCHECK(tp_ != nullptr);
-      tp_->Clear();
-    }
-    if (cached_has_bits & 0x00000080u) {
-      GOOGLE_DCHECK(sparse_tensor_ != nullptr);
-      sparse_tensor_->Clear();
-    }
-  }
-  if (cached_has_bits & 0x00000700u) {
-    ::memset(&i_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&type_) -
-        reinterpret_cast<char*>(&i_)) + sizeof(type_));
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* AttributeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional float f = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
-          _Internal::set_has_f(&has_bits);
-          f_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
-          ptr += sizeof(float);
-        } else goto handle_unusual;
-        continue;
-      // optional int64 i = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          _Internal::set_has_i(&has_bits);
-          i_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional bytes s = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_s();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorProto t = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ctx->ParseMessage(_internal_mutable_t(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.GraphProto g = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr = ctx->ParseMessage(_internal_mutable_g(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated float floats = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_floats(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
-            ptr += sizeof(float);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_floats(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 ints = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_ints(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<64>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_ints(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated bytes strings = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_strings();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorProto tensors = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_tensors(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.GraphProto graphs = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_graphs(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TypeProto tp = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr = ctx->ParseMessage(_internal_mutable_tp(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TypeProto type_protos = 15;
-      case 15:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_type_protos(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.AttributeProto.AttributeType type = 20;
-      case 20:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
-          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-          if (PROTOBUF_PREDICT_TRUE(::onnx::AttributeProto_AttributeType_IsValid(val))) {
-            _internal_set_type(static_cast<::onnx::AttributeProto_AttributeType>(val));
-          } else {
-            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields());
-          }
-        } else goto handle_unusual;
-        continue;
-      // optional string ref_attr_name = 21;
-      case 21:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
-          auto str = _internal_mutable_ref_attr_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.SparseTensorProto sparse_tensor = 22;
-      case 22:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-      case 23:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_sparse_tensors(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<186>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* AttributeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.AttributeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // optional float f = 2;
-  if (cached_has_bits & 0x00000200u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_f(), target);
-  }
-
-  // optional int64 i = 3;
-  if (cached_has_bits & 0x00000100u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_i(), target);
-  }
-
-  // optional bytes s = 4;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteBytesMaybeAliased(
-        4, this->_internal_s(), target);
-  }
-
-  // optional .onnx.TensorProto t = 5;
-  if (cached_has_bits & 0x00000010u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        5, _Internal::t(this), target, stream);
-  }
-
-  // optional .onnx.GraphProto g = 6;
-  if (cached_has_bits & 0x00000020u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        6, _Internal::g(this), target, stream);
-  }
-
-  // repeated float floats = 7;
-  for (int i = 0, n = this->_internal_floats_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_floats(i), target);
-  }
-
-  // repeated int64 ints = 8;
-  for (int i = 0, n = this->_internal_ints_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->_internal_ints(i), target);
-  }
-
-  // repeated bytes strings = 9;
-  for (int i = 0, n = this->_internal_strings_size(); i < n; i++) {
-    const auto& s = this->_internal_strings(i);
-    target = stream->WriteBytes(9, s, target);
-  }
-
-  // repeated .onnx.TensorProto tensors = 10;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_tensors_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(10, this->_internal_tensors(i), target, stream);
-  }
-
-  // repeated .onnx.GraphProto graphs = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_graphs_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_graphs(i), target, stream);
-  }
-
-  // optional string doc_string = 13;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->WriteStringMaybeAliased(
-        13, this->_internal_doc_string(), target);
-  }
-
-  // optional .onnx.TypeProto tp = 14;
-  if (cached_has_bits & 0x00000040u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        14, _Internal::tp(this), target, stream);
-  }
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_type_protos_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(15, this->_internal_type_protos(i), target, stream);
-  }
-
-  // optional .onnx.AttributeProto.AttributeType type = 20;
-  if (cached_has_bits & 0x00000400u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
-      20, this->_internal_type(), target);
-  }
-
-  // optional string ref_attr_name = 21;
-  if (cached_has_bits & 0x00000008u) {
-    target = stream->WriteStringMaybeAliased(
-        21, this->_internal_ref_attr_name(), target);
-  }
-
-  // optional .onnx.SparseTensorProto sparse_tensor = 22;
-  if (cached_has_bits & 0x00000080u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        22, _Internal::sparse_tensor(this), target, stream);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sparse_tensors_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(23, this->_internal_sparse_tensors(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.AttributeProto)
-  return target;
-}
-
-size_t AttributeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.AttributeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated float floats = 7;
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_floats_size());
-    size_t data_size = 4UL * count;
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_floats_size());
-    total_size += data_size;
-  }
-
-  // repeated int64 ints = 8;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->ints_);
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_ints_size());
-    total_size += data_size;
-  }
-
-  // repeated bytes strings = 9;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(strings_.size());
-  for (int i = 0, n = strings_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      strings_.Get(i));
-  }
-
-  // repeated .onnx.TensorProto tensors = 10;
-  total_size += 1UL * this->_internal_tensors_size();
-  for (const auto& msg : this->tensors_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.GraphProto graphs = 11;
-  total_size += 1UL * this->_internal_graphs_size();
-  for (const auto& msg : this->graphs_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  total_size += 1UL * this->_internal_type_protos_size();
-  for (const auto& msg : this->type_protos_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  total_size += 2UL * this->_internal_sparse_tensors_size();
-  for (const auto& msg : this->sparse_tensors_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x000000ffu) {
-    // optional string name = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional bytes s = 4;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-          this->_internal_s());
-    }
-
-    // optional string doc_string = 13;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional string ref_attr_name = 21;
-    if (cached_has_bits & 0x00000008u) {
-      total_size += 2 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_ref_attr_name());
-    }
-
-    // optional .onnx.TensorProto t = 5;
-    if (cached_has_bits & 0x00000010u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *t_);
-    }
-
-    // optional .onnx.GraphProto g = 6;
-    if (cached_has_bits & 0x00000020u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *g_);
-    }
-
-    // optional .onnx.TypeProto tp = 14;
-    if (cached_has_bits & 0x00000040u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *tp_);
-    }
-
-    // optional .onnx.SparseTensorProto sparse_tensor = 22;
-    if (cached_has_bits & 0x00000080u) {
-      total_size += 2 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *sparse_tensor_);
-    }
-
-  }
-  if (cached_has_bits & 0x00000700u) {
-    // optional int64 i = 3;
-    if (cached_has_bits & 0x00000100u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_i());
-    }
-
-    // optional float f = 2;
-    if (cached_has_bits & 0x00000200u) {
-      total_size += 1 + 4;
-    }
-
-    // optional .onnx.AttributeProto.AttributeType type = 20;
-    if (cached_has_bits & 0x00000400u) {
-      total_size += 2 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void AttributeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AttributeProto*>(
-      &from));
-}
-
-void AttributeProto::MergeFrom(const AttributeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.AttributeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  floats_.MergeFrom(from.floats_);
-  ints_.MergeFrom(from.ints_);
-  strings_.MergeFrom(from.strings_);
-  tensors_.MergeFrom(from.tensors_);
-  graphs_.MergeFrom(from.graphs_);
-  type_protos_.MergeFrom(from.type_protos_);
-  sparse_tensors_.MergeFrom(from.sparse_tensors_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x000000ffu) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_s(from._internal_s());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000008u) {
-      _internal_set_ref_attr_name(from._internal_ref_attr_name());
-    }
-    if (cached_has_bits & 0x00000010u) {
-      _internal_mutable_t()->::onnx::TensorProto::MergeFrom(from._internal_t());
-    }
-    if (cached_has_bits & 0x00000020u) {
-      _internal_mutable_g()->::onnx::GraphProto::MergeFrom(from._internal_g());
-    }
-    if (cached_has_bits & 0x00000040u) {
-      _internal_mutable_tp()->::onnx::TypeProto::MergeFrom(from._internal_tp());
-    }
-    if (cached_has_bits & 0x00000080u) {
-      _internal_mutable_sparse_tensor()->::onnx::SparseTensorProto::MergeFrom(from._internal_sparse_tensor());
-    }
-  }
-  if (cached_has_bits & 0x00000700u) {
-    if (cached_has_bits & 0x00000100u) {
-      i_ = from.i_;
-    }
-    if (cached_has_bits & 0x00000200u) {
-      f_ = from.f_;
-    }
-    if (cached_has_bits & 0x00000400u) {
-      type_ = from.type_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void AttributeProto::CopyFrom(const AttributeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.AttributeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AttributeProto::IsInitialized() const {
-  return true;
-}
-
-void AttributeProto::InternalSwap(AttributeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  floats_.InternalSwap(&other->floats_);
-  ints_.InternalSwap(&other->ints_);
-  strings_.InternalSwap(&other->strings_);
-  tensors_.InternalSwap(&other->tensors_);
-  graphs_.InternalSwap(&other->graphs_);
-  type_protos_.InternalSwap(&other->type_protos_);
-  sparse_tensors_.InternalSwap(&other->sparse_tensors_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  s_.Swap(&other->s_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ref_attr_name_.Swap(&other->ref_attr_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(AttributeProto, type_)
-      + sizeof(AttributeProto::type_)
-      - PROTOBUF_FIELD_OFFSET(AttributeProto, t_)>(
-          reinterpret_cast<char*>(&t_),
-          reinterpret_cast<char*>(&other->t_));
-}
-
-std::string AttributeProto::GetTypeName() const {
-  return "onnx.AttributeProto";
-}
-
-
-// ===================================================================
-
-void ValueInfoProto::InitAsDefaultInstance() {
-  ::onnx::_ValueInfoProto_default_instance_._instance.get_mutable()->type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class ValueInfoProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<ValueInfoProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static const ::onnx::TypeProto& type(const ValueInfoProto* msg);
-  static void set_has_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-const ::onnx::TypeProto&
-ValueInfoProto::_Internal::type(const ValueInfoProto* msg) {
-  return *msg->type_;
-}
-ValueInfoProto::ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ValueInfoProto)
-}
-ValueInfoProto::ValueInfoProto(const ValueInfoProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_type()) {
-    type_ = new ::onnx::TypeProto(*from.type_);
-  } else {
-    type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.ValueInfoProto)
-}
-
-void ValueInfoProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ValueInfoProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  type_ = nullptr;
-}
-
-ValueInfoProto::~ValueInfoProto() {
-  // @@protoc_insertion_point(destructor:onnx.ValueInfoProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ValueInfoProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete type_;
-}
-
-void ValueInfoProto::ArenaDtor(void* object) {
-  ValueInfoProto* _this = reinterpret_cast< ValueInfoProto* >(object);
-  (void)_this;
-}
-void ValueInfoProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ValueInfoProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ValueInfoProto& ValueInfoProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ValueInfoProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void ValueInfoProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ValueInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  metadata_props_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000007u) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      GOOGLE_DCHECK(type_ != nullptr);
-      type_->Clear();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ValueInfoProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TypeProto type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ValueInfoProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ValueInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // optional .onnx.TypeProto type = 2;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::type(this), target, stream);
-  }
-
-  // optional string doc_string = 3;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ValueInfoProto)
-  return target;
-}
-
-size_t ValueInfoProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ValueInfoProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000007u) {
-    // optional string name = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional string doc_string = 3;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional .onnx.TypeProto type = 2;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *type_);
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ValueInfoProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ValueInfoProto*>(
-      &from));
-}
-
-void ValueInfoProto::MergeFrom(const ValueInfoProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ValueInfoProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  metadata_props_.MergeFrom(from.metadata_props_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000007u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_mutable_type()->::onnx::TypeProto::MergeFrom(from._internal_type());
-    }
-  }
-}
-
-void ValueInfoProto::CopyFrom(const ValueInfoProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ValueInfoProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ValueInfoProto::IsInitialized() const {
-  return true;
-}
-
-void ValueInfoProto::InternalSwap(ValueInfoProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(type_, other->type_);
-}
-
-std::string ValueInfoProto::GetTypeName() const {
-  return "onnx.ValueInfoProto";
-}
-
-
-// ===================================================================
-
-void NodeProto::InitAsDefaultInstance() {
-}
-class NodeProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<NodeProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_op_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_domain(HasBits* has_bits) {
-    (*has_bits)[0] |= 8u;
-  }
-  static void set_has_overload(HasBits* has_bits) {
-    (*has_bits)[0] |= 16u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-};
-
-NodeProto::NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  input_(arena),
-  output_(arena),
-  attribute_(arena),
-  metadata_props_(arena),
-  device_configurations_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.NodeProto)
-}
-NodeProto::NodeProto(const NodeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      input_(from.input_),
-      output_(from.output_),
-      attribute_(from.attribute_),
-      metadata_props_(from.metadata_props_),
-      device_configurations_(from.device_configurations_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  op_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_op_type()) {
-    op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_op_type(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_domain()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_overload()) {
-    overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_overload(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.NodeProto)
-}
-
-void NodeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  op_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-NodeProto::~NodeProto() {
-  // @@protoc_insertion_point(destructor:onnx.NodeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void NodeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  op_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void NodeProto::ArenaDtor(void* object) {
-  NodeProto* _this = reinterpret_cast< NodeProto* >(object);
-  (void)_this;
-}
-void NodeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void NodeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const NodeProto& NodeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void NodeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.NodeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  input_.Clear();
-  output_.Clear();
-  attribute_.Clear();
-  metadata_props_.Clear();
-  device_configurations_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000001fu) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      op_type_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000008u) {
-      domain_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000010u) {
-      overload_.ClearNonDefaultToEmpty();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* NodeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated string input = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_input();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string output = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_output();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string name = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string op_type = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_op_type();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.AttributeProto attribute = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_attribute(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string domain = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string overload = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_overload();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_device_configurations(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* NodeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.NodeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated string input = 1;
-  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
-    const auto& s = this->_internal_input(i);
-    target = stream->WriteString(1, s, target);
-  }
-
-  // repeated string output = 2;
-  for (int i = 0, n = this->_internal_output_size(); i < n; i++) {
-    const auto& s = this->_internal_output(i);
-    target = stream->WriteString(2, s, target);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 3;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_name(), target);
-  }
-
-  // optional string op_type = 4;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        4, this->_internal_op_type(), target);
-  }
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_attribute_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(5, this->_internal_attribute(i), target, stream);
-  }
-
-  // optional string doc_string = 6;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_doc_string(), target);
-  }
-
-  // optional string domain = 7;
-  if (cached_has_bits & 0x00000008u) {
-    target = stream->WriteStringMaybeAliased(
-        7, this->_internal_domain(), target);
-  }
-
-  // optional string overload = 8;
-  if (cached_has_bits & 0x00000010u) {
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_overload(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(9, this->_internal_metadata_props(i), target, stream);
-  }
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_device_configurations_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(10, this->_internal_device_configurations(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.NodeProto)
-  return target;
-}
-
-size_t NodeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.NodeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string input = 1;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
-  for (int i = 0, n = input_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      input_.Get(i));
-  }
-
-  // repeated string output = 2;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size());
-  for (int i = 0, n = output_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      output_.Get(i));
-  }
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  total_size += 1UL * this->_internal_attribute_size();
-  for (const auto& msg : this->attribute_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  total_size += 1UL * this->_internal_device_configurations_size();
-  for (const auto& msg : this->device_configurations_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000001fu) {
-    // optional string name = 3;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional string op_type = 4;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_op_type());
-    }
-
-    // optional string doc_string = 6;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional string domain = 7;
-    if (cached_has_bits & 0x00000008u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_domain());
-    }
-
-    // optional string overload = 8;
-    if (cached_has_bits & 0x00000010u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_overload());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void NodeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const NodeProto*>(
-      &from));
-}
-
-void NodeProto::MergeFrom(const NodeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.NodeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  attribute_.MergeFrom(from.attribute_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  device_configurations_.MergeFrom(from.device_configurations_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000001fu) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_op_type(from._internal_op_type());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000008u) {
-      _internal_set_domain(from._internal_domain());
-    }
-    if (cached_has_bits & 0x00000010u) {
-      _internal_set_overload(from._internal_overload());
-    }
-  }
-}
-
-void NodeProto::CopyFrom(const NodeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.NodeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool NodeProto::IsInitialized() const {
-  return true;
-}
-
-void NodeProto::InternalSwap(NodeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  attribute_.InternalSwap(&other->attribute_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  device_configurations_.InternalSwap(&other->device_configurations_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  op_type_.Swap(&other->op_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.Swap(&other->overload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string NodeProto::GetTypeName() const {
-  return "onnx.NodeProto";
-}
-
-
-// ===================================================================
-
-void IntIntListEntryProto::InitAsDefaultInstance() {
-}
-class IntIntListEntryProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<IntIntListEntryProto>()._has_bits_);
-  static void set_has_key(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-IntIntListEntryProto::IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  value_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.IntIntListEntryProto)
-}
-IntIntListEntryProto::IntIntListEntryProto(const IntIntListEntryProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      value_(from.value_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  key_ = from.key_;
-  // @@protoc_insertion_point(copy_constructor:onnx.IntIntListEntryProto)
-}
-
-void IntIntListEntryProto::SharedCtor() {
-  key_ = PROTOBUF_LONGLONG(0);
-}
-
-IntIntListEntryProto::~IntIntListEntryProto() {
-  // @@protoc_insertion_point(destructor:onnx.IntIntListEntryProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void IntIntListEntryProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void IntIntListEntryProto::ArenaDtor(void* object) {
-  IntIntListEntryProto* _this = reinterpret_cast< IntIntListEntryProto* >(object);
-  (void)_this;
-}
-void IntIntListEntryProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void IntIntListEntryProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const IntIntListEntryProto& IntIntListEntryProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IntIntListEntryProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void IntIntListEntryProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.IntIntListEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  value_.Clear();
-  key_ = PROTOBUF_LONGLONG(0);
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* IntIntListEntryProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int64 key = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_key(&has_bits);
-          key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 value = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_value(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* IntIntListEntryProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.IntIntListEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int64 key = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_key(), target);
-  }
-
-  // repeated int64 value = 2;
-  for (int i = 0, n = this->_internal_value_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_value(i), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.IntIntListEntryProto)
-  return target;
-}
-
-size_t IntIntListEntryProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.IntIntListEntryProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 value = 2;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->value_);
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_value_size());
-    total_size += data_size;
-  }
-
-  // optional int64 key = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_key());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void IntIntListEntryProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const IntIntListEntryProto*>(
-      &from));
-}
-
-void IntIntListEntryProto::MergeFrom(const IntIntListEntryProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.IntIntListEntryProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  value_.MergeFrom(from.value_);
-  if (from._internal_has_key()) {
-    _internal_set_key(from._internal_key());
-  }
-}
-
-void IntIntListEntryProto::CopyFrom(const IntIntListEntryProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.IntIntListEntryProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool IntIntListEntryProto::IsInitialized() const {
-  return true;
-}
-
-void IntIntListEntryProto::InternalSwap(IntIntListEntryProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  value_.InternalSwap(&other->value_);
-  swap(key_, other->key_);
-}
-
-std::string IntIntListEntryProto::GetTypeName() const {
-  return "onnx.IntIntListEntryProto";
-}
-
-
-// ===================================================================
-
-void NodeDeviceConfigurationProto::InitAsDefaultInstance() {
-}
-class NodeDeviceConfigurationProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<NodeDeviceConfigurationProto>()._has_bits_);
-  static void set_has_configuration_id(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_pipeline_stage(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-NodeDeviceConfigurationProto::NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  sharding_spec_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.NodeDeviceConfigurationProto)
-}
-NodeDeviceConfigurationProto::NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      sharding_spec_(from.sharding_spec_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  configuration_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_configuration_id()) {
-    configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_configuration_id(),
-      GetArena());
-  }
-  pipeline_stage_ = from.pipeline_stage_;
-  // @@protoc_insertion_point(copy_constructor:onnx.NodeDeviceConfigurationProto)
-}
-
-void NodeDeviceConfigurationProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NodeDeviceConfigurationProto_onnx_2eproto.base);
-  configuration_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  pipeline_stage_ = 0;
-}
-
-NodeDeviceConfigurationProto::~NodeDeviceConfigurationProto() {
-  // @@protoc_insertion_point(destructor:onnx.NodeDeviceConfigurationProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void NodeDeviceConfigurationProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  configuration_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void NodeDeviceConfigurationProto::ArenaDtor(void* object) {
-  NodeDeviceConfigurationProto* _this = reinterpret_cast< NodeDeviceConfigurationProto* >(object);
-  (void)_this;
-}
-void NodeDeviceConfigurationProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void NodeDeviceConfigurationProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const NodeDeviceConfigurationProto& NodeDeviceConfigurationProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NodeDeviceConfigurationProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void NodeDeviceConfigurationProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.NodeDeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  sharding_spec_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    configuration_id_.ClearNonDefaultToEmpty();
-  }
-  pipeline_stage_ = 0;
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* NodeDeviceConfigurationProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string configuration_id = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_configuration_id();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sharding_spec(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional int32 pipeline_stage = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          _Internal::set_has_pipeline_stage(&has_bits);
-          pipeline_stage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* NodeDeviceConfigurationProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.NodeDeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string configuration_id = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_configuration_id(), target);
-  }
-
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sharding_spec_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_sharding_spec(i), target, stream);
-  }
-
-  // optional int32 pipeline_stage = 3;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_pipeline_stage(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.NodeDeviceConfigurationProto)
-  return target;
-}
-
-size_t NodeDeviceConfigurationProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.NodeDeviceConfigurationProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  total_size += 1UL * this->_internal_sharding_spec_size();
-  for (const auto& msg : this->sharding_spec_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional string configuration_id = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_configuration_id());
-    }
-
-    // optional int32 pipeline_stage = 3;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_pipeline_stage());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void NodeDeviceConfigurationProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const NodeDeviceConfigurationProto*>(
-      &from));
-}
-
-void NodeDeviceConfigurationProto::MergeFrom(const NodeDeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.NodeDeviceConfigurationProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  sharding_spec_.MergeFrom(from.sharding_spec_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_configuration_id(from._internal_configuration_id());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      pipeline_stage_ = from.pipeline_stage_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void NodeDeviceConfigurationProto::CopyFrom(const NodeDeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.NodeDeviceConfigurationProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool NodeDeviceConfigurationProto::IsInitialized() const {
-  return true;
-}
-
-void NodeDeviceConfigurationProto::InternalSwap(NodeDeviceConfigurationProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  sharding_spec_.InternalSwap(&other->sharding_spec_);
-  configuration_id_.Swap(&other->configuration_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(pipeline_stage_, other->pipeline_stage_);
-}
-
-std::string NodeDeviceConfigurationProto::GetTypeName() const {
-  return "onnx.NodeDeviceConfigurationProto";
-}
-
-
-// ===================================================================
-
-void ShardingSpecProto::InitAsDefaultInstance() {
-}
-class ShardingSpecProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<ShardingSpecProto>()._has_bits_);
-  static void set_has_tensor_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-ShardingSpecProto::ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  device_(arena),
-  index_to_device_group_map_(arena),
-  sharded_dim_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ShardingSpecProto)
-}
-ShardingSpecProto::ShardingSpecProto(const ShardingSpecProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      device_(from.device_),
-      index_to_device_group_map_(from.index_to_device_group_map_),
-      sharded_dim_(from.sharded_dim_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_tensor_name()) {
-    tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_tensor_name(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.ShardingSpecProto)
-}
-
-void ShardingSpecProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ShardingSpecProto_onnx_2eproto.base);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-ShardingSpecProto::~ShardingSpecProto() {
-  // @@protoc_insertion_point(destructor:onnx.ShardingSpecProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ShardingSpecProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  tensor_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void ShardingSpecProto::ArenaDtor(void* object) {
-  ShardingSpecProto* _this = reinterpret_cast< ShardingSpecProto* >(object);
-  (void)_this;
-}
-void ShardingSpecProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ShardingSpecProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ShardingSpecProto& ShardingSpecProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ShardingSpecProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void ShardingSpecProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ShardingSpecProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  device_.Clear();
-  index_to_device_group_map_.Clear();
-  sharded_dim_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    tensor_name_.ClearNonDefaultToEmpty();
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ShardingSpecProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string tensor_name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_tensor_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 device = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_device(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_device(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_index_to_device_group_map(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ShardedDimProto sharded_dim = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sharded_dim(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ShardingSpecProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ShardingSpecProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string tensor_name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_tensor_name(), target);
-  }
-
-  // repeated int64 device = 2;
-  for (int i = 0, n = this->_internal_device_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_device(i), target);
-  }
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_index_to_device_group_map_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, this->_internal_index_to_device_group_map(i), target, stream);
-  }
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sharded_dim_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_sharded_dim(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ShardingSpecProto)
-  return target;
-}
-
-size_t ShardingSpecProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ShardingSpecProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 device = 2;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->device_);
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_device_size());
-    total_size += data_size;
-  }
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  total_size += 1UL * this->_internal_index_to_device_group_map_size();
-  for (const auto& msg : this->index_to_device_group_map_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  total_size += 1UL * this->_internal_sharded_dim_size();
-  for (const auto& msg : this->sharded_dim_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // optional string tensor_name = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_tensor_name());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ShardingSpecProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ShardingSpecProto*>(
-      &from));
-}
-
-void ShardingSpecProto::MergeFrom(const ShardingSpecProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ShardingSpecProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  device_.MergeFrom(from.device_);
-  index_to_device_group_map_.MergeFrom(from.index_to_device_group_map_);
-  sharded_dim_.MergeFrom(from.sharded_dim_);
-  if (from._internal_has_tensor_name()) {
-    _internal_set_tensor_name(from._internal_tensor_name());
-  }
-}
-
-void ShardingSpecProto::CopyFrom(const ShardingSpecProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ShardingSpecProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ShardingSpecProto::IsInitialized() const {
-  return true;
-}
-
-void ShardingSpecProto::InternalSwap(ShardingSpecProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  device_.InternalSwap(&other->device_);
-  index_to_device_group_map_.InternalSwap(&other->index_to_device_group_map_);
-  sharded_dim_.InternalSwap(&other->sharded_dim_);
-  tensor_name_.Swap(&other->tensor_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string ShardingSpecProto::GetTypeName() const {
-  return "onnx.ShardingSpecProto";
-}
-
-
-// ===================================================================
-
-void ShardedDimProto::InitAsDefaultInstance() {
-}
-class ShardedDimProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<ShardedDimProto>()._has_bits_);
-  static void set_has_axis(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-ShardedDimProto::ShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  simple_sharding_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ShardedDimProto)
-}
-ShardedDimProto::ShardedDimProto(const ShardedDimProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      simple_sharding_(from.simple_sharding_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  axis_ = from.axis_;
-  // @@protoc_insertion_point(copy_constructor:onnx.ShardedDimProto)
-}
-
-void ShardedDimProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ShardedDimProto_onnx_2eproto.base);
-  axis_ = PROTOBUF_LONGLONG(0);
-}
-
-ShardedDimProto::~ShardedDimProto() {
-  // @@protoc_insertion_point(destructor:onnx.ShardedDimProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ShardedDimProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void ShardedDimProto::ArenaDtor(void* object) {
-  ShardedDimProto* _this = reinterpret_cast< ShardedDimProto* >(object);
-  (void)_this;
-}
-void ShardedDimProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ShardedDimProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ShardedDimProto& ShardedDimProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ShardedDimProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void ShardedDimProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  simple_sharding_.Clear();
-  axis_ = PROTOBUF_LONGLONG(0);
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ShardedDimProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int64 axis = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_axis(&has_bits);
-          axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_simple_sharding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ShardedDimProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int64 axis = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_axis(), target);
-  }
-
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_simple_sharding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_simple_sharding(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ShardedDimProto)
-  return target;
-}
-
-size_t ShardedDimProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ShardedDimProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  total_size += 1UL * this->_internal_simple_sharding_size();
-  for (const auto& msg : this->simple_sharding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // optional int64 axis = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_axis());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ShardedDimProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ShardedDimProto*>(
-      &from));
-}
-
-void ShardedDimProto::MergeFrom(const ShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ShardedDimProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  simple_sharding_.MergeFrom(from.simple_sharding_);
-  if (from._internal_has_axis()) {
-    _internal_set_axis(from._internal_axis());
-  }
-}
-
-void ShardedDimProto::CopyFrom(const ShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ShardedDimProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ShardedDimProto::IsInitialized() const {
-  return true;
-}
-
-void ShardedDimProto::InternalSwap(ShardedDimProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  simple_sharding_.InternalSwap(&other->simple_sharding_);
-  swap(axis_, other->axis_);
-}
-
-std::string ShardedDimProto::GetTypeName() const {
-  return "onnx.ShardedDimProto";
-}
-
-
-// ===================================================================
-
-void SimpleShardedDimProto::InitAsDefaultInstance() {
-}
-class SimpleShardedDimProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<SimpleShardedDimProto>()._has_bits_);
-  static void set_has_num_shards(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-SimpleShardedDimProto::SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.SimpleShardedDimProto)
-}
-SimpleShardedDimProto::SimpleShardedDimProto(const SimpleShardedDimProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  num_shards_ = from.num_shards_;
-  clear_has_dim();
-  switch (from.dim_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.SimpleShardedDimProto)
-}
-
-void SimpleShardedDimProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SimpleShardedDimProto_onnx_2eproto.base);
-  num_shards_ = PROTOBUF_LONGLONG(0);
-  clear_has_dim();
-}
-
-SimpleShardedDimProto::~SimpleShardedDimProto() {
-  // @@protoc_insertion_point(destructor:onnx.SimpleShardedDimProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void SimpleShardedDimProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (has_dim()) {
-    clear_dim();
-  }
-}
-
-void SimpleShardedDimProto::ArenaDtor(void* object) {
-  SimpleShardedDimProto* _this = reinterpret_cast< SimpleShardedDimProto* >(object);
-  (void)_this;
-}
-void SimpleShardedDimProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void SimpleShardedDimProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const SimpleShardedDimProto& SimpleShardedDimProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SimpleShardedDimProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void SimpleShardedDimProto::clear_dim() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.SimpleShardedDimProto)
-  switch (dim_case()) {
-    case kDimValue: {
-      // No need to clear
-      break;
-    }
-    case kDimParam: {
-      dim_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = DIM_NOT_SET;
-}
-
-
-void SimpleShardedDimProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.SimpleShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  num_shards_ = PROTOBUF_LONGLONG(0);
-  clear_dim();
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* SimpleShardedDimProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 dim_value = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string dim_param = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_dim_param();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int64 num_shards = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          _Internal::set_has_num_shards(&has_bits);
-          num_shards_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* SimpleShardedDimProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.SimpleShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  switch (dim_case()) {
-    case kDimValue: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_dim_value(), target);
-      break;
-    }
-    case kDimParam: {
-      target = stream->WriteStringMaybeAliased(
-          2, this->_internal_dim_param(), target);
-      break;
-    }
-    default: ;
-  }
-  cached_has_bits = _has_bits_[0];
-  // optional int64 num_shards = 3;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_num_shards(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.SimpleShardedDimProto)
-  return target;
-}
-
-size_t SimpleShardedDimProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.SimpleShardedDimProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // optional int64 num_shards = 3;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_num_shards());
-  }
-
-  switch (dim_case()) {
-    // int64 dim_value = 1;
-    case kDimValue: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_dim_value());
-      break;
-    }
-    // string dim_param = 2;
-    case kDimParam: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void SimpleShardedDimProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SimpleShardedDimProto*>(
-      &from));
-}
-
-void SimpleShardedDimProto::MergeFrom(const SimpleShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.SimpleShardedDimProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from._internal_has_num_shards()) {
-    _internal_set_num_shards(from._internal_num_shards());
-  }
-  switch (from.dim_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void SimpleShardedDimProto::CopyFrom(const SimpleShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.SimpleShardedDimProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SimpleShardedDimProto::IsInitialized() const {
-  return true;
-}
-
-void SimpleShardedDimProto::InternalSwap(SimpleShardedDimProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  swap(num_shards_, other->num_shards_);
-  swap(dim_, other->dim_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string SimpleShardedDimProto::GetTypeName() const {
-  return "onnx.SimpleShardedDimProto";
-}
-
-
-// ===================================================================
-
-void TrainingInfoProto::InitAsDefaultInstance() {
-  ::onnx::_TrainingInfoProto_default_instance_._instance.get_mutable()->initialization_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-  ::onnx::_TrainingInfoProto_default_instance_._instance.get_mutable()->algorithm_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-}
-class TrainingInfoProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<TrainingInfoProto>()._has_bits_);
-  static const ::onnx::GraphProto& initialization(const TrainingInfoProto* msg);
-  static void set_has_initialization(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static const ::onnx::GraphProto& algorithm(const TrainingInfoProto* msg);
-  static void set_has_algorithm(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-const ::onnx::GraphProto&
-TrainingInfoProto::_Internal::initialization(const TrainingInfoProto* msg) {
-  return *msg->initialization_;
-}
-const ::onnx::GraphProto&
-TrainingInfoProto::_Internal::algorithm(const TrainingInfoProto* msg) {
-  return *msg->algorithm_;
-}
-TrainingInfoProto::TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  initialization_binding_(arena),
-  update_binding_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TrainingInfoProto)
-}
-TrainingInfoProto::TrainingInfoProto(const TrainingInfoProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      initialization_binding_(from.initialization_binding_),
-      update_binding_(from.update_binding_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_initialization()) {
-    initialization_ = new ::onnx::GraphProto(*from.initialization_);
-  } else {
-    initialization_ = nullptr;
-  }
-  if (from._internal_has_algorithm()) {
-    algorithm_ = new ::onnx::GraphProto(*from.algorithm_);
-  } else {
-    algorithm_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TrainingInfoProto)
-}
-
-void TrainingInfoProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainingInfoProto_onnx_2eproto.base);
-  ::memset(&initialization_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&algorithm_) -
-      reinterpret_cast<char*>(&initialization_)) + sizeof(algorithm_));
-}
-
-TrainingInfoProto::~TrainingInfoProto() {
-  // @@protoc_insertion_point(destructor:onnx.TrainingInfoProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TrainingInfoProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete initialization_;
-  if (this != internal_default_instance()) delete algorithm_;
-}
-
-void TrainingInfoProto::ArenaDtor(void* object) {
-  TrainingInfoProto* _this = reinterpret_cast< TrainingInfoProto* >(object);
-  (void)_this;
-}
-void TrainingInfoProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TrainingInfoProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TrainingInfoProto& TrainingInfoProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TrainingInfoProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TrainingInfoProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TrainingInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  initialization_binding_.Clear();
-  update_binding_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      GOOGLE_DCHECK(initialization_ != nullptr);
-      initialization_->Clear();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      GOOGLE_DCHECK(algorithm_ != nullptr);
-      algorithm_->Clear();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TrainingInfoProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional .onnx.GraphProto initialization = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_initialization(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.GraphProto algorithm = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_algorithm(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_initialization_binding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto update_binding = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_update_binding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TrainingInfoProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TrainingInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional .onnx.GraphProto initialization = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::initialization(this), target, stream);
-  }
-
-  // optional .onnx.GraphProto algorithm = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::algorithm(this), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_initialization_binding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, this->_internal_initialization_binding(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_update_binding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_update_binding(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TrainingInfoProto)
-  return target;
-}
-
-size_t TrainingInfoProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TrainingInfoProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  total_size += 1UL * this->_internal_initialization_binding_size();
-  for (const auto& msg : this->initialization_binding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  total_size += 1UL * this->_internal_update_binding_size();
-  for (const auto& msg : this->update_binding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional .onnx.GraphProto initialization = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *initialization_);
-    }
-
-    // optional .onnx.GraphProto algorithm = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *algorithm_);
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TrainingInfoProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TrainingInfoProto*>(
-      &from));
-}
-
-void TrainingInfoProto::MergeFrom(const TrainingInfoProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TrainingInfoProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  initialization_binding_.MergeFrom(from.initialization_binding_);
-  update_binding_.MergeFrom(from.update_binding_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_initialization()->::onnx::GraphProto::MergeFrom(from._internal_initialization());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_mutable_algorithm()->::onnx::GraphProto::MergeFrom(from._internal_algorithm());
-    }
-  }
-}
-
-void TrainingInfoProto::CopyFrom(const TrainingInfoProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TrainingInfoProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TrainingInfoProto::IsInitialized() const {
-  return true;
-}
-
-void TrainingInfoProto::InternalSwap(TrainingInfoProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  initialization_binding_.InternalSwap(&other->initialization_binding_);
-  update_binding_.InternalSwap(&other->update_binding_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TrainingInfoProto, algorithm_)
-      + sizeof(TrainingInfoProto::algorithm_)
-      - PROTOBUF_FIELD_OFFSET(TrainingInfoProto, initialization_)>(
-          reinterpret_cast<char*>(&initialization_),
-          reinterpret_cast<char*>(&other->initialization_));
-}
-
-std::string TrainingInfoProto::GetTypeName() const {
-  return "onnx.TrainingInfoProto";
-}
-
-
-// ===================================================================
-
-void ModelProto::InitAsDefaultInstance() {
-  ::onnx::_ModelProto_default_instance_._instance.get_mutable()->graph_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-}
-class ModelProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<ModelProto>()._has_bits_);
-  static void set_has_ir_version(HasBits* has_bits) {
-    (*has_bits)[0] |= 32u;
-  }
-  static void set_has_producer_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_producer_version(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_domain(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_model_version(HasBits* has_bits) {
-    (*has_bits)[0] |= 64u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 8u;
-  }
-  static const ::onnx::GraphProto& graph(const ModelProto* msg);
-  static void set_has_graph(HasBits* has_bits) {
-    (*has_bits)[0] |= 16u;
-  }
-};
-
-const ::onnx::GraphProto&
-ModelProto::_Internal::graph(const ModelProto* msg) {
-  return *msg->graph_;
-}
-ModelProto::ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  opset_import_(arena),
-  metadata_props_(arena),
-  training_info_(arena),
-  functions_(arena),
-  configuration_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ModelProto)
-}
-ModelProto::ModelProto(const ModelProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      opset_import_(from.opset_import_),
-      metadata_props_(from.metadata_props_),
-      training_info_(from.training_info_),
-      functions_(from.functions_),
-      configuration_(from.configuration_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  producer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_producer_name()) {
-    producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_producer_name(),
-      GetArena());
-  }
-  producer_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_producer_version()) {
-    producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_producer_version(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_domain()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_graph()) {
-    graph_ = new ::onnx::GraphProto(*from.graph_);
-  } else {
-    graph_ = nullptr;
-  }
-  ::memcpy(&ir_version_, &from.ir_version_,
-    static_cast<size_t>(reinterpret_cast<char*>(&model_version_) -
-    reinterpret_cast<char*>(&ir_version_)) + sizeof(model_version_));
-  // @@protoc_insertion_point(copy_constructor:onnx.ModelProto)
-}
-
-void ModelProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_onnx_2eproto.base);
-  producer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  producer_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&graph_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&model_version_) -
-      reinterpret_cast<char*>(&graph_)) + sizeof(model_version_));
-}
-
-ModelProto::~ModelProto() {
-  // @@protoc_insertion_point(destructor:onnx.ModelProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ModelProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  producer_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  producer_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete graph_;
-}
-
-void ModelProto::ArenaDtor(void* object) {
-  ModelProto* _this = reinterpret_cast< ModelProto* >(object);
-  (void)_this;
-}
-void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ModelProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ModelProto& ModelProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ModelProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void ModelProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ModelProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  opset_import_.Clear();
-  metadata_props_.Clear();
-  training_info_.Clear();
-  functions_.Clear();
-  configuration_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000001fu) {
-    if (cached_has_bits & 0x00000001u) {
-      producer_name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      producer_version_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      domain_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000008u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000010u) {
-      GOOGLE_DCHECK(graph_ != nullptr);
-      graph_->Clear();
-    }
-  }
-  if (cached_has_bits & 0x00000060u) {
-    ::memset(&ir_version_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&model_version_) -
-        reinterpret_cast<char*>(&ir_version_)) + sizeof(model_version_));
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ModelProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int64 ir_version = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_ir_version(&has_bits);
-          ir_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string producer_name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_producer_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string producer_version = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_producer_version();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string domain = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int64 model_version = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
-          _Internal::set_has_model_version(&has_bits);
-          model_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.GraphProto graph = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr = ctx->ParseMessage(_internal_mutable_graph(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.OperatorSetIdProto opset_import = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TrainingInfoProto training_info = 20;
-      case 20:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_training_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.FunctionProto functions = 25;
-      case 25:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_functions(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<202>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.DeviceConfigurationProto configuration = 26;
-      case 26:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_configuration(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<210>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ModelProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ModelProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int64 ir_version = 1;
-  if (cached_has_bits & 0x00000020u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_ir_version(), target);
-  }
-
-  // optional string producer_name = 2;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_producer_name(), target);
-  }
-
-  // optional string producer_version = 3;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_producer_version(), target);
-  }
-
-  // optional string domain = 4;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->WriteStringMaybeAliased(
-        4, this->_internal_domain(), target);
-  }
-
-  // optional int64 model_version = 5;
-  if (cached_has_bits & 0x00000040u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_model_version(), target);
-  }
-
-  // optional string doc_string = 6;
-  if (cached_has_bits & 0x00000008u) {
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_doc_string(), target);
-  }
-
-  // optional .onnx.GraphProto graph = 7;
-  if (cached_has_bits & 0x00000010u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        7, _Internal::graph(this), target, stream);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_opset_import_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(8, this->_internal_opset_import(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_metadata_props(i), target, stream);
-  }
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_training_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(20, this->_internal_training_info(i), target, stream);
-  }
-
-  // repeated .onnx.FunctionProto functions = 25;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_functions_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(25, this->_internal_functions(i), target, stream);
-  }
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_configuration_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(26, this->_internal_configuration(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ModelProto)
-  return target;
-}
-
-size_t ModelProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ModelProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  total_size += 1UL * this->_internal_opset_import_size();
-  for (const auto& msg : this->opset_import_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  total_size += 2UL * this->_internal_training_info_size();
-  for (const auto& msg : this->training_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.FunctionProto functions = 25;
-  total_size += 2UL * this->_internal_functions_size();
-  for (const auto& msg : this->functions_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  total_size += 2UL * this->_internal_configuration_size();
-  for (const auto& msg : this->configuration_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
-    // optional string producer_name = 2;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_producer_name());
-    }
-
-    // optional string producer_version = 3;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_producer_version());
-    }
-
-    // optional string domain = 4;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_domain());
-    }
-
-    // optional string doc_string = 6;
-    if (cached_has_bits & 0x00000008u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional .onnx.GraphProto graph = 7;
-    if (cached_has_bits & 0x00000010u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *graph_);
-    }
-
-    // optional int64 ir_version = 1;
-    if (cached_has_bits & 0x00000020u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_ir_version());
-    }
-
-    // optional int64 model_version = 5;
-    if (cached_has_bits & 0x00000040u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_model_version());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ModelProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ModelProto*>(
-      &from));
-}
-
-void ModelProto::MergeFrom(const ModelProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ModelProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  opset_import_.MergeFrom(from.opset_import_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  training_info_.MergeFrom(from.training_info_);
-  functions_.MergeFrom(from.functions_);
-  configuration_.MergeFrom(from.configuration_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_producer_name(from._internal_producer_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_producer_version(from._internal_producer_version());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_set_domain(from._internal_domain());
-    }
-    if (cached_has_bits & 0x00000008u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000010u) {
-      _internal_mutable_graph()->::onnx::GraphProto::MergeFrom(from._internal_graph());
-    }
-    if (cached_has_bits & 0x00000020u) {
-      ir_version_ = from.ir_version_;
-    }
-    if (cached_has_bits & 0x00000040u) {
-      model_version_ = from.model_version_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void ModelProto::CopyFrom(const ModelProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ModelProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ModelProto::IsInitialized() const {
-  return true;
-}
-
-void ModelProto::InternalSwap(ModelProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  opset_import_.InternalSwap(&other->opset_import_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  training_info_.InternalSwap(&other->training_info_);
-  functions_.InternalSwap(&other->functions_);
-  configuration_.InternalSwap(&other->configuration_);
-  producer_name_.Swap(&other->producer_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  producer_version_.Swap(&other->producer_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(ModelProto, model_version_)
-      + sizeof(ModelProto::model_version_)
-      - PROTOBUF_FIELD_OFFSET(ModelProto, graph_)>(
-          reinterpret_cast<char*>(&graph_),
-          reinterpret_cast<char*>(&other->graph_));
-}
-
-std::string ModelProto::GetTypeName() const {
-  return "onnx.ModelProto";
-}
-
-
-// ===================================================================
-
-void DeviceConfigurationProto::InitAsDefaultInstance() {
-}
-class DeviceConfigurationProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<DeviceConfigurationProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_num_devices(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-DeviceConfigurationProto::DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  device_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.DeviceConfigurationProto)
-}
-DeviceConfigurationProto::DeviceConfigurationProto(const DeviceConfigurationProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      device_(from.device_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  num_devices_ = from.num_devices_;
-  // @@protoc_insertion_point(copy_constructor:onnx.DeviceConfigurationProto)
-}
-
-void DeviceConfigurationProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeviceConfigurationProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  num_devices_ = 0;
-}
-
-DeviceConfigurationProto::~DeviceConfigurationProto() {
-  // @@protoc_insertion_point(destructor:onnx.DeviceConfigurationProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void DeviceConfigurationProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void DeviceConfigurationProto::ArenaDtor(void* object) {
-  DeviceConfigurationProto* _this = reinterpret_cast< DeviceConfigurationProto* >(object);
-  (void)_this;
-}
-void DeviceConfigurationProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void DeviceConfigurationProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const DeviceConfigurationProto& DeviceConfigurationProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DeviceConfigurationProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void DeviceConfigurationProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.DeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  device_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    name_.ClearNonDefaultToEmpty();
-  }
-  num_devices_ = 0;
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* DeviceConfigurationProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int32 num_devices = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          _Internal::set_has_num_devices(&has_bits);
-          num_devices_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated string device = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_device();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* DeviceConfigurationProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.DeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // optional int32 num_devices = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_devices(), target);
-  }
-
-  // repeated string device = 3;
-  for (int i = 0, n = this->_internal_device_size(); i < n; i++) {
-    const auto& s = this->_internal_device(i);
-    target = stream->WriteString(3, s, target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.DeviceConfigurationProto)
-  return target;
-}
-
-size_t DeviceConfigurationProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.DeviceConfigurationProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string device = 3;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(device_.size());
-  for (int i = 0, n = device_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      device_.Get(i));
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional string name = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional int32 num_devices = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_num_devices());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void DeviceConfigurationProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DeviceConfigurationProto*>(
-      &from));
-}
-
-void DeviceConfigurationProto::MergeFrom(const DeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.DeviceConfigurationProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  device_.MergeFrom(from.device_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      num_devices_ = from.num_devices_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void DeviceConfigurationProto::CopyFrom(const DeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.DeviceConfigurationProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool DeviceConfigurationProto::IsInitialized() const {
-  return true;
-}
-
-void DeviceConfigurationProto::InternalSwap(DeviceConfigurationProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  device_.InternalSwap(&other->device_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(num_devices_, other->num_devices_);
-}
-
-std::string DeviceConfigurationProto::GetTypeName() const {
-  return "onnx.DeviceConfigurationProto";
-}
-
-
-// ===================================================================
-
-void StringStringEntryProto::InitAsDefaultInstance() {
-}
-class StringStringEntryProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<StringStringEntryProto>()._has_bits_);
-  static void set_has_key(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_value(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-StringStringEntryProto::StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.StringStringEntryProto)
-}
-StringStringEntryProto::StringStringEntryProto(const StringStringEntryProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_key()) {
-    key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_key(),
-      GetArena());
-  }
-  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_value()) {
-    value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_value(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.StringStringEntryProto)
-}
-
-void StringStringEntryProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringStringEntryProto_onnx_2eproto.base);
-  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-StringStringEntryProto::~StringStringEntryProto() {
-  // @@protoc_insertion_point(destructor:onnx.StringStringEntryProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void StringStringEntryProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void StringStringEntryProto::ArenaDtor(void* object) {
-  StringStringEntryProto* _this = reinterpret_cast< StringStringEntryProto* >(object);
-  (void)_this;
-}
-void StringStringEntryProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void StringStringEntryProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const StringStringEntryProto& StringStringEntryProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StringStringEntryProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void StringStringEntryProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.StringStringEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      key_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      value_.ClearNonDefaultToEmpty();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* StringStringEntryProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string key = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_key();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string value = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_value();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* StringStringEntryProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.StringStringEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string key = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_key(), target);
-  }
-
-  // optional string value = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_value(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.StringStringEntryProto)
-  return target;
-}
-
-size_t StringStringEntryProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.StringStringEntryProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional string key = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_key());
-    }
-
-    // optional string value = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_value());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void StringStringEntryProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const StringStringEntryProto*>(
-      &from));
-}
-
-void StringStringEntryProto::MergeFrom(const StringStringEntryProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.StringStringEntryProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_key(from._internal_key());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_value(from._internal_value());
-    }
-  }
-}
-
-void StringStringEntryProto::CopyFrom(const StringStringEntryProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.StringStringEntryProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool StringStringEntryProto::IsInitialized() const {
-  return true;
-}
-
-void StringStringEntryProto::InternalSwap(StringStringEntryProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string StringStringEntryProto::GetTypeName() const {
-  return "onnx.StringStringEntryProto";
-}
-
-
-// ===================================================================
-
-void TensorAnnotation::InitAsDefaultInstance() {
-}
-class TensorAnnotation::_Internal {
- public:
-  using HasBits = decltype(std::declval<TensorAnnotation>()._has_bits_);
-  static void set_has_tensor_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-TensorAnnotation::TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  quant_parameter_tensor_names_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorAnnotation)
-}
-TensorAnnotation::TensorAnnotation(const TensorAnnotation& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      quant_parameter_tensor_names_(from.quant_parameter_tensor_names_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_tensor_name()) {
-    tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_tensor_name(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorAnnotation)
-}
-
-void TensorAnnotation::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorAnnotation_onnx_2eproto.base);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-TensorAnnotation::~TensorAnnotation() {
-  // @@protoc_insertion_point(destructor:onnx.TensorAnnotation)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorAnnotation::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  tensor_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void TensorAnnotation::ArenaDtor(void* object) {
-  TensorAnnotation* _this = reinterpret_cast< TensorAnnotation* >(object);
-  (void)_this;
-}
-void TensorAnnotation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorAnnotation::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorAnnotation& TensorAnnotation::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorAnnotation_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TensorAnnotation::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorAnnotation)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  quant_parameter_tensor_names_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    tensor_name_.ClearNonDefaultToEmpty();
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorAnnotation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string tensor_name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_tensor_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_quant_parameter_tensor_names(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorAnnotation::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorAnnotation)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string tensor_name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_tensor_name(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_quant_parameter_tensor_names_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_quant_parameter_tensor_names(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorAnnotation)
-  return target;
-}
-
-size_t TensorAnnotation::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorAnnotation)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  total_size += 1UL * this->_internal_quant_parameter_tensor_names_size();
-  for (const auto& msg : this->quant_parameter_tensor_names_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // optional string tensor_name = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_tensor_name());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorAnnotation::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorAnnotation*>(
-      &from));
-}
-
-void TensorAnnotation::MergeFrom(const TensorAnnotation& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorAnnotation)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  quant_parameter_tensor_names_.MergeFrom(from.quant_parameter_tensor_names_);
-  if (from._internal_has_tensor_name()) {
-    _internal_set_tensor_name(from._internal_tensor_name());
-  }
-}
-
-void TensorAnnotation::CopyFrom(const TensorAnnotation& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorAnnotation)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorAnnotation::IsInitialized() const {
-  return true;
-}
-
-void TensorAnnotation::InternalSwap(TensorAnnotation* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  quant_parameter_tensor_names_.InternalSwap(&other->quant_parameter_tensor_names_);
-  tensor_name_.Swap(&other->tensor_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string TensorAnnotation::GetTypeName() const {
-  return "onnx.TensorAnnotation";
-}
-
-
-// ===================================================================
-
-void GraphProto::InitAsDefaultInstance() {
-}
-class GraphProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<GraphProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-GraphProto::GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  node_(arena),
-  initializer_(arena),
-  input_(arena),
-  output_(arena),
-  value_info_(arena),
-  quantization_annotation_(arena),
-  sparse_initializer_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.GraphProto)
-}
-GraphProto::GraphProto(const GraphProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      node_(from.node_),
-      initializer_(from.initializer_),
-      input_(from.input_),
-      output_(from.output_),
-      value_info_(from.value_info_),
-      quantization_annotation_(from.quantization_annotation_),
-      sparse_initializer_(from.sparse_initializer_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.GraphProto)
-}
-
-void GraphProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-GraphProto::~GraphProto() {
-  // @@protoc_insertion_point(destructor:onnx.GraphProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void GraphProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GraphProto::ArenaDtor(void* object) {
-  GraphProto* _this = reinterpret_cast< GraphProto* >(object);
-  (void)_this;
-}
-void GraphProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GraphProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const GraphProto& GraphProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void GraphProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.GraphProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  node_.Clear();
-  initializer_.Clear();
-  input_.Clear();
-  output_.Clear();
-  value_info_.Clear();
-  quantization_annotation_.Clear();
-  sparse_initializer_.Clear();
-  metadata_props_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* GraphProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated .onnx.NodeProto node = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_node(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorProto initializer = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_initializer(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto input = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_input(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto output = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_output(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto value_info = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_value_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_quantization_annotation(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-      case 15:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sparse_initializer(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 16;
-      case 16:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* GraphProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.GraphProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated .onnx.NodeProto node = 1;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_node_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, this->_internal_node(i), target, stream);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 2;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_name(), target);
-  }
-
-  // repeated .onnx.TensorProto initializer = 5;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_initializer_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(5, this->_internal_initializer(i), target, stream);
-  }
-
-  // optional string doc_string = 10;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        10, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_input_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_input(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_output_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(12, this->_internal_output(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_value_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(13, this->_internal_value_info(i), target, stream);
-  }
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_quantization_annotation_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_quantization_annotation(i), target, stream);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sparse_initializer_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(15, this->_internal_sparse_initializer(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(16, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.GraphProto)
-  return target;
-}
-
-size_t GraphProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.GraphProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.NodeProto node = 1;
-  total_size += 1UL * this->_internal_node_size();
-  for (const auto& msg : this->node_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TensorProto initializer = 5;
-  total_size += 1UL * this->_internal_initializer_size();
-  for (const auto& msg : this->initializer_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  total_size += 1UL * this->_internal_input_size();
-  for (const auto& msg : this->input_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  total_size += 1UL * this->_internal_output_size();
-  for (const auto& msg : this->output_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  total_size += 1UL * this->_internal_value_info_size();
-  for (const auto& msg : this->value_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  total_size += 1UL * this->_internal_quantization_annotation_size();
-  for (const auto& msg : this->quantization_annotation_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  total_size += 1UL * this->_internal_sparse_initializer_size();
-  for (const auto& msg : this->sparse_initializer_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  total_size += 2UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional string name = 2;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional string doc_string = 10;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void GraphProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const GraphProto*>(
-      &from));
-}
-
-void GraphProto::MergeFrom(const GraphProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.GraphProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  node_.MergeFrom(from.node_);
-  initializer_.MergeFrom(from.initializer_);
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  value_info_.MergeFrom(from.value_info_);
-  quantization_annotation_.MergeFrom(from.quantization_annotation_);
-  sparse_initializer_.MergeFrom(from.sparse_initializer_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-  }
-}
-
-void GraphProto::CopyFrom(const GraphProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.GraphProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GraphProto::IsInitialized() const {
-  return true;
-}
-
-void GraphProto::InternalSwap(GraphProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  node_.InternalSwap(&other->node_);
-  initializer_.InternalSwap(&other->initializer_);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  value_info_.InternalSwap(&other->value_info_);
-  quantization_annotation_.InternalSwap(&other->quantization_annotation_);
-  sparse_initializer_.InternalSwap(&other->sparse_initializer_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string GraphProto::GetTypeName() const {
-  return "onnx.GraphProto";
-}
-
-
-// ===================================================================
-
-void TensorProto_Segment::InitAsDefaultInstance() {
-}
-class TensorProto_Segment::_Internal {
- public:
-  using HasBits = decltype(std::declval<TensorProto_Segment>()._has_bits_);
-  static void set_has_begin(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_end(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-TensorProto_Segment::TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorProto.Segment)
-}
-TensorProto_Segment::TensorProto_Segment(const TensorProto_Segment& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::memcpy(&begin_, &from.begin_,
-    static_cast<size_t>(reinterpret_cast<char*>(&end_) -
-    reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorProto.Segment)
-}
-
-void TensorProto_Segment::SharedCtor() {
-  ::memset(&begin_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&end_) -
-      reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-}
-
-TensorProto_Segment::~TensorProto_Segment() {
-  // @@protoc_insertion_point(destructor:onnx.TensorProto.Segment)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorProto_Segment::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void TensorProto_Segment::ArenaDtor(void* object) {
-  TensorProto_Segment* _this = reinterpret_cast< TensorProto_Segment* >(object);
-  (void)_this;
-}
-void TensorProto_Segment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorProto_Segment::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorProto_Segment& TensorProto_Segment::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorProto_Segment_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TensorProto_Segment::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorProto.Segment)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    ::memset(&begin_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&end_) -
-        reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorProto_Segment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int64 begin = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_begin(&has_bits);
-          begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int64 end = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          _Internal::set_has_end(&has_bits);
-          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorProto_Segment::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto.Segment)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int64 begin = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_begin(), target);
-  }
-
-  // optional int64 end = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_end(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto.Segment)
-  return target;
-}
-
-size_t TensorProto_Segment::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto.Segment)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional int64 begin = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_begin());
-    }
-
-    // optional int64 end = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_end());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorProto_Segment::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorProto_Segment*>(
-      &from));
-}
-
-void TensorProto_Segment::MergeFrom(const TensorProto_Segment& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto.Segment)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      begin_ = from.begin_;
-    }
-    if (cached_has_bits & 0x00000002u) {
-      end_ = from.end_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void TensorProto_Segment::CopyFrom(const TensorProto_Segment& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto.Segment)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorProto_Segment::IsInitialized() const {
-  return true;
-}
-
-void TensorProto_Segment::InternalSwap(TensorProto_Segment* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TensorProto_Segment, end_)
-      + sizeof(TensorProto_Segment::end_)
-      - PROTOBUF_FIELD_OFFSET(TensorProto_Segment, begin_)>(
-          reinterpret_cast<char*>(&begin_),
-          reinterpret_cast<char*>(&other->begin_));
-}
-
-std::string TensorProto_Segment::GetTypeName() const {
-  return "onnx.TensorProto.Segment";
-}
-
-
-// ===================================================================
-
-void TensorProto::InitAsDefaultInstance() {
-  ::onnx::_TensorProto_default_instance_._instance.get_mutable()->segment_ = const_cast< ::onnx::TensorProto_Segment*>(
-      ::onnx::TensorProto_Segment::internal_default_instance());
-}
-class TensorProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<TensorProto>()._has_bits_);
-  static void set_has_data_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 16u;
-  }
-  static const ::onnx::TensorProto_Segment& segment(const TensorProto* msg);
-  static void set_has_segment(HasBits* has_bits) {
-    (*has_bits)[0] |= 8u;
-  }
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_raw_data(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_data_location(HasBits* has_bits) {
-    (*has_bits)[0] |= 32u;
-  }
-};
-
-const ::onnx::TensorProto_Segment&
-TensorProto::_Internal::segment(const TensorProto* msg) {
-  return *msg->segment_;
-}
-TensorProto::TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dims_(arena),
-  float_data_(arena),
-  int32_data_(arena),
-  string_data_(arena),
-  int64_data_(arena),
-  double_data_(arena),
-  uint64_data_(arena),
-  external_data_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorProto)
-}
-TensorProto::TensorProto(const TensorProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      dims_(from.dims_),
-      float_data_(from.float_data_),
-      int32_data_(from.int32_data_),
-      string_data_(from.string_data_),
-      int64_data_(from.int64_data_),
-      double_data_(from.double_data_),
-      uint64_data_(from.uint64_data_),
-      external_data_(from.external_data_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_raw_data()) {
-    raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_raw_data(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_segment()) {
-    segment_ = new ::onnx::TensorProto_Segment(*from.segment_);
-  } else {
-    segment_ = nullptr;
-  }
-  ::memcpy(&data_type_, &from.data_type_,
-    static_cast<size_t>(reinterpret_cast<char*>(&data_location_) -
-    reinterpret_cast<char*>(&data_type_)) + sizeof(data_location_));
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorProto)
-}
-
-void TensorProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&segment_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&data_location_) -
-      reinterpret_cast<char*>(&segment_)) + sizeof(data_location_));
-}
-
-TensorProto::~TensorProto() {
-  // @@protoc_insertion_point(destructor:onnx.TensorProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  raw_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete segment_;
-}
-
-void TensorProto::ArenaDtor(void* object) {
-  TensorProto* _this = reinterpret_cast< TensorProto* >(object);
-  (void)_this;
-}
-void TensorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorProto& TensorProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TensorProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dims_.Clear();
-  float_data_.Clear();
-  int32_data_.Clear();
-  string_data_.Clear();
-  int64_data_.Clear();
-  double_data_.Clear();
-  uint64_data_.Clear();
-  external_data_.Clear();
-  metadata_props_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000000fu) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      raw_data_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000008u) {
-      GOOGLE_DCHECK(segment_ != nullptr);
-      segment_->Clear();
-    }
-  }
-  if (cached_has_bits & 0x00000030u) {
-    ::memset(&data_type_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&data_location_) -
-        reinterpret_cast<char*>(&data_type_)) + sizeof(data_location_));
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated int64 dims = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_dims(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dims(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int32 data_type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          _Internal::set_has_data_type(&has_bits);
-          data_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorProto.Segment segment = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr = ctx->ParseMessage(_internal_mutable_segment(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated float float_data = 4 [packed = true];
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_float_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) {
-          _internal_add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
-          ptr += sizeof(float);
-        } else goto handle_unusual;
-        continue;
-      // repeated int32 int32_data = 5 [packed = true];
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_int32_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40) {
-          _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated bytes string_data = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_string_data();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 int64_data = 7 [packed = true];
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_int64_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56) {
-          _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string name = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional bytes raw_data = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          auto str = _internal_mutable_raw_data();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated double double_data = 10 [packed = true];
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 81) {
-          _internal_add_double_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
-          ptr += sizeof(double);
-        } else goto handle_unusual;
-        continue;
-      // repeated uint64 uint64_data = 11 [packed = true];
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_uint64_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88) {
-          _internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto external_data = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_external_data(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorProto.DataLocation data_location = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
-          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-          if (PROTOBUF_PREDICT_TRUE(::onnx::TensorProto_DataLocation_IsValid(val))) {
-            _internal_set_data_location(static_cast<::onnx::TensorProto_DataLocation>(val));
-          } else {
-            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields());
-          }
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 16;
-      case 16:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 1;
-  for (int i = 0, n = this->_internal_dims_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_dims(i), target);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  // optional int32 data_type = 2;
-  if (cached_has_bits & 0x00000010u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_data_type(), target);
-  }
-
-  // optional .onnx.TensorProto.Segment segment = 3;
-  if (cached_has_bits & 0x00000008u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        3, _Internal::segment(this), target, stream);
-  }
-
-  // repeated float float_data = 4 [packed = true];
-  if (this->_internal_float_data_size() > 0) {
-    target = stream->WriteFixedPacked(4, _internal_float_data(), target);
-  }
-
-  // repeated int32 int32_data = 5 [packed = true];
-  {
-    int byte_size = _int32_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt32Packed(
-          5, _internal_int32_data(), byte_size, target);
-    }
-  }
-
-  // repeated bytes string_data = 6;
-  for (int i = 0, n = this->_internal_string_data_size(); i < n; i++) {
-    const auto& s = this->_internal_string_data(i);
-    target = stream->WriteBytes(6, s, target);
-  }
-
-  // repeated int64 int64_data = 7 [packed = true];
-  {
-    int byte_size = _int64_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          7, _internal_int64_data(), byte_size, target);
-    }
-  }
-
-  // optional string name = 8;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_name(), target);
-  }
-
-  // optional bytes raw_data = 9;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteBytesMaybeAliased(
-        9, this->_internal_raw_data(), target);
-  }
-
-  // repeated double double_data = 10 [packed = true];
-  if (this->_internal_double_data_size() > 0) {
-    target = stream->WriteFixedPacked(10, _internal_double_data(), target);
-  }
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  {
-    int byte_size = _uint64_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteUInt64Packed(
-          11, _internal_uint64_data(), byte_size, target);
-    }
-  }
-
-  // optional string doc_string = 12;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->WriteStringMaybeAliased(
-        12, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_external_data_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(13, this->_internal_external_data(i), target, stream);
-  }
-
-  // optional .onnx.TensorProto.DataLocation data_location = 14;
-  if (cached_has_bits & 0x00000020u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
-      14, this->_internal_data_location(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(16, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto)
-  return target;
-}
-
-size_t TensorProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 1;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->dims_);
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_dims_size());
-    total_size += data_size;
-  }
-
-  // repeated float float_data = 4 [packed = true];
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_float_data_size());
-    size_t data_size = 4UL * count;
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _float_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated int32 int32_data = 5 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int32Size(this->int32_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _int32_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated bytes string_data = 6;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_data_.size());
-  for (int i = 0, n = string_data_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      string_data_.Get(i));
-  }
-
-  // repeated int64 int64_data = 7 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->int64_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _int64_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated double double_data = 10 [packed = true];
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_double_data_size());
-    size_t data_size = 8UL * count;
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _double_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      UInt64Size(this->uint64_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _uint64_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  total_size += 1UL * this->_internal_external_data_size();
-  for (const auto& msg : this->external_data_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  total_size += 2UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000003fu) {
-    // optional string name = 8;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional bytes raw_data = 9;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-          this->_internal_raw_data());
-    }
-
-    // optional string doc_string = 12;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional .onnx.TensorProto.Segment segment = 3;
-    if (cached_has_bits & 0x00000008u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *segment_);
-    }
-
-    // optional int32 data_type = 2;
-    if (cached_has_bits & 0x00000010u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_data_type());
-    }
-
-    // optional .onnx.TensorProto.DataLocation data_location = 14;
-    if (cached_has_bits & 0x00000020u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_data_location());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorProto*>(
-      &from));
-}
-
-void TensorProto::MergeFrom(const TensorProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dims_.MergeFrom(from.dims_);
-  float_data_.MergeFrom(from.float_data_);
-  int32_data_.MergeFrom(from.int32_data_);
-  string_data_.MergeFrom(from.string_data_);
-  int64_data_.MergeFrom(from.int64_data_);
-  double_data_.MergeFrom(from.double_data_);
-  uint64_data_.MergeFrom(from.uint64_data_);
-  external_data_.MergeFrom(from.external_data_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000003fu) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_raw_data(from._internal_raw_data());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000008u) {
-      _internal_mutable_segment()->::onnx::TensorProto_Segment::MergeFrom(from._internal_segment());
-    }
-    if (cached_has_bits & 0x00000010u) {
-      data_type_ = from.data_type_;
-    }
-    if (cached_has_bits & 0x00000020u) {
-      data_location_ = from.data_location_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void TensorProto::CopyFrom(const TensorProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorProto::IsInitialized() const {
-  return true;
-}
-
-void TensorProto::InternalSwap(TensorProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  dims_.InternalSwap(&other->dims_);
-  float_data_.InternalSwap(&other->float_data_);
-  int32_data_.InternalSwap(&other->int32_data_);
-  string_data_.InternalSwap(&other->string_data_);
-  int64_data_.InternalSwap(&other->int64_data_);
-  double_data_.InternalSwap(&other->double_data_);
-  uint64_data_.InternalSwap(&other->uint64_data_);
-  external_data_.InternalSwap(&other->external_data_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  raw_data_.Swap(&other->raw_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TensorProto, data_location_)
-      + sizeof(TensorProto::data_location_)
-      - PROTOBUF_FIELD_OFFSET(TensorProto, segment_)>(
-          reinterpret_cast<char*>(&segment_),
-          reinterpret_cast<char*>(&other->segment_));
-}
-
-std::string TensorProto::GetTypeName() const {
-  return "onnx.TensorProto";
-}
-
-
-// ===================================================================
-
-void SparseTensorProto::InitAsDefaultInstance() {
-  ::onnx::_SparseTensorProto_default_instance_._instance.get_mutable()->values_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-  ::onnx::_SparseTensorProto_default_instance_._instance.get_mutable()->indices_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-}
-class SparseTensorProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<SparseTensorProto>()._has_bits_);
-  static const ::onnx::TensorProto& values(const SparseTensorProto* msg);
-  static void set_has_values(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static const ::onnx::TensorProto& indices(const SparseTensorProto* msg);
-  static void set_has_indices(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-const ::onnx::TensorProto&
-SparseTensorProto::_Internal::values(const SparseTensorProto* msg) {
-  return *msg->values_;
-}
-const ::onnx::TensorProto&
-SparseTensorProto::_Internal::indices(const SparseTensorProto* msg) {
-  return *msg->indices_;
-}
-SparseTensorProto::SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dims_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.SparseTensorProto)
-}
-SparseTensorProto::SparseTensorProto(const SparseTensorProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      dims_(from.dims_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_values()) {
-    values_ = new ::onnx::TensorProto(*from.values_);
-  } else {
-    values_ = nullptr;
-  }
-  if (from._internal_has_indices()) {
-    indices_ = new ::onnx::TensorProto(*from.indices_);
-  } else {
-    indices_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.SparseTensorProto)
-}
-
-void SparseTensorProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SparseTensorProto_onnx_2eproto.base);
-  ::memset(&values_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&indices_) -
-      reinterpret_cast<char*>(&values_)) + sizeof(indices_));
-}
-
-SparseTensorProto::~SparseTensorProto() {
-  // @@protoc_insertion_point(destructor:onnx.SparseTensorProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void SparseTensorProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete values_;
-  if (this != internal_default_instance()) delete indices_;
-}
-
-void SparseTensorProto::ArenaDtor(void* object) {
-  SparseTensorProto* _this = reinterpret_cast< SparseTensorProto* >(object);
-  (void)_this;
-}
-void SparseTensorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void SparseTensorProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const SparseTensorProto& SparseTensorProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SparseTensorProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void SparseTensorProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.SparseTensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dims_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      GOOGLE_DCHECK(values_ != nullptr);
-      values_->Clear();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      GOOGLE_DCHECK(indices_ != nullptr);
-      indices_->Clear();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* SparseTensorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional .onnx.TensorProto values = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_values(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorProto indices = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_indices(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 dims = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            _internal_add_dims(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr));
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dims(), ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* SparseTensorProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.SparseTensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional .onnx.TensorProto values = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::values(this), target, stream);
-  }
-
-  // optional .onnx.TensorProto indices = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::indices(this), target, stream);
-  }
-
-  // repeated int64 dims = 3;
-  for (int i = 0, n = this->_internal_dims_size(); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_dims(i), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.SparseTensorProto)
-  return target;
-}
-
-size_t SparseTensorProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.SparseTensorProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 3;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->dims_);
-    total_size += 1 *
-                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_dims_size());
-    total_size += data_size;
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional .onnx.TensorProto values = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *values_);
-    }
-
-    // optional .onnx.TensorProto indices = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *indices_);
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void SparseTensorProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SparseTensorProto*>(
-      &from));
-}
-
-void SparseTensorProto::MergeFrom(const SparseTensorProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.SparseTensorProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dims_.MergeFrom(from.dims_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_values()->::onnx::TensorProto::MergeFrom(from._internal_values());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_mutable_indices()->::onnx::TensorProto::MergeFrom(from._internal_indices());
-    }
-  }
-}
-
-void SparseTensorProto::CopyFrom(const SparseTensorProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.SparseTensorProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SparseTensorProto::IsInitialized() const {
-  return true;
-}
-
-void SparseTensorProto::InternalSwap(SparseTensorProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  dims_.InternalSwap(&other->dims_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(SparseTensorProto, indices_)
-      + sizeof(SparseTensorProto::indices_)
-      - PROTOBUF_FIELD_OFFSET(SparseTensorProto, values_)>(
-          reinterpret_cast<char*>(&values_),
-          reinterpret_cast<char*>(&other->values_));
-}
-
-std::string SparseTensorProto::GetTypeName() const {
-  return "onnx.SparseTensorProto";
-}
-
-
-// ===================================================================
-
-void TensorShapeProto_Dimension::InitAsDefaultInstance() {
-}
-class TensorShapeProto_Dimension::_Internal {
- public:
-  using HasBits = decltype(std::declval<TensorShapeProto_Dimension>()._has_bits_);
-  static void set_has_denotation(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-TensorShapeProto_Dimension::TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto.Dimension)
-}
-TensorShapeProto_Dimension::TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_denotation()) {
-    denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_denotation(),
-      GetArena());
-  }
-  clear_has_value();
-  switch (from.value_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto.Dimension)
-}
-
-void TensorShapeProto_Dimension::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorShapeProto_Dimension_onnx_2eproto.base);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  clear_has_value();
-}
-
-TensorShapeProto_Dimension::~TensorShapeProto_Dimension() {
-  // @@protoc_insertion_point(destructor:onnx.TensorShapeProto.Dimension)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorShapeProto_Dimension::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  denotation_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (has_value()) {
-    clear_value();
-  }
-}
-
-void TensorShapeProto_Dimension::ArenaDtor(void* object) {
-  TensorShapeProto_Dimension* _this = reinterpret_cast< TensorShapeProto_Dimension* >(object);
-  (void)_this;
-}
-void TensorShapeProto_Dimension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorShapeProto_Dimension::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorShapeProto_Dimension& TensorShapeProto_Dimension::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorShapeProto_Dimension_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TensorShapeProto_Dimension::clear_value() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.TensorShapeProto.Dimension)
-  switch (value_case()) {
-    case kDimValue: {
-      // No need to clear
-      break;
-    }
-    case kDimParam: {
-      value_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-
-
-void TensorShapeProto_Dimension::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto.Dimension)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    denotation_.ClearNonDefaultToEmpty();
-  }
-  clear_value();
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorShapeProto_Dimension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 dim_value = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string dim_param = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_dim_param();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string denotation = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_denotation();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorShapeProto_Dimension::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto.Dimension)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  switch (value_case()) {
-    case kDimValue: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_dim_value(), target);
-      break;
-    }
-    case kDimParam: {
-      target = stream->WriteStringMaybeAliased(
-          2, this->_internal_dim_param(), target);
-      break;
-    }
-    default: ;
-  }
-  cached_has_bits = _has_bits_[0];
-  // optional string denotation = 3;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_denotation(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto.Dimension)
-  return target;
-}
-
-size_t TensorShapeProto_Dimension::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto.Dimension)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // optional string denotation = 3;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_denotation());
-  }
-
-  switch (value_case()) {
-    // int64 dim_value = 1;
-    case kDimValue: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_dim_value());
-      break;
-    }
-    // string dim_param = 2;
-    case kDimParam: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorShapeProto_Dimension::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorShapeProto_Dimension*>(
-      &from));
-}
-
-void TensorShapeProto_Dimension::MergeFrom(const TensorShapeProto_Dimension& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto.Dimension)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from._internal_has_denotation()) {
-    _internal_set_denotation(from._internal_denotation());
-  }
-  switch (from.value_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void TensorShapeProto_Dimension::CopyFrom(const TensorShapeProto_Dimension& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto.Dimension)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorShapeProto_Dimension::IsInitialized() const {
-  return true;
-}
-
-void TensorShapeProto_Dimension::InternalSwap(TensorShapeProto_Dimension* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  denotation_.Swap(&other->denotation_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(value_, other->value_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string TensorShapeProto_Dimension::GetTypeName() const {
-  return "onnx.TensorShapeProto.Dimension";
-}
-
-
-// ===================================================================
-
-void TensorShapeProto::InitAsDefaultInstance() {
-}
-class TensorShapeProto::_Internal {
- public:
-};
-
-TensorShapeProto::TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dim_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto)
-}
-TensorShapeProto::TensorShapeProto(const TensorShapeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      dim_(from.dim_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto)
-}
-
-void TensorShapeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorShapeProto_onnx_2eproto.base);
-}
-
-TensorShapeProto::~TensorShapeProto() {
-  // @@protoc_insertion_point(destructor:onnx.TensorShapeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorShapeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void TensorShapeProto::ArenaDtor(void* object) {
-  TensorShapeProto* _this = reinterpret_cast< TensorShapeProto* >(object);
-  (void)_this;
-}
-void TensorShapeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorShapeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorShapeProto& TensorShapeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorShapeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TensorShapeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dim_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorShapeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_dim(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorShapeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_dim_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, this->_internal_dim(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto)
-  return target;
-}
-
-size_t TensorShapeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  total_size += 1UL * this->_internal_dim_size();
-  for (const auto& msg : this->dim_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorShapeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorShapeProto*>(
-      &from));
-}
-
-void TensorShapeProto::MergeFrom(const TensorShapeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dim_.MergeFrom(from.dim_);
-}
-
-void TensorShapeProto::CopyFrom(const TensorShapeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorShapeProto::IsInitialized() const {
-  return true;
-}
-
-void TensorShapeProto::InternalSwap(TensorShapeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  dim_.InternalSwap(&other->dim_);
-}
-
-std::string TensorShapeProto::GetTypeName() const {
-  return "onnx.TensorShapeProto";
-}
-
-
-// ===================================================================
-
-void TypeProto_Tensor::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Tensor_default_instance_._instance.get_mutable()->shape_ = const_cast< ::onnx::TensorShapeProto*>(
-      ::onnx::TensorShapeProto::internal_default_instance());
-}
-class TypeProto_Tensor::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto_Tensor>()._has_bits_);
-  static void set_has_elem_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static const ::onnx::TensorShapeProto& shape(const TypeProto_Tensor* msg);
-  static void set_has_shape(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TensorShapeProto&
-TypeProto_Tensor::_Internal::shape(const TypeProto_Tensor* msg) {
-  return *msg->shape_;
-}
-TypeProto_Tensor::TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Tensor)
-}
-TypeProto_Tensor::TypeProto_Tensor(const TypeProto_Tensor& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_shape()) {
-    shape_ = new ::onnx::TensorShapeProto(*from.shape_);
-  } else {
-    shape_ = nullptr;
-  }
-  elem_type_ = from.elem_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Tensor)
-}
-
-void TypeProto_Tensor::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_Tensor_onnx_2eproto.base);
-  ::memset(&shape_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&elem_type_) -
-      reinterpret_cast<char*>(&shape_)) + sizeof(elem_type_));
-}
-
-TypeProto_Tensor::~TypeProto_Tensor() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Tensor)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Tensor::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete shape_;
-}
-
-void TypeProto_Tensor::ArenaDtor(void* object) {
-  TypeProto_Tensor* _this = reinterpret_cast< TypeProto_Tensor* >(object);
-  (void)_this;
-}
-void TypeProto_Tensor::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Tensor::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Tensor& TypeProto_Tensor::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_Tensor_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Tensor::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Tensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    GOOGLE_DCHECK(shape_ != nullptr);
-    shape_->Clear();
-  }
-  elem_type_ = 0;
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Tensor::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int32 elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_elem_type(&has_bits);
-          elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorShapeProto shape = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Tensor::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Tensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int32 elem_type = 1;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_elem_type(), target);
-  }
-
-  // optional .onnx.TensorShapeProto shape = 2;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::shape(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Tensor)
-  return target;
-}
-
-size_t TypeProto_Tensor::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Tensor)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional .onnx.TensorShapeProto shape = 2;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *shape_);
-    }
-
-    // optional int32 elem_type = 1;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_elem_type());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Tensor::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Tensor*>(
-      &from));
-}
-
-void TypeProto_Tensor::MergeFrom(const TypeProto_Tensor& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Tensor)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom(from._internal_shape());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      elem_type_ = from.elem_type_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void TypeProto_Tensor::CopyFrom(const TypeProto_Tensor& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Tensor)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Tensor::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Tensor::InternalSwap(TypeProto_Tensor* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, elem_type_)
-      + sizeof(TypeProto_Tensor::elem_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, shape_)>(
-          reinterpret_cast<char*>(&shape_),
-          reinterpret_cast<char*>(&other->shape_));
-}
-
-std::string TypeProto_Tensor::GetTypeName() const {
-  return "onnx.TypeProto.Tensor";
-}
-
-
-// ===================================================================
-
-void TypeProto_Sequence::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Sequence_default_instance_._instance.get_mutable()->elem_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Sequence::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto_Sequence>()._has_bits_);
-  static const ::onnx::TypeProto& elem_type(const TypeProto_Sequence* msg);
-  static void set_has_elem_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TypeProto&
-TypeProto_Sequence::_Internal::elem_type(const TypeProto_Sequence* msg) {
-  return *msg->elem_type_;
-}
-TypeProto_Sequence::TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Sequence)
-}
-TypeProto_Sequence::TypeProto_Sequence(const TypeProto_Sequence& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_elem_type()) {
-    elem_type_ = new ::onnx::TypeProto(*from.elem_type_);
-  } else {
-    elem_type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Sequence)
-}
-
-void TypeProto_Sequence::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto.base);
-  elem_type_ = nullptr;
-}
-
-TypeProto_Sequence::~TypeProto_Sequence() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Sequence)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Sequence::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete elem_type_;
-}
-
-void TypeProto_Sequence::ArenaDtor(void* object) {
-  TypeProto_Sequence* _this = reinterpret_cast< TypeProto_Sequence* >(object);
-  (void)_this;
-}
-void TypeProto_Sequence::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Sequence::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Sequence& TypeProto_Sequence::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Sequence::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Sequence)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    GOOGLE_DCHECK(elem_type_ != nullptr);
-    elem_type_->Clear();
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Sequence::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional .onnx.TypeProto elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Sequence::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Sequence)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional .onnx.TypeProto elem_type = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::elem_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Sequence)
-  return target;
-}
-
-size_t TypeProto_Sequence::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Sequence)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // optional .onnx.TypeProto elem_type = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *elem_type_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Sequence::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Sequence*>(
-      &from));
-}
-
-void TypeProto_Sequence::MergeFrom(const TypeProto_Sequence& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Sequence)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from._internal_has_elem_type()) {
-    _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom(from._internal_elem_type());
-  }
-}
-
-void TypeProto_Sequence::CopyFrom(const TypeProto_Sequence& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Sequence)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Sequence::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Sequence::InternalSwap(TypeProto_Sequence* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  swap(elem_type_, other->elem_type_);
-}
-
-std::string TypeProto_Sequence::GetTypeName() const {
-  return "onnx.TypeProto.Sequence";
-}
-
-
-// ===================================================================
-
-void TypeProto_Map::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Map_default_instance_._instance.get_mutable()->value_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Map::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto_Map>()._has_bits_);
-  static void set_has_key_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static const ::onnx::TypeProto& value_type(const TypeProto_Map* msg);
-  static void set_has_value_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TypeProto&
-TypeProto_Map::_Internal::value_type(const TypeProto_Map* msg) {
-  return *msg->value_type_;
-}
-TypeProto_Map::TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Map)
-}
-TypeProto_Map::TypeProto_Map(const TypeProto_Map& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_value_type()) {
-    value_type_ = new ::onnx::TypeProto(*from.value_type_);
-  } else {
-    value_type_ = nullptr;
-  }
-  key_type_ = from.key_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Map)
-}
-
-void TypeProto_Map::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto.base);
-  ::memset(&value_type_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&key_type_) -
-      reinterpret_cast<char*>(&value_type_)) + sizeof(key_type_));
-}
-
-TypeProto_Map::~TypeProto_Map() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Map)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Map::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete value_type_;
-}
-
-void TypeProto_Map::ArenaDtor(void* object) {
-  TypeProto_Map* _this = reinterpret_cast< TypeProto_Map* >(object);
-  (void)_this;
-}
-void TypeProto_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Map::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Map& TypeProto_Map::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Map::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Map)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    GOOGLE_DCHECK(value_type_ != nullptr);
-    value_type_->Clear();
-  }
-  key_type_ = 0;
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int32 key_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_key_type(&has_bits);
-          key_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TypeProto value_type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_value_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Map::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Map)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int32 key_type = 1;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_key_type(), target);
-  }
-
-  // optional .onnx.TypeProto value_type = 2;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::value_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Map)
-  return target;
-}
-
-size_t TypeProto_Map::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Map)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional .onnx.TypeProto value_type = 2;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_type_);
-    }
-
-    // optional int32 key_type = 1;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_key_type());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Map::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Map*>(
-      &from));
-}
-
-void TypeProto_Map::MergeFrom(const TypeProto_Map& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Map)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_value_type()->::onnx::TypeProto::MergeFrom(from._internal_value_type());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      key_type_ = from.key_type_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void TypeProto_Map::CopyFrom(const TypeProto_Map& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Map)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Map::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Map::InternalSwap(TypeProto_Map* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_Map, key_type_)
-      + sizeof(TypeProto_Map::key_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_Map, value_type_)>(
-          reinterpret_cast<char*>(&value_type_),
-          reinterpret_cast<char*>(&other->value_type_));
-}
-
-std::string TypeProto_Map::GetTypeName() const {
-  return "onnx.TypeProto.Map";
-}
-
-
-// ===================================================================
-
-void TypeProto_Optional::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Optional_default_instance_._instance.get_mutable()->elem_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Optional::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto_Optional>()._has_bits_);
-  static const ::onnx::TypeProto& elem_type(const TypeProto_Optional* msg);
-  static void set_has_elem_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TypeProto&
-TypeProto_Optional::_Internal::elem_type(const TypeProto_Optional* msg) {
-  return *msg->elem_type_;
-}
-TypeProto_Optional::TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Optional)
-}
-TypeProto_Optional::TypeProto_Optional(const TypeProto_Optional& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_elem_type()) {
-    elem_type_ = new ::onnx::TypeProto(*from.elem_type_);
-  } else {
-    elem_type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Optional)
-}
-
-void TypeProto_Optional::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto.base);
-  elem_type_ = nullptr;
-}
-
-TypeProto_Optional::~TypeProto_Optional() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Optional)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Optional::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete elem_type_;
-}
-
-void TypeProto_Optional::ArenaDtor(void* object) {
-  TypeProto_Optional* _this = reinterpret_cast< TypeProto_Optional* >(object);
-  (void)_this;
-}
-void TypeProto_Optional::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Optional::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Optional& TypeProto_Optional::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Optional::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Optional)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    GOOGLE_DCHECK(elem_type_ != nullptr);
-    elem_type_->Clear();
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Optional::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional .onnx.TypeProto elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Optional::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Optional)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional .onnx.TypeProto elem_type = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::elem_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Optional)
-  return target;
-}
-
-size_t TypeProto_Optional::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Optional)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // optional .onnx.TypeProto elem_type = 1;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *elem_type_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Optional::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Optional*>(
-      &from));
-}
-
-void TypeProto_Optional::MergeFrom(const TypeProto_Optional& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Optional)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from._internal_has_elem_type()) {
-    _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom(from._internal_elem_type());
-  }
-}
-
-void TypeProto_Optional::CopyFrom(const TypeProto_Optional& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Optional)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Optional::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Optional::InternalSwap(TypeProto_Optional* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  swap(elem_type_, other->elem_type_);
-}
-
-std::string TypeProto_Optional::GetTypeName() const {
-  return "onnx.TypeProto.Optional";
-}
-
-
-// ===================================================================
-
-void TypeProto_SparseTensor::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_SparseTensor_default_instance_._instance.get_mutable()->shape_ = const_cast< ::onnx::TensorShapeProto*>(
-      ::onnx::TensorShapeProto::internal_default_instance());
-}
-class TypeProto_SparseTensor::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto_SparseTensor>()._has_bits_);
-  static void set_has_elem_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static const ::onnx::TensorShapeProto& shape(const TypeProto_SparseTensor* msg);
-  static void set_has_shape(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TensorShapeProto&
-TypeProto_SparseTensor::_Internal::shape(const TypeProto_SparseTensor* msg) {
-  return *msg->shape_;
-}
-TypeProto_SparseTensor::TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.SparseTensor)
-}
-TypeProto_SparseTensor::TypeProto_SparseTensor(const TypeProto_SparseTensor& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_shape()) {
-    shape_ = new ::onnx::TensorShapeProto(*from.shape_);
-  } else {
-    shape_ = nullptr;
-  }
-  elem_type_ = from.elem_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.SparseTensor)
-}
-
-void TypeProto_SparseTensor::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_SparseTensor_onnx_2eproto.base);
-  ::memset(&shape_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&elem_type_) -
-      reinterpret_cast<char*>(&shape_)) + sizeof(elem_type_));
-}
-
-TypeProto_SparseTensor::~TypeProto_SparseTensor() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.SparseTensor)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_SparseTensor::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete shape_;
-}
-
-void TypeProto_SparseTensor::ArenaDtor(void* object) {
-  TypeProto_SparseTensor* _this = reinterpret_cast< TypeProto_SparseTensor* >(object);
-  (void)_this;
-}
-void TypeProto_SparseTensor::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_SparseTensor::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_SparseTensor& TypeProto_SparseTensor::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_SparseTensor_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_SparseTensor::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.SparseTensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    GOOGLE_DCHECK(shape_ != nullptr);
-    shape_->Clear();
-  }
-  elem_type_ = 0;
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_SparseTensor::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional int32 elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _Internal::set_has_elem_type(&has_bits);
-          elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional .onnx.TensorShapeProto shape = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_SparseTensor::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.SparseTensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional int32 elem_type = 1;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_elem_type(), target);
-  }
-
-  // optional .onnx.TensorShapeProto shape = 2;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::shape(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.SparseTensor)
-  return target;
-}
-
-size_t TypeProto_SparseTensor::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.SparseTensor)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional .onnx.TensorShapeProto shape = 2;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *shape_);
-    }
-
-    // optional int32 elem_type = 1;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-          this->_internal_elem_type());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_SparseTensor::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_SparseTensor*>(
-      &from));
-}
-
-void TypeProto_SparseTensor::MergeFrom(const TypeProto_SparseTensor& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.SparseTensor)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom(from._internal_shape());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      elem_type_ = from.elem_type_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void TypeProto_SparseTensor::CopyFrom(const TypeProto_SparseTensor& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.SparseTensor)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_SparseTensor::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_SparseTensor::InternalSwap(TypeProto_SparseTensor* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, elem_type_)
-      + sizeof(TypeProto_SparseTensor::elem_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, shape_)>(
-          reinterpret_cast<char*>(&shape_),
-          reinterpret_cast<char*>(&other->shape_));
-}
-
-std::string TypeProto_SparseTensor::GetTypeName() const {
-  return "onnx.TypeProto.SparseTensor";
-}
-
-
-// ===================================================================
-
-void TypeProto::InitAsDefaultInstance() {
-}
-class TypeProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<TypeProto>()._has_bits_);
-  static const ::onnx::TypeProto_Tensor& tensor_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Sequence& sequence_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Map& map_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Optional& optional_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_SparseTensor& sparse_tensor_type(const TypeProto* msg);
-  static void set_has_denotation(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-};
-
-const ::onnx::TypeProto_Tensor&
-TypeProto::_Internal::tensor_type(const TypeProto* msg) {
-  return *msg->value_.tensor_type_;
-}
-const ::onnx::TypeProto_Sequence&
-TypeProto::_Internal::sequence_type(const TypeProto* msg) {
-  return *msg->value_.sequence_type_;
-}
-const ::onnx::TypeProto_Map&
-TypeProto::_Internal::map_type(const TypeProto* msg) {
-  return *msg->value_.map_type_;
-}
-const ::onnx::TypeProto_Optional&
-TypeProto::_Internal::optional_type(const TypeProto* msg) {
-  return *msg->value_.optional_type_;
-}
-const ::onnx::TypeProto_SparseTensor&
-TypeProto::_Internal::sparse_tensor_type(const TypeProto* msg) {
-  return *msg->value_.sparse_tensor_type_;
-}
-void TypeProto::set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (tensor_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tensor_type);
-    if (message_arena != submessage_arena) {
-      tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, tensor_type, submessage_arena);
-    }
-    set_has_tensor_type();
-    value_.tensor_type_ = tensor_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.tensor_type)
-}
-void TypeProto::set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (sequence_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sequence_type);
-    if (message_arena != submessage_arena) {
-      sequence_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sequence_type, submessage_arena);
-    }
-    set_has_sequence_type();
-    value_.sequence_type_ = sequence_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sequence_type)
-}
-void TypeProto::set_allocated_map_type(::onnx::TypeProto_Map* map_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (map_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_type);
-    if (message_arena != submessage_arena) {
-      map_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, map_type, submessage_arena);
-    }
-    set_has_map_type();
-    value_.map_type_ = map_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.map_type)
-}
-void TypeProto::set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (optional_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(optional_type);
-    if (message_arena != submessage_arena) {
-      optional_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, optional_type, submessage_arena);
-    }
-    set_has_optional_type();
-    value_.optional_type_ = optional_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.optional_type)
-}
-void TypeProto::set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (sparse_tensor_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sparse_tensor_type);
-    if (message_arena != submessage_arena) {
-      sparse_tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sparse_tensor_type, submessage_arena);
-    }
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = sparse_tensor_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sparse_tensor_type)
-}
-TypeProto::TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto)
-}
-TypeProto::TypeProto(const TypeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_denotation()) {
-    denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_denotation(),
-      GetArena());
-  }
-  clear_has_value();
-  switch (from.value_case()) {
-    case kTensorType: {
-      _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom(from._internal_tensor_type());
-      break;
-    }
-    case kSequenceType: {
-      _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom(from._internal_sequence_type());
-      break;
-    }
-    case kMapType: {
-      _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom(from._internal_map_type());
-      break;
-    }
-    case kOptionalType: {
-      _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom(from._internal_optional_type());
-      break;
-    }
-    case kSparseTensorType: {
-      _internal_mutable_sparse_tensor_type()->::onnx::TypeProto_SparseTensor::MergeFrom(from._internal_sparse_tensor_type());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto)
-}
-
-void TypeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto.base);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  clear_has_value();
-}
-
-TypeProto::~TypeProto() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  denotation_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (has_value()) {
-    clear_value();
-  }
-}
-
-void TypeProto::ArenaDtor(void* object) {
-  TypeProto* _this = reinterpret_cast< TypeProto* >(object);
-  (void)_this;
-}
-void TypeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto& TypeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto::clear_value() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.TypeProto)
-  switch (value_case()) {
-    case kTensorType: {
-      if (GetArena() == nullptr) {
-        delete value_.tensor_type_;
-      }
-      break;
-    }
-    case kSequenceType: {
-      if (GetArena() == nullptr) {
-        delete value_.sequence_type_;
-      }
-      break;
-    }
-    case kMapType: {
-      if (GetArena() == nullptr) {
-        delete value_.map_type_;
-      }
-      break;
-    }
-    case kOptionalType: {
-      if (GetArena() == nullptr) {
-        delete value_.optional_type_;
-      }
-      break;
-    }
-    case kSparseTensorType: {
-      if (GetArena() == nullptr) {
-        delete value_.sparse_tensor_type_;
-      }
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-
-
-void TypeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    denotation_.ClearNonDefaultToEmpty();
-  }
-  clear_value();
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.TypeProto.Tensor tensor_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_tensor_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Sequence sequence_type = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sequence_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Map map_type = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ctx->ParseMessage(_internal_mutable_map_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional string denotation = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_denotation();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Optional optional_type = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr = ctx->ParseMessage(_internal_mutable_optional_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  switch (value_case()) {
-    case kTensorType: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-        InternalWriteMessage(
-          1, _Internal::tensor_type(this), target, stream);
-      break;
-    }
-    case kSequenceType: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-        InternalWriteMessage(
-          4, _Internal::sequence_type(this), target, stream);
-      break;
-    }
-    case kMapType: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-        InternalWriteMessage(
-          5, _Internal::map_type(this), target, stream);
-      break;
-    }
-    default: ;
-  }
-  cached_has_bits = _has_bits_[0];
-  // optional string denotation = 6;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_denotation(), target);
-  }
-
-  switch (value_case()) {
-    case kSparseTensorType: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-        InternalWriteMessage(
-          8, _Internal::sparse_tensor_type(this), target, stream);
-      break;
-    }
-    case kOptionalType: {
-      target = stream->EnsureSpace(target);
-      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-        InternalWriteMessage(
-          9, _Internal::optional_type(this), target, stream);
-      break;
-    }
-    default: ;
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto)
-  return target;
-}
-
-size_t TypeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // optional string denotation = 6;
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_denotation());
-  }
-
-  switch (value_case()) {
-    // .onnx.TypeProto.Tensor tensor_type = 1;
-    case kTensorType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.tensor_type_);
-      break;
-    }
-    // .onnx.TypeProto.Sequence sequence_type = 4;
-    case kSequenceType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.sequence_type_);
-      break;
-    }
-    // .onnx.TypeProto.Map map_type = 5;
-    case kMapType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.map_type_);
-      break;
-    }
-    // .onnx.TypeProto.Optional optional_type = 9;
-    case kOptionalType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.optional_type_);
-      break;
-    }
-    // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-    case kSparseTensorType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.sparse_tensor_type_);
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto*>(
-      &from));
-}
-
-void TypeProto::MergeFrom(const TypeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from._internal_has_denotation()) {
-    _internal_set_denotation(from._internal_denotation());
-  }
-  switch (from.value_case()) {
-    case kTensorType: {
-      _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom(from._internal_tensor_type());
-      break;
-    }
-    case kSequenceType: {
-      _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom(from._internal_sequence_type());
-      break;
-    }
-    case kMapType: {
-      _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom(from._internal_map_type());
-      break;
-    }
-    case kOptionalType: {
-      _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom(from._internal_optional_type());
-      break;
-    }
-    case kSparseTensorType: {
-      _internal_mutable_sparse_tensor_type()->::onnx::TypeProto_SparseTensor::MergeFrom(from._internal_sparse_tensor_type());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void TypeProto::CopyFrom(const TypeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto::IsInitialized() const {
-  return true;
-}
-
-void TypeProto::InternalSwap(TypeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  denotation_.Swap(&other->denotation_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(value_, other->value_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string TypeProto::GetTypeName() const {
-  return "onnx.TypeProto";
-}
-
-
-// ===================================================================
-
-void OperatorSetIdProto::InitAsDefaultInstance() {
-}
-class OperatorSetIdProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<OperatorSetIdProto>()._has_bits_);
-  static void set_has_domain(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_version(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-};
-
-OperatorSetIdProto::OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.OperatorSetIdProto)
-}
-OperatorSetIdProto::OperatorSetIdProto(const OperatorSetIdProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_domain()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  version_ = from.version_;
-  // @@protoc_insertion_point(copy_constructor:onnx.OperatorSetIdProto)
-}
-
-void OperatorSetIdProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OperatorSetIdProto_onnx_2eproto.base);
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  version_ = PROTOBUF_LONGLONG(0);
-}
-
-OperatorSetIdProto::~OperatorSetIdProto() {
-  // @@protoc_insertion_point(destructor:onnx.OperatorSetIdProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void OperatorSetIdProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void OperatorSetIdProto::ArenaDtor(void* object) {
-  OperatorSetIdProto* _this = reinterpret_cast< OperatorSetIdProto* >(object);
-  (void)_this;
-}
-void OperatorSetIdProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void OperatorSetIdProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const OperatorSetIdProto& OperatorSetIdProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_OperatorSetIdProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void OperatorSetIdProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.OperatorSetIdProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    domain_.ClearNonDefaultToEmpty();
-  }
-  version_ = PROTOBUF_LONGLONG(0);
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* OperatorSetIdProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string domain = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // optional int64 version = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          _Internal::set_has_version(&has_bits);
-          version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* OperatorSetIdProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.OperatorSetIdProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string domain = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_domain(), target);
-  }
-
-  // optional int64 version = 2;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_version(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.OperatorSetIdProto)
-  return target;
-}
-
-size_t OperatorSetIdProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.OperatorSetIdProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    // optional string domain = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_domain());
-    }
-
-    // optional int64 version = 2;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_version());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void OperatorSetIdProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const OperatorSetIdProto*>(
-      &from));
-}
-
-void OperatorSetIdProto::MergeFrom(const OperatorSetIdProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.OperatorSetIdProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_domain(from._internal_domain());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      version_ = from.version_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void OperatorSetIdProto::CopyFrom(const OperatorSetIdProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.OperatorSetIdProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool OperatorSetIdProto::IsInitialized() const {
-  return true;
-}
-
-void OperatorSetIdProto::InternalSwap(OperatorSetIdProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(version_, other->version_);
-}
-
-std::string OperatorSetIdProto::GetTypeName() const {
-  return "onnx.OperatorSetIdProto";
-}
-
-
-// ===================================================================
-
-void FunctionProto::InitAsDefaultInstance() {
-}
-class FunctionProto::_Internal {
- public:
-  using HasBits = decltype(std::declval<FunctionProto>()._has_bits_);
-  static void set_has_name(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_doc_string(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_domain(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_overload(HasBits* has_bits) {
-    (*has_bits)[0] |= 8u;
-  }
-};
-
-FunctionProto::FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  input_(arena),
-  output_(arena),
-  attribute_(arena),
-  node_(arena),
-  opset_import_(arena),
-  attribute_proto_(arena),
-  value_info_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.FunctionProto)
-}
-FunctionProto::FunctionProto(const FunctionProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      _has_bits_(from._has_bits_),
-      input_(from.input_),
-      output_(from.output_),
-      attribute_(from.attribute_),
-      node_(from.node_),
-      opset_import_(from.opset_import_),
-      attribute_proto_(from.attribute_proto_),
-      value_info_(from.value_info_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_name()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_doc_string()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_domain()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (from._internal_has_overload()) {
-    overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_overload(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.FunctionProto)
-}
-
-void FunctionProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FunctionProto_onnx_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-FunctionProto::~FunctionProto() {
-  // @@protoc_insertion_point(destructor:onnx.FunctionProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void FunctionProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void FunctionProto::ArenaDtor(void* object) {
-  FunctionProto* _this = reinterpret_cast< FunctionProto* >(object);
-  (void)_this;
-}
-void FunctionProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void FunctionProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const FunctionProto& FunctionProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FunctionProto_onnx_2eproto.base);
-  return *internal_default_instance();
-}
-
-
-void FunctionProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.FunctionProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  input_.Clear();
-  output_.Clear();
-  attribute_.Clear();
-  node_.Clear();
-  opset_import_.Clear();
-  attribute_proto_.Clear();
-  value_info_.Clear();
-  metadata_props_.Clear();
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000000fu) {
-    if (cached_has_bits & 0x00000001u) {
-      name_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      doc_string_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000004u) {
-      domain_.ClearNonDefaultToEmpty();
-    }
-    if (cached_has_bits & 0x00000008u) {
-      overload_.ClearNonDefaultToEmpty();
-    }
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* FunctionProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  _Internal::HasBits has_bits{};
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // optional string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated string input = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_input();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string output = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_output();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string attribute = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_attribute();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.NodeProto node = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_node(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string doc_string = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.OperatorSetIdProto opset_import = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string domain = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.AttributeProto attribute_proto = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_attribute_proto(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto value_info = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_value_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // optional string overload = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          auto str = _internal_mutable_overload();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  _has_bits_.Or(has_bits);
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* FunctionProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.FunctionProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string name = 1;
-  if (cached_has_bits & 0x00000001u) {
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // repeated string input = 4;
-  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
-    const auto& s = this->_internal_input(i);
-    target = stream->WriteString(4, s, target);
-  }
-
-  // repeated string output = 5;
-  for (int i = 0, n = this->_internal_output_size(); i < n; i++) {
-    const auto& s = this->_internal_output(i);
-    target = stream->WriteString(5, s, target);
-  }
-
-  // repeated string attribute = 6;
-  for (int i = 0, n = this->_internal_attribute_size(); i < n; i++) {
-    const auto& s = this->_internal_attribute(i);
-    target = stream->WriteString(6, s, target);
-  }
-
-  // repeated .onnx.NodeProto node = 7;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_node_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(7, this->_internal_node(i), target, stream);
-  }
-
-  // optional string doc_string = 8;
-  if (cached_has_bits & 0x00000002u) {
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_opset_import_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(9, this->_internal_opset_import(i), target, stream);
-  }
-
-  // optional string domain = 10;
-  if (cached_has_bits & 0x00000004u) {
-    target = stream->WriteStringMaybeAliased(
-        10, this->_internal_domain(), target);
-  }
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_attribute_proto_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_attribute_proto(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_value_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(12, this->_internal_value_info(i), target, stream);
-  }
-
-  // optional string overload = 13;
-  if (cached_has_bits & 0x00000008u) {
-    target = stream->WriteStringMaybeAliased(
-        13, this->_internal_overload(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.FunctionProto)
-  return target;
-}
-
-size_t FunctionProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.FunctionProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string input = 4;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
-  for (int i = 0, n = input_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      input_.Get(i));
-  }
-
-  // repeated string output = 5;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size());
-  for (int i = 0, n = output_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      output_.Get(i));
-  }
-
-  // repeated string attribute = 6;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(attribute_.size());
-  for (int i = 0, n = attribute_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      attribute_.Get(i));
-  }
-
-  // repeated .onnx.NodeProto node = 7;
-  total_size += 1UL * this->_internal_node_size();
-  for (const auto& msg : this->node_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  total_size += 1UL * this->_internal_opset_import_size();
-  for (const auto& msg : this->opset_import_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  total_size += 1UL * this->_internal_attribute_proto_size();
-  for (const auto& msg : this->attribute_proto_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  total_size += 1UL * this->_internal_value_info_size();
-  for (const auto& msg : this->value_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000000fu) {
-    // optional string name = 1;
-    if (cached_has_bits & 0x00000001u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_name());
-    }
-
-    // optional string doc_string = 8;
-    if (cached_has_bits & 0x00000002u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_doc_string());
-    }
-
-    // optional string domain = 10;
-    if (cached_has_bits & 0x00000004u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_domain());
-    }
-
-    // optional string overload = 13;
-    if (cached_has_bits & 0x00000008u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_overload());
-    }
-
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void FunctionProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FunctionProto*>(
-      &from));
-}
-
-void FunctionProto::MergeFrom(const FunctionProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.FunctionProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  attribute_.MergeFrom(from.attribute_);
-  node_.MergeFrom(from.node_);
-  opset_import_.MergeFrom(from.opset_import_);
-  attribute_proto_.MergeFrom(from.attribute_proto_);
-  value_info_.MergeFrom(from.value_info_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000000fu) {
-    if (cached_has_bits & 0x00000001u) {
-      _internal_set_name(from._internal_name());
-    }
-    if (cached_has_bits & 0x00000002u) {
-      _internal_set_doc_string(from._internal_doc_string());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      _internal_set_domain(from._internal_domain());
-    }
-    if (cached_has_bits & 0x00000008u) {
-      _internal_set_overload(from._internal_overload());
-    }
-  }
-}
-
-void FunctionProto::CopyFrom(const FunctionProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.FunctionProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool FunctionProto::IsInitialized() const {
-  return true;
-}
-
-void FunctionProto::InternalSwap(FunctionProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  attribute_.InternalSwap(&other->attribute_);
-  node_.InternalSwap(&other->node_);
-  opset_import_.InternalSwap(&other->opset_import_);
-  attribute_proto_.InternalSwap(&other->attribute_proto_);
-  value_info_.InternalSwap(&other->value_info_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.Swap(&other->overload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string FunctionProto::GetTypeName() const {
-  return "onnx.FunctionProto";
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-}  // namespace onnx
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::onnx::AttributeProto* Arena::CreateMaybeMessage< ::onnx::AttributeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::AttributeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ValueInfoProto* Arena::CreateMaybeMessage< ::onnx::ValueInfoProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ValueInfoProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::NodeProto* Arena::CreateMaybeMessage< ::onnx::NodeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::NodeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::IntIntListEntryProto* Arena::CreateMaybeMessage< ::onnx::IntIntListEntryProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::IntIntListEntryProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::NodeDeviceConfigurationProto* Arena::CreateMaybeMessage< ::onnx::NodeDeviceConfigurationProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::NodeDeviceConfigurationProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ShardingSpecProto* Arena::CreateMaybeMessage< ::onnx::ShardingSpecProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ShardingSpecProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ShardedDimProto* Arena::CreateMaybeMessage< ::onnx::ShardedDimProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ShardedDimProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::SimpleShardedDimProto* Arena::CreateMaybeMessage< ::onnx::SimpleShardedDimProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::SimpleShardedDimProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TrainingInfoProto* Arena::CreateMaybeMessage< ::onnx::TrainingInfoProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TrainingInfoProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ModelProto* Arena::CreateMaybeMessage< ::onnx::ModelProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ModelProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::DeviceConfigurationProto* Arena::CreateMaybeMessage< ::onnx::DeviceConfigurationProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::DeviceConfigurationProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::StringStringEntryProto* Arena::CreateMaybeMessage< ::onnx::StringStringEntryProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::StringStringEntryProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorAnnotation* Arena::CreateMaybeMessage< ::onnx::TensorAnnotation >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorAnnotation >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::GraphProto* Arena::CreateMaybeMessage< ::onnx::GraphProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::GraphProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorProto_Segment* Arena::CreateMaybeMessage< ::onnx::TensorProto_Segment >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorProto_Segment >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorProto* Arena::CreateMaybeMessage< ::onnx::TensorProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::SparseTensorProto* Arena::CreateMaybeMessage< ::onnx::SparseTensorProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::SparseTensorProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage< ::onnx::TensorShapeProto_Dimension >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorShapeProto_Dimension >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorShapeProto* Arena::CreateMaybeMessage< ::onnx::TensorShapeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorShapeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Tensor* Arena::CreateMaybeMessage< ::onnx::TypeProto_Tensor >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Tensor >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Sequence* Arena::CreateMaybeMessage< ::onnx::TypeProto_Sequence >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Sequence >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Map* Arena::CreateMaybeMessage< ::onnx::TypeProto_Map >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Map >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Optional* Arena::CreateMaybeMessage< ::onnx::TypeProto_Optional >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Optional >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_SparseTensor* Arena::CreateMaybeMessage< ::onnx::TypeProto_SparseTensor >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_SparseTensor >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto* Arena::CreateMaybeMessage< ::onnx::TypeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::OperatorSetIdProto* Arena::CreateMaybeMessage< ::onnx::OperatorSetIdProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::OperatorSetIdProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::FunctionProto* Arena::CreateMaybeMessage< ::onnx::FunctionProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::FunctionProto >(arena);
-}
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-#include <google/protobuf/port_undef.inc>
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.h
deleted file mode 100644
index 8af95d7..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.pb.h
+++ /dev/null
@@ -1,15041 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: onnx.proto
-
-#ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto
-#define GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto
-
-#include <limits>
-#include <string>
-
-#include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3012000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please update
-#error your headers.
-#endif
-#if 3012004 < PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/port_undef.inc>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/inlined_string_field.h>
-#include <google/protobuf/metadata_lite.h>
-#include <google/protobuf/message_lite.h>
-#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/generated_enum_util.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-#define PROTOBUF_INTERNAL_EXPORT_onnx_2eproto
-PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
-}  // namespace internal
-PROTOBUF_NAMESPACE_CLOSE
-
-// Internal implementation detail -- do not use these members.
-struct TableStruct_onnx_2eproto {
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
-  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
-  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
-};
-namespace onnx {
-class AttributeProto;
-class AttributeProtoDefaultTypeInternal;
-extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
-class DeviceConfigurationProto;
-class DeviceConfigurationProtoDefaultTypeInternal;
-extern DeviceConfigurationProtoDefaultTypeInternal _DeviceConfigurationProto_default_instance_;
-class FunctionProto;
-class FunctionProtoDefaultTypeInternal;
-extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
-class GraphProto;
-class GraphProtoDefaultTypeInternal;
-extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
-class IntIntListEntryProto;
-class IntIntListEntryProtoDefaultTypeInternal;
-extern IntIntListEntryProtoDefaultTypeInternal _IntIntListEntryProto_default_instance_;
-class ModelProto;
-class ModelProtoDefaultTypeInternal;
-extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
-class NodeDeviceConfigurationProto;
-class NodeDeviceConfigurationProtoDefaultTypeInternal;
-extern NodeDeviceConfigurationProtoDefaultTypeInternal _NodeDeviceConfigurationProto_default_instance_;
-class NodeProto;
-class NodeProtoDefaultTypeInternal;
-extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
-class OperatorSetIdProto;
-class OperatorSetIdProtoDefaultTypeInternal;
-extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
-class ShardedDimProto;
-class ShardedDimProtoDefaultTypeInternal;
-extern ShardedDimProtoDefaultTypeInternal _ShardedDimProto_default_instance_;
-class ShardingSpecProto;
-class ShardingSpecProtoDefaultTypeInternal;
-extern ShardingSpecProtoDefaultTypeInternal _ShardingSpecProto_default_instance_;
-class SimpleShardedDimProto;
-class SimpleShardedDimProtoDefaultTypeInternal;
-extern SimpleShardedDimProtoDefaultTypeInternal _SimpleShardedDimProto_default_instance_;
-class SparseTensorProto;
-class SparseTensorProtoDefaultTypeInternal;
-extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
-class StringStringEntryProto;
-class StringStringEntryProtoDefaultTypeInternal;
-extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
-class TensorAnnotation;
-class TensorAnnotationDefaultTypeInternal;
-extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
-class TensorProto;
-class TensorProtoDefaultTypeInternal;
-extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
-class TensorProto_Segment;
-class TensorProto_SegmentDefaultTypeInternal;
-extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
-class TensorShapeProto;
-class TensorShapeProtoDefaultTypeInternal;
-extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
-class TensorShapeProto_Dimension;
-class TensorShapeProto_DimensionDefaultTypeInternal;
-extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
-class TrainingInfoProto;
-class TrainingInfoProtoDefaultTypeInternal;
-extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
-class TypeProto;
-class TypeProtoDefaultTypeInternal;
-extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
-class TypeProto_Map;
-class TypeProto_MapDefaultTypeInternal;
-extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
-class TypeProto_Optional;
-class TypeProto_OptionalDefaultTypeInternal;
-extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
-class TypeProto_Sequence;
-class TypeProto_SequenceDefaultTypeInternal;
-extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
-class TypeProto_SparseTensor;
-class TypeProto_SparseTensorDefaultTypeInternal;
-extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
-class TypeProto_Tensor;
-class TypeProto_TensorDefaultTypeInternal;
-extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
-class ValueInfoProto;
-class ValueInfoProtoDefaultTypeInternal;
-extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
-}  // namespace onnx
-PROTOBUF_NAMESPACE_OPEN
-template<> ::onnx::AttributeProto* Arena::CreateMaybeMessage<::onnx::AttributeProto>(Arena*);
-template<> ::onnx::DeviceConfigurationProto* Arena::CreateMaybeMessage<::onnx::DeviceConfigurationProto>(Arena*);
-template<> ::onnx::FunctionProto* Arena::CreateMaybeMessage<::onnx::FunctionProto>(Arena*);
-template<> ::onnx::GraphProto* Arena::CreateMaybeMessage<::onnx::GraphProto>(Arena*);
-template<> ::onnx::IntIntListEntryProto* Arena::CreateMaybeMessage<::onnx::IntIntListEntryProto>(Arena*);
-template<> ::onnx::ModelProto* Arena::CreateMaybeMessage<::onnx::ModelProto>(Arena*);
-template<> ::onnx::NodeDeviceConfigurationProto* Arena::CreateMaybeMessage<::onnx::NodeDeviceConfigurationProto>(Arena*);
-template<> ::onnx::NodeProto* Arena::CreateMaybeMessage<::onnx::NodeProto>(Arena*);
-template<> ::onnx::OperatorSetIdProto* Arena::CreateMaybeMessage<::onnx::OperatorSetIdProto>(Arena*);
-template<> ::onnx::ShardedDimProto* Arena::CreateMaybeMessage<::onnx::ShardedDimProto>(Arena*);
-template<> ::onnx::ShardingSpecProto* Arena::CreateMaybeMessage<::onnx::ShardingSpecProto>(Arena*);
-template<> ::onnx::SimpleShardedDimProto* Arena::CreateMaybeMessage<::onnx::SimpleShardedDimProto>(Arena*);
-template<> ::onnx::SparseTensorProto* Arena::CreateMaybeMessage<::onnx::SparseTensorProto>(Arena*);
-template<> ::onnx::StringStringEntryProto* Arena::CreateMaybeMessage<::onnx::StringStringEntryProto>(Arena*);
-template<> ::onnx::TensorAnnotation* Arena::CreateMaybeMessage<::onnx::TensorAnnotation>(Arena*);
-template<> ::onnx::TensorProto* Arena::CreateMaybeMessage<::onnx::TensorProto>(Arena*);
-template<> ::onnx::TensorProto_Segment* Arena::CreateMaybeMessage<::onnx::TensorProto_Segment>(Arena*);
-template<> ::onnx::TensorShapeProto* Arena::CreateMaybeMessage<::onnx::TensorShapeProto>(Arena*);
-template<> ::onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage<::onnx::TensorShapeProto_Dimension>(Arena*);
-template<> ::onnx::TrainingInfoProto* Arena::CreateMaybeMessage<::onnx::TrainingInfoProto>(Arena*);
-template<> ::onnx::TypeProto* Arena::CreateMaybeMessage<::onnx::TypeProto>(Arena*);
-template<> ::onnx::TypeProto_Map* Arena::CreateMaybeMessage<::onnx::TypeProto_Map>(Arena*);
-template<> ::onnx::TypeProto_Optional* Arena::CreateMaybeMessage<::onnx::TypeProto_Optional>(Arena*);
-template<> ::onnx::TypeProto_Sequence* Arena::CreateMaybeMessage<::onnx::TypeProto_Sequence>(Arena*);
-template<> ::onnx::TypeProto_SparseTensor* Arena::CreateMaybeMessage<::onnx::TypeProto_SparseTensor>(Arena*);
-template<> ::onnx::TypeProto_Tensor* Arena::CreateMaybeMessage<::onnx::TypeProto_Tensor>(Arena*);
-template<> ::onnx::ValueInfoProto* Arena::CreateMaybeMessage<::onnx::ValueInfoProto>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
-namespace onnx {
-
-enum AttributeProto_AttributeType : int {
-  AttributeProto_AttributeType_UNDEFINED = 0,
-  AttributeProto_AttributeType_FLOAT = 1,
-  AttributeProto_AttributeType_INT = 2,
-  AttributeProto_AttributeType_STRING = 3,
-  AttributeProto_AttributeType_TENSOR = 4,
-  AttributeProto_AttributeType_GRAPH = 5,
-  AttributeProto_AttributeType_SPARSE_TENSOR = 11,
-  AttributeProto_AttributeType_TYPE_PROTO = 13,
-  AttributeProto_AttributeType_FLOATS = 6,
-  AttributeProto_AttributeType_INTS = 7,
-  AttributeProto_AttributeType_STRINGS = 8,
-  AttributeProto_AttributeType_TENSORS = 9,
-  AttributeProto_AttributeType_GRAPHS = 10,
-  AttributeProto_AttributeType_SPARSE_TENSORS = 12,
-  AttributeProto_AttributeType_TYPE_PROTOS = 14
-};
-bool AttributeProto_AttributeType_IsValid(int value);
-constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
-constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_TYPE_PROTOS;
-constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
-
-const std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value);
-template<typename T>
-inline const std::string& AttributeProto_AttributeType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function AttributeProto_AttributeType_Name.");
-  return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(enum_t_value));
-}
-bool AttributeProto_AttributeType_Parse(
-    const std::string& name, AttributeProto_AttributeType* value);
-enum TensorProto_DataType : int {
-  TensorProto_DataType_UNDEFINED = 0,
-  TensorProto_DataType_FLOAT = 1,
-  TensorProto_DataType_UINT8 = 2,
-  TensorProto_DataType_INT8 = 3,
-  TensorProto_DataType_UINT16 = 4,
-  TensorProto_DataType_INT16 = 5,
-  TensorProto_DataType_INT32 = 6,
-  TensorProto_DataType_INT64 = 7,
-  TensorProto_DataType_STRING = 8,
-  TensorProto_DataType_BOOL = 9,
-  TensorProto_DataType_FLOAT16 = 10,
-  TensorProto_DataType_DOUBLE = 11,
-  TensorProto_DataType_UINT32 = 12,
-  TensorProto_DataType_UINT64 = 13,
-  TensorProto_DataType_COMPLEX64 = 14,
-  TensorProto_DataType_COMPLEX128 = 15,
-  TensorProto_DataType_BFLOAT16 = 16,
-  TensorProto_DataType_FLOAT8E4M3FN = 17,
-  TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
-  TensorProto_DataType_FLOAT8E5M2 = 19,
-  TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
-  TensorProto_DataType_UINT4 = 21,
-  TensorProto_DataType_INT4 = 22,
-  TensorProto_DataType_FLOAT4E2M1 = 23,
-  TensorProto_DataType_FLOAT8E8M0 = 24
-};
-bool TensorProto_DataType_IsValid(int value);
-constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
-constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_FLOAT8E8M0;
-constexpr int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
-
-const std::string& TensorProto_DataType_Name(TensorProto_DataType value);
-template<typename T>
-inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, TensorProto_DataType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function TensorProto_DataType_Name.");
-  return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(enum_t_value));
-}
-bool TensorProto_DataType_Parse(
-    const std::string& name, TensorProto_DataType* value);
-enum TensorProto_DataLocation : int {
-  TensorProto_DataLocation_DEFAULT = 0,
-  TensorProto_DataLocation_EXTERNAL = 1
-};
-bool TensorProto_DataLocation_IsValid(int value);
-constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = TensorProto_DataLocation_DEFAULT;
-constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = TensorProto_DataLocation_EXTERNAL;
-constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_MAX + 1;
-
-const std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value);
-template<typename T>
-inline const std::string& TensorProto_DataLocation_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, TensorProto_DataLocation>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function TensorProto_DataLocation_Name.");
-  return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(enum_t_value));
-}
-bool TensorProto_DataLocation_Parse(
-    const std::string& name, TensorProto_DataLocation* value);
-enum Version : int {
-  _START_VERSION = 0,
-  IR_VERSION_2017_10_10 = 1,
-  IR_VERSION_2017_10_30 = 2,
-  IR_VERSION_2017_11_3 = 3,
-  IR_VERSION_2019_1_22 = 4,
-  IR_VERSION_2019_3_18 = 5,
-  IR_VERSION_2019_9_19 = 6,
-  IR_VERSION_2020_5_8 = 7,
-  IR_VERSION_2021_7_30 = 8,
-  IR_VERSION_2023_5_5 = 9,
-  IR_VERSION_2024_3_25 = 10,
-  IR_VERSION_2025_05_12 = 11,
-  IR_VERSION = 12
-};
-bool Version_IsValid(int value);
-constexpr Version Version_MIN = _START_VERSION;
-constexpr Version Version_MAX = IR_VERSION;
-constexpr int Version_ARRAYSIZE = Version_MAX + 1;
-
-const std::string& Version_Name(Version value);
-template<typename T>
-inline const std::string& Version_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, Version>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Version_Name.");
-  return Version_Name(static_cast<Version>(enum_t_value));
-}
-bool Version_Parse(
-    const std::string& name, Version* value);
-enum OperatorStatus : int {
-  EXPERIMENTAL = 0,
-  STABLE = 1
-};
-bool OperatorStatus_IsValid(int value);
-constexpr OperatorStatus OperatorStatus_MIN = EXPERIMENTAL;
-constexpr OperatorStatus OperatorStatus_MAX = STABLE;
-constexpr int OperatorStatus_ARRAYSIZE = OperatorStatus_MAX + 1;
-
-const std::string& OperatorStatus_Name(OperatorStatus value);
-template<typename T>
-inline const std::string& OperatorStatus_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, OperatorStatus>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function OperatorStatus_Name.");
-  return OperatorStatus_Name(static_cast<OperatorStatus>(enum_t_value));
-}
-bool OperatorStatus_Parse(
-    const std::string& name, OperatorStatus* value);
-// ===================================================================
-
-class AttributeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
- public:
-  inline AttributeProto() : AttributeProto(nullptr) {};
-  virtual ~AttributeProto();
-
-  AttributeProto(const AttributeProto& from);
-  AttributeProto(AttributeProto&& from) noexcept
-    : AttributeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline AttributeProto& operator=(const AttributeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline AttributeProto& operator=(AttributeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const AttributeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const AttributeProto* internal_default_instance() {
-    return reinterpret_cast<const AttributeProto*>(
-               &_AttributeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(AttributeProto& a, AttributeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(AttributeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(AttributeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline AttributeProto* New() const final {
-    return CreateMaybeMessage<AttributeProto>(nullptr);
-  }
-
-  AttributeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<AttributeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const AttributeProto& from);
-  void MergeFrom(const AttributeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(AttributeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.AttributeProto";
-  }
-  protected:
-  explicit AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef AttributeProto_AttributeType AttributeType;
-  static constexpr AttributeType UNDEFINED =
-    AttributeProto_AttributeType_UNDEFINED;
-  static constexpr AttributeType FLOAT =
-    AttributeProto_AttributeType_FLOAT;
-  static constexpr AttributeType INT =
-    AttributeProto_AttributeType_INT;
-  static constexpr AttributeType STRING =
-    AttributeProto_AttributeType_STRING;
-  static constexpr AttributeType TENSOR =
-    AttributeProto_AttributeType_TENSOR;
-  static constexpr AttributeType GRAPH =
-    AttributeProto_AttributeType_GRAPH;
-  static constexpr AttributeType SPARSE_TENSOR =
-    AttributeProto_AttributeType_SPARSE_TENSOR;
-  static constexpr AttributeType TYPE_PROTO =
-    AttributeProto_AttributeType_TYPE_PROTO;
-  static constexpr AttributeType FLOATS =
-    AttributeProto_AttributeType_FLOATS;
-  static constexpr AttributeType INTS =
-    AttributeProto_AttributeType_INTS;
-  static constexpr AttributeType STRINGS =
-    AttributeProto_AttributeType_STRINGS;
-  static constexpr AttributeType TENSORS =
-    AttributeProto_AttributeType_TENSORS;
-  static constexpr AttributeType GRAPHS =
-    AttributeProto_AttributeType_GRAPHS;
-  static constexpr AttributeType SPARSE_TENSORS =
-    AttributeProto_AttributeType_SPARSE_TENSORS;
-  static constexpr AttributeType TYPE_PROTOS =
-    AttributeProto_AttributeType_TYPE_PROTOS;
-  static inline bool AttributeType_IsValid(int value) {
-    return AttributeProto_AttributeType_IsValid(value);
-  }
-  static constexpr AttributeType AttributeType_MIN =
-    AttributeProto_AttributeType_AttributeType_MIN;
-  static constexpr AttributeType AttributeType_MAX =
-    AttributeProto_AttributeType_AttributeType_MAX;
-  static constexpr int AttributeType_ARRAYSIZE =
-    AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& AttributeType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, AttributeType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function AttributeType_Name.");
-    return AttributeProto_AttributeType_Name(enum_t_value);
-  }
-  static inline bool AttributeType_Parse(const std::string& name,
-      AttributeType* value) {
-    return AttributeProto_AttributeType_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFloatsFieldNumber = 7,
-    kIntsFieldNumber = 8,
-    kStringsFieldNumber = 9,
-    kTensorsFieldNumber = 10,
-    kGraphsFieldNumber = 11,
-    kTypeProtosFieldNumber = 15,
-    kSparseTensorsFieldNumber = 23,
-    kNameFieldNumber = 1,
-    kSFieldNumber = 4,
-    kDocStringFieldNumber = 13,
-    kRefAttrNameFieldNumber = 21,
-    kTFieldNumber = 5,
-    kGFieldNumber = 6,
-    kTpFieldNumber = 14,
-    kSparseTensorFieldNumber = 22,
-    kIFieldNumber = 3,
-    kFFieldNumber = 2,
-    kTypeFieldNumber = 20,
-  };
-  // repeated float floats = 7;
-  int floats_size() const;
-  private:
-  int _internal_floats_size() const;
-  public:
-  void clear_floats();
-  private:
-  float _internal_floats(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      _internal_floats() const;
-  void _internal_add_floats(float value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      _internal_mutable_floats();
-  public:
-  float floats(int index) const;
-  void set_floats(int index, float value);
-  void add_floats(float value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      floats() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      mutable_floats();
-
-  // repeated int64 ints = 8;
-  int ints_size() const;
-  private:
-  int _internal_ints_size() const;
-  public:
-  void clear_ints();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_ints(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_ints() const;
-  void _internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_ints();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 ints(int index) const;
-  void set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      ints() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_ints();
-
-  // repeated bytes strings = 9;
-  int strings_size() const;
-  private:
-  int _internal_strings_size() const;
-  public:
-  void clear_strings();
-  const std::string& strings(int index) const;
-  std::string* mutable_strings(int index);
-  void set_strings(int index, const std::string& value);
-  void set_strings(int index, std::string&& value);
-  void set_strings(int index, const char* value);
-  void set_strings(int index, const void* value, size_t size);
-  std::string* add_strings();
-  void add_strings(const std::string& value);
-  void add_strings(std::string&& value);
-  void add_strings(const char* value);
-  void add_strings(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
-  private:
-  const std::string& _internal_strings(int index) const;
-  std::string* _internal_add_strings();
-  public:
-
-  // repeated .onnx.TensorProto tensors = 10;
-  int tensors_size() const;
-  private:
-  int _internal_tensors_size() const;
-  public:
-  void clear_tensors();
-  ::onnx::TensorProto* mutable_tensors(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-      mutable_tensors();
-  private:
-  const ::onnx::TensorProto& _internal_tensors(int index) const;
-  ::onnx::TensorProto* _internal_add_tensors();
-  public:
-  const ::onnx::TensorProto& tensors(int index) const;
-  ::onnx::TensorProto* add_tensors();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-      tensors() const;
-
-  // repeated .onnx.GraphProto graphs = 11;
-  int graphs_size() const;
-  private:
-  int _internal_graphs_size() const;
-  public:
-  void clear_graphs();
-  ::onnx::GraphProto* mutable_graphs(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >*
-      mutable_graphs();
-  private:
-  const ::onnx::GraphProto& _internal_graphs(int index) const;
-  ::onnx::GraphProto* _internal_add_graphs();
-  public:
-  const ::onnx::GraphProto& graphs(int index) const;
-  ::onnx::GraphProto* add_graphs();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >&
-      graphs() const;
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  int type_protos_size() const;
-  private:
-  int _internal_type_protos_size() const;
-  public:
-  void clear_type_protos();
-  ::onnx::TypeProto* mutable_type_protos(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >*
-      mutable_type_protos();
-  private:
-  const ::onnx::TypeProto& _internal_type_protos(int index) const;
-  ::onnx::TypeProto* _internal_add_type_protos();
-  public:
-  const ::onnx::TypeProto& type_protos(int index) const;
-  ::onnx::TypeProto* add_type_protos();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >&
-      type_protos() const;
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  int sparse_tensors_size() const;
-  private:
-  int _internal_sparse_tensors_size() const;
-  public:
-  void clear_sparse_tensors();
-  ::onnx::SparseTensorProto* mutable_sparse_tensors(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-      mutable_sparse_tensors();
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_tensors(int index) const;
-  ::onnx::SparseTensorProto* _internal_add_sparse_tensors();
-  public:
-  const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
-  ::onnx::SparseTensorProto* add_sparse_tensors();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-      sparse_tensors() const;
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional bytes s = 4;
-  bool has_s() const;
-  private:
-  bool _internal_has_s() const;
-  public:
-  void clear_s();
-  const std::string& s() const;
-  void set_s(const std::string& value);
-  void set_s(std::string&& value);
-  void set_s(const char* value);
-  void set_s(const void* value, size_t size);
-  std::string* mutable_s();
-  std::string* release_s();
-  void set_allocated_s(std::string* s);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_s();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_s(
-      std::string* s);
-  private:
-  const std::string& _internal_s() const;
-  void _internal_set_s(const std::string& value);
-  std::string* _internal_mutable_s();
-  public:
-
-  // optional string doc_string = 13;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional string ref_attr_name = 21;
-  bool has_ref_attr_name() const;
-  private:
-  bool _internal_has_ref_attr_name() const;
-  public:
-  void clear_ref_attr_name();
-  const std::string& ref_attr_name() const;
-  void set_ref_attr_name(const std::string& value);
-  void set_ref_attr_name(std::string&& value);
-  void set_ref_attr_name(const char* value);
-  void set_ref_attr_name(const char* value, size_t size);
-  std::string* mutable_ref_attr_name();
-  std::string* release_ref_attr_name();
-  void set_allocated_ref_attr_name(std::string* ref_attr_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_ref_attr_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_ref_attr_name(
-      std::string* ref_attr_name);
-  private:
-  const std::string& _internal_ref_attr_name() const;
-  void _internal_set_ref_attr_name(const std::string& value);
-  std::string* _internal_mutable_ref_attr_name();
-  public:
-
-  // optional .onnx.TensorProto t = 5;
-  bool has_t() const;
-  private:
-  bool _internal_has_t() const;
-  public:
-  void clear_t();
-  const ::onnx::TensorProto& t() const;
-  ::onnx::TensorProto* release_t();
-  ::onnx::TensorProto* mutable_t();
-  void set_allocated_t(::onnx::TensorProto* t);
-  private:
-  const ::onnx::TensorProto& _internal_t() const;
-  ::onnx::TensorProto* _internal_mutable_t();
-  public:
-  void unsafe_arena_set_allocated_t(
-      ::onnx::TensorProto* t);
-  ::onnx::TensorProto* unsafe_arena_release_t();
-
-  // optional .onnx.GraphProto g = 6;
-  bool has_g() const;
-  private:
-  bool _internal_has_g() const;
-  public:
-  void clear_g();
-  const ::onnx::GraphProto& g() const;
-  ::onnx::GraphProto* release_g();
-  ::onnx::GraphProto* mutable_g();
-  void set_allocated_g(::onnx::GraphProto* g);
-  private:
-  const ::onnx::GraphProto& _internal_g() const;
-  ::onnx::GraphProto* _internal_mutable_g();
-  public:
-  void unsafe_arena_set_allocated_g(
-      ::onnx::GraphProto* g);
-  ::onnx::GraphProto* unsafe_arena_release_g();
-
-  // optional .onnx.TypeProto tp = 14;
-  bool has_tp() const;
-  private:
-  bool _internal_has_tp() const;
-  public:
-  void clear_tp();
-  const ::onnx::TypeProto& tp() const;
-  ::onnx::TypeProto* release_tp();
-  ::onnx::TypeProto* mutable_tp();
-  void set_allocated_tp(::onnx::TypeProto* tp);
-  private:
-  const ::onnx::TypeProto& _internal_tp() const;
-  ::onnx::TypeProto* _internal_mutable_tp();
-  public:
-  void unsafe_arena_set_allocated_tp(
-      ::onnx::TypeProto* tp);
-  ::onnx::TypeProto* unsafe_arena_release_tp();
-
-  // optional .onnx.SparseTensorProto sparse_tensor = 22;
-  bool has_sparse_tensor() const;
-  private:
-  bool _internal_has_sparse_tensor() const;
-  public:
-  void clear_sparse_tensor();
-  const ::onnx::SparseTensorProto& sparse_tensor() const;
-  ::onnx::SparseTensorProto* release_sparse_tensor();
-  ::onnx::SparseTensorProto* mutable_sparse_tensor();
-  void set_allocated_sparse_tensor(::onnx::SparseTensorProto* sparse_tensor);
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
-  ::onnx::SparseTensorProto* _internal_mutable_sparse_tensor();
-  public:
-  void unsafe_arena_set_allocated_sparse_tensor(
-      ::onnx::SparseTensorProto* sparse_tensor);
-  ::onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor();
-
-  // optional int64 i = 3;
-  bool has_i() const;
-  private:
-  bool _internal_has_i() const;
-  public:
-  void clear_i();
-  ::PROTOBUF_NAMESPACE_ID::int64 i() const;
-  void set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_i() const;
-  void _internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // optional float f = 2;
-  bool has_f() const;
-  private:
-  bool _internal_has_f() const;
-  public:
-  void clear_f();
-  float f() const;
-  void set_f(float value);
-  private:
-  float _internal_f() const;
-  void _internal_set_f(float value);
-  public:
-
-  // optional .onnx.AttributeProto.AttributeType type = 20;
-  bool has_type() const;
-  private:
-  bool _internal_has_type() const;
-  public:
-  void clear_type();
-  ::onnx::AttributeProto_AttributeType type() const;
-  void set_type(::onnx::AttributeProto_AttributeType value);
-  private:
-  ::onnx::AttributeProto_AttributeType _internal_type() const;
-  void _internal_set_type(::onnx::AttributeProto_AttributeType value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ints_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto > tensors_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto > graphs_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ref_attr_name_;
-  ::onnx::TensorProto* t_;
-  ::onnx::GraphProto* g_;
-  ::onnx::TypeProto* tp_;
-  ::onnx::SparseTensorProto* sparse_tensor_;
-  ::PROTOBUF_NAMESPACE_ID::int64 i_;
-  float f_;
-  int type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class ValueInfoProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
- public:
-  inline ValueInfoProto() : ValueInfoProto(nullptr) {};
-  virtual ~ValueInfoProto();
-
-  ValueInfoProto(const ValueInfoProto& from);
-  ValueInfoProto(ValueInfoProto&& from) noexcept
-    : ValueInfoProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ValueInfoProto& operator=(const ValueInfoProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const ValueInfoProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ValueInfoProto* internal_default_instance() {
-    return reinterpret_cast<const ValueInfoProto*>(
-               &_ValueInfoProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ValueInfoProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ValueInfoProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ValueInfoProto* New() const final {
-    return CreateMaybeMessage<ValueInfoProto>(nullptr);
-  }
-
-  ValueInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ValueInfoProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ValueInfoProto& from);
-  void MergeFrom(const ValueInfoProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ValueInfoProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ValueInfoProto";
-  }
-  protected:
-  explicit ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kMetadataPropsFieldNumber = 4,
-    kNameFieldNumber = 1,
-    kDocStringFieldNumber = 3,
-    kTypeFieldNumber = 2,
-  };
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string doc_string = 3;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional .onnx.TypeProto type = 2;
-  bool has_type() const;
-  private:
-  bool _internal_has_type() const;
-  public:
-  void clear_type();
-  const ::onnx::TypeProto& type() const;
-  ::onnx::TypeProto* release_type();
-  ::onnx::TypeProto* mutable_type();
-  void set_allocated_type(::onnx::TypeProto* type);
-  private:
-  const ::onnx::TypeProto& _internal_type() const;
-  ::onnx::TypeProto* _internal_mutable_type();
-  public:
-  void unsafe_arena_set_allocated_type(
-      ::onnx::TypeProto* type);
-  ::onnx::TypeProto* unsafe_arena_release_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::TypeProto* type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class NodeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
- public:
-  inline NodeProto() : NodeProto(nullptr) {};
-  virtual ~NodeProto();
-
-  NodeProto(const NodeProto& from);
-  NodeProto(NodeProto&& from) noexcept
-    : NodeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline NodeProto& operator=(const NodeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline NodeProto& operator=(NodeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const NodeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const NodeProto* internal_default_instance() {
-    return reinterpret_cast<const NodeProto*>(
-               &_NodeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(NodeProto& a, NodeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(NodeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(NodeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline NodeProto* New() const final {
-    return CreateMaybeMessage<NodeProto>(nullptr);
-  }
-
-  NodeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NodeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const NodeProto& from);
-  void MergeFrom(const NodeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(NodeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.NodeProto";
-  }
-  protected:
-  explicit NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInputFieldNumber = 1,
-    kOutputFieldNumber = 2,
-    kAttributeFieldNumber = 5,
-    kMetadataPropsFieldNumber = 9,
-    kDeviceConfigurationsFieldNumber = 10,
-    kNameFieldNumber = 3,
-    kOpTypeFieldNumber = 4,
-    kDocStringFieldNumber = 6,
-    kDomainFieldNumber = 7,
-    kOverloadFieldNumber = 8,
-  };
-  // repeated string input = 1;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  const std::string& input(int index) const;
-  std::string* mutable_input(int index);
-  void set_input(int index, const std::string& value);
-  void set_input(int index, std::string&& value);
-  void set_input(int index, const char* value);
-  void set_input(int index, const char* value, size_t size);
-  std::string* add_input();
-  void add_input(const std::string& value);
-  void add_input(std::string&& value);
-  void add_input(const char* value);
-  void add_input(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
-  private:
-  const std::string& _internal_input(int index) const;
-  std::string* _internal_add_input();
-  public:
-
-  // repeated string output = 2;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  const std::string& output(int index) const;
-  std::string* mutable_output(int index);
-  void set_output(int index, const std::string& value);
-  void set_output(int index, std::string&& value);
-  void set_output(int index, const char* value);
-  void set_output(int index, const char* value, size_t size);
-  std::string* add_output();
-  void add_output(const std::string& value);
-  void add_output(std::string&& value);
-  void add_output(const char* value);
-  void add_output(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
-  private:
-  const std::string& _internal_output(int index) const;
-  std::string* _internal_add_output();
-  public:
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  int attribute_size() const;
-  private:
-  int _internal_attribute_size() const;
-  public:
-  void clear_attribute();
-  ::onnx::AttributeProto* mutable_attribute(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-      mutable_attribute();
-  private:
-  const ::onnx::AttributeProto& _internal_attribute(int index) const;
-  ::onnx::AttributeProto* _internal_add_attribute();
-  public:
-  const ::onnx::AttributeProto& attribute(int index) const;
-  ::onnx::AttributeProto* add_attribute();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-      attribute() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  int device_configurations_size() const;
-  private:
-  int _internal_device_configurations_size() const;
-  public:
-  void clear_device_configurations();
-  ::onnx::NodeDeviceConfigurationProto* mutable_device_configurations(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >*
-      mutable_device_configurations();
-  private:
-  const ::onnx::NodeDeviceConfigurationProto& _internal_device_configurations(int index) const;
-  ::onnx::NodeDeviceConfigurationProto* _internal_add_device_configurations();
-  public:
-  const ::onnx::NodeDeviceConfigurationProto& device_configurations(int index) const;
-  ::onnx::NodeDeviceConfigurationProto* add_device_configurations();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >&
-      device_configurations() const;
-
-  // optional string name = 3;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string op_type = 4;
-  bool has_op_type() const;
-  private:
-  bool _internal_has_op_type() const;
-  public:
-  void clear_op_type();
-  const std::string& op_type() const;
-  void set_op_type(const std::string& value);
-  void set_op_type(std::string&& value);
-  void set_op_type(const char* value);
-  void set_op_type(const char* value, size_t size);
-  std::string* mutable_op_type();
-  std::string* release_op_type();
-  void set_allocated_op_type(std::string* op_type);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_op_type();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_op_type(
-      std::string* op_type);
-  private:
-  const std::string& _internal_op_type() const;
-  void _internal_set_op_type(const std::string& value);
-  std::string* _internal_mutable_op_type();
-  public:
-
-  // optional string doc_string = 6;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional string domain = 7;
-  bool has_domain() const;
-  private:
-  bool _internal_has_domain() const;
-  public:
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // optional string overload = 8;
-  bool has_overload() const;
-  private:
-  bool _internal_has_overload() const;
-  public:
-  void clear_overload();
-  const std::string& overload() const;
-  void set_overload(const std::string& value);
-  void set_overload(std::string&& value);
-  void set_overload(const char* value);
-  void set_overload(const char* value, size_t size);
-  std::string* mutable_overload();
-  std::string* release_overload();
-  void set_allocated_overload(std::string* overload);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_overload();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_overload(
-      std::string* overload);
-  private:
-  const std::string& _internal_overload() const;
-  void _internal_set_overload(const std::string& value);
-  std::string* _internal_mutable_overload();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.NodeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto > device_configurations_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class IntIntListEntryProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.IntIntListEntryProto) */ {
- public:
-  inline IntIntListEntryProto() : IntIntListEntryProto(nullptr) {};
-  virtual ~IntIntListEntryProto();
-
-  IntIntListEntryProto(const IntIntListEntryProto& from);
-  IntIntListEntryProto(IntIntListEntryProto&& from) noexcept
-    : IntIntListEntryProto() {
-    *this = ::std::move(from);
-  }
-
-  inline IntIntListEntryProto& operator=(const IntIntListEntryProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline IntIntListEntryProto& operator=(IntIntListEntryProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const IntIntListEntryProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const IntIntListEntryProto* internal_default_instance() {
-    return reinterpret_cast<const IntIntListEntryProto*>(
-               &_IntIntListEntryProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(IntIntListEntryProto& a, IntIntListEntryProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(IntIntListEntryProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(IntIntListEntryProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline IntIntListEntryProto* New() const final {
-    return CreateMaybeMessage<IntIntListEntryProto>(nullptr);
-  }
-
-  IntIntListEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<IntIntListEntryProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const IntIntListEntryProto& from);
-  void MergeFrom(const IntIntListEntryProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(IntIntListEntryProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.IntIntListEntryProto";
-  }
-  protected:
-  explicit IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 2,
-    kKeyFieldNumber = 1,
-  };
-  // repeated int64 value = 2;
-  int value_size() const;
-  private:
-  int _internal_value_size() const;
-  public:
-  void clear_value();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_value(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_value() const;
-  void _internal_add_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_value();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 value(int index) const;
-  void set_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      value() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_value();
-
-  // optional int64 key = 1;
-  bool has_key() const;
-  private:
-  bool _internal_has_key() const;
-  public:
-  void clear_key();
-  ::PROTOBUF_NAMESPACE_ID::int64 key() const;
-  void set_key(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_key() const;
-  void _internal_set_key(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.IntIntListEntryProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > value_;
-  ::PROTOBUF_NAMESPACE_ID::int64 key_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class NodeDeviceConfigurationProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.NodeDeviceConfigurationProto) */ {
- public:
-  inline NodeDeviceConfigurationProto() : NodeDeviceConfigurationProto(nullptr) {};
-  virtual ~NodeDeviceConfigurationProto();
-
-  NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from);
-  NodeDeviceConfigurationProto(NodeDeviceConfigurationProto&& from) noexcept
-    : NodeDeviceConfigurationProto() {
-    *this = ::std::move(from);
-  }
-
-  inline NodeDeviceConfigurationProto& operator=(const NodeDeviceConfigurationProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline NodeDeviceConfigurationProto& operator=(NodeDeviceConfigurationProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const NodeDeviceConfigurationProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const NodeDeviceConfigurationProto* internal_default_instance() {
-    return reinterpret_cast<const NodeDeviceConfigurationProto*>(
-               &_NodeDeviceConfigurationProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(NodeDeviceConfigurationProto& a, NodeDeviceConfigurationProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(NodeDeviceConfigurationProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(NodeDeviceConfigurationProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline NodeDeviceConfigurationProto* New() const final {
-    return CreateMaybeMessage<NodeDeviceConfigurationProto>(nullptr);
-  }
-
-  NodeDeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NodeDeviceConfigurationProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const NodeDeviceConfigurationProto& from);
-  void MergeFrom(const NodeDeviceConfigurationProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(NodeDeviceConfigurationProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.NodeDeviceConfigurationProto";
-  }
-  protected:
-  explicit NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShardingSpecFieldNumber = 2,
-    kConfigurationIdFieldNumber = 1,
-    kPipelineStageFieldNumber = 3,
-  };
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  int sharding_spec_size() const;
-  private:
-  int _internal_sharding_spec_size() const;
-  public:
-  void clear_sharding_spec();
-  ::onnx::ShardingSpecProto* mutable_sharding_spec(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >*
-      mutable_sharding_spec();
-  private:
-  const ::onnx::ShardingSpecProto& _internal_sharding_spec(int index) const;
-  ::onnx::ShardingSpecProto* _internal_add_sharding_spec();
-  public:
-  const ::onnx::ShardingSpecProto& sharding_spec(int index) const;
-  ::onnx::ShardingSpecProto* add_sharding_spec();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >&
-      sharding_spec() const;
-
-  // optional string configuration_id = 1;
-  bool has_configuration_id() const;
-  private:
-  bool _internal_has_configuration_id() const;
-  public:
-  void clear_configuration_id();
-  const std::string& configuration_id() const;
-  void set_configuration_id(const std::string& value);
-  void set_configuration_id(std::string&& value);
-  void set_configuration_id(const char* value);
-  void set_configuration_id(const char* value, size_t size);
-  std::string* mutable_configuration_id();
-  std::string* release_configuration_id();
-  void set_allocated_configuration_id(std::string* configuration_id);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_configuration_id();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_configuration_id(
-      std::string* configuration_id);
-  private:
-  const std::string& _internal_configuration_id() const;
-  void _internal_set_configuration_id(const std::string& value);
-  std::string* _internal_mutable_configuration_id();
-  public:
-
-  // optional int32 pipeline_stage = 3;
-  bool has_pipeline_stage() const;
-  private:
-  bool _internal_has_pipeline_stage() const;
-  public:
-  void clear_pipeline_stage();
-  ::PROTOBUF_NAMESPACE_ID::int32 pipeline_stage() const;
-  void set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pipeline_stage() const;
-  void _internal_set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.NodeDeviceConfigurationProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto > sharding_spec_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr configuration_id_;
-  ::PROTOBUF_NAMESPACE_ID::int32 pipeline_stage_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class ShardingSpecProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ShardingSpecProto) */ {
- public:
-  inline ShardingSpecProto() : ShardingSpecProto(nullptr) {};
-  virtual ~ShardingSpecProto();
-
-  ShardingSpecProto(const ShardingSpecProto& from);
-  ShardingSpecProto(ShardingSpecProto&& from) noexcept
-    : ShardingSpecProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ShardingSpecProto& operator=(const ShardingSpecProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ShardingSpecProto& operator=(ShardingSpecProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const ShardingSpecProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ShardingSpecProto* internal_default_instance() {
-    return reinterpret_cast<const ShardingSpecProto*>(
-               &_ShardingSpecProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    5;
-
-  friend void swap(ShardingSpecProto& a, ShardingSpecProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ShardingSpecProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ShardingSpecProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ShardingSpecProto* New() const final {
-    return CreateMaybeMessage<ShardingSpecProto>(nullptr);
-  }
-
-  ShardingSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ShardingSpecProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ShardingSpecProto& from);
-  void MergeFrom(const ShardingSpecProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ShardingSpecProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ShardingSpecProto";
-  }
-  protected:
-  explicit ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDeviceFieldNumber = 2,
-    kIndexToDeviceGroupMapFieldNumber = 3,
-    kShardedDimFieldNumber = 4,
-    kTensorNameFieldNumber = 1,
-  };
-  // repeated int64 device = 2;
-  int device_size() const;
-  private:
-  int _internal_device_size() const;
-  public:
-  void clear_device();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_device(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_device() const;
-  void _internal_add_device(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_device();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 device(int index) const;
-  void set_device(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_device(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      device() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_device();
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  int index_to_device_group_map_size() const;
-  private:
-  int _internal_index_to_device_group_map_size() const;
-  public:
-  void clear_index_to_device_group_map();
-  ::onnx::IntIntListEntryProto* mutable_index_to_device_group_map(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >*
-      mutable_index_to_device_group_map();
-  private:
-  const ::onnx::IntIntListEntryProto& _internal_index_to_device_group_map(int index) const;
-  ::onnx::IntIntListEntryProto* _internal_add_index_to_device_group_map();
-  public:
-  const ::onnx::IntIntListEntryProto& index_to_device_group_map(int index) const;
-  ::onnx::IntIntListEntryProto* add_index_to_device_group_map();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >&
-      index_to_device_group_map() const;
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  int sharded_dim_size() const;
-  private:
-  int _internal_sharded_dim_size() const;
-  public:
-  void clear_sharded_dim();
-  ::onnx::ShardedDimProto* mutable_sharded_dim(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >*
-      mutable_sharded_dim();
-  private:
-  const ::onnx::ShardedDimProto& _internal_sharded_dim(int index) const;
-  ::onnx::ShardedDimProto* _internal_add_sharded_dim();
-  public:
-  const ::onnx::ShardedDimProto& sharded_dim(int index) const;
-  ::onnx::ShardedDimProto* add_sharded_dim();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >&
-      sharded_dim() const;
-
-  // optional string tensor_name = 1;
-  bool has_tensor_name() const;
-  private:
-  bool _internal_has_tensor_name() const;
-  public:
-  void clear_tensor_name();
-  const std::string& tensor_name() const;
-  void set_tensor_name(const std::string& value);
-  void set_tensor_name(std::string&& value);
-  void set_tensor_name(const char* value);
-  void set_tensor_name(const char* value, size_t size);
-  std::string* mutable_tensor_name();
-  std::string* release_tensor_name();
-  void set_allocated_tensor_name(std::string* tensor_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_tensor_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_tensor_name(
-      std::string* tensor_name);
-  private:
-  const std::string& _internal_tensor_name() const;
-  void _internal_set_tensor_name(const std::string& value);
-  std::string* _internal_mutable_tensor_name();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ShardingSpecProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > device_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto > index_to_device_group_map_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto > sharded_dim_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class ShardedDimProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ShardedDimProto) */ {
- public:
-  inline ShardedDimProto() : ShardedDimProto(nullptr) {};
-  virtual ~ShardedDimProto();
-
-  ShardedDimProto(const ShardedDimProto& from);
-  ShardedDimProto(ShardedDimProto&& from) noexcept
-    : ShardedDimProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ShardedDimProto& operator=(const ShardedDimProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ShardedDimProto& operator=(ShardedDimProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const ShardedDimProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ShardedDimProto* internal_default_instance() {
-    return reinterpret_cast<const ShardedDimProto*>(
-               &_ShardedDimProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    6;
-
-  friend void swap(ShardedDimProto& a, ShardedDimProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ShardedDimProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ShardedDimProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ShardedDimProto* New() const final {
-    return CreateMaybeMessage<ShardedDimProto>(nullptr);
-  }
-
-  ShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ShardedDimProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ShardedDimProto& from);
-  void MergeFrom(const ShardedDimProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ShardedDimProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ShardedDimProto";
-  }
-  protected:
-  explicit ShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kSimpleShardingFieldNumber = 2,
-    kAxisFieldNumber = 1,
-  };
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  int simple_sharding_size() const;
-  private:
-  int _internal_simple_sharding_size() const;
-  public:
-  void clear_simple_sharding();
-  ::onnx::SimpleShardedDimProto* mutable_simple_sharding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >*
-      mutable_simple_sharding();
-  private:
-  const ::onnx::SimpleShardedDimProto& _internal_simple_sharding(int index) const;
-  ::onnx::SimpleShardedDimProto* _internal_add_simple_sharding();
-  public:
-  const ::onnx::SimpleShardedDimProto& simple_sharding(int index) const;
-  ::onnx::SimpleShardedDimProto* add_simple_sharding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >&
-      simple_sharding() const;
-
-  // optional int64 axis = 1;
-  bool has_axis() const;
-  private:
-  bool _internal_has_axis() const;
-  public:
-  void clear_axis();
-  ::PROTOBUF_NAMESPACE_ID::int64 axis() const;
-  void set_axis(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_axis() const;
-  void _internal_set_axis(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ShardedDimProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto > simple_sharding_;
-  ::PROTOBUF_NAMESPACE_ID::int64 axis_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class SimpleShardedDimProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.SimpleShardedDimProto) */ {
- public:
-  inline SimpleShardedDimProto() : SimpleShardedDimProto(nullptr) {};
-  virtual ~SimpleShardedDimProto();
-
-  SimpleShardedDimProto(const SimpleShardedDimProto& from);
-  SimpleShardedDimProto(SimpleShardedDimProto&& from) noexcept
-    : SimpleShardedDimProto() {
-    *this = ::std::move(from);
-  }
-
-  inline SimpleShardedDimProto& operator=(const SimpleShardedDimProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SimpleShardedDimProto& operator=(SimpleShardedDimProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const SimpleShardedDimProto& default_instance();
-
-  enum DimCase {
-    kDimValue = 1,
-    kDimParam = 2,
-    DIM_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const SimpleShardedDimProto* internal_default_instance() {
-    return reinterpret_cast<const SimpleShardedDimProto*>(
-               &_SimpleShardedDimProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    7;
-
-  friend void swap(SimpleShardedDimProto& a, SimpleShardedDimProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SimpleShardedDimProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SimpleShardedDimProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline SimpleShardedDimProto* New() const final {
-    return CreateMaybeMessage<SimpleShardedDimProto>(nullptr);
-  }
-
-  SimpleShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<SimpleShardedDimProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const SimpleShardedDimProto& from);
-  void MergeFrom(const SimpleShardedDimProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(SimpleShardedDimProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.SimpleShardedDimProto";
-  }
-  protected:
-  explicit SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNumShardsFieldNumber = 3,
-    kDimValueFieldNumber = 1,
-    kDimParamFieldNumber = 2,
-  };
-  // optional int64 num_shards = 3;
-  bool has_num_shards() const;
-  private:
-  bool _internal_has_num_shards() const;
-  public:
-  void clear_num_shards();
-  ::PROTOBUF_NAMESPACE_ID::int64 num_shards() const;
-  void set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_shards() const;
-  void _internal_set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // int64 dim_value = 1;
-  bool has_dim_value() const;
-  private:
-  bool _internal_has_dim_value() const;
-  public:
-  void clear_dim_value();
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value() const;
-  void set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dim_value() const;
-  void _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // string dim_param = 2;
-  bool has_dim_param() const;
-  private:
-  bool _internal_has_dim_param() const;
-  public:
-  void clear_dim_param();
-  const std::string& dim_param() const;
-  void set_dim_param(const std::string& value);
-  void set_dim_param(std::string&& value);
-  void set_dim_param(const char* value);
-  void set_dim_param(const char* value, size_t size);
-  std::string* mutable_dim_param();
-  std::string* release_dim_param();
-  void set_allocated_dim_param(std::string* dim_param);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_dim_param();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_dim_param(
-      std::string* dim_param);
-  private:
-  const std::string& _internal_dim_param() const;
-  void _internal_set_dim_param(const std::string& value);
-  std::string* _internal_mutable_dim_param();
-  public:
-
-  void clear_dim();
-  DimCase dim_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.SimpleShardedDimProto)
- private:
-  class _Internal;
-  void set_has_dim_value();
-  void set_has_dim_param();
-
-  inline bool has_dim() const;
-  inline void clear_has_dim();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::int64 num_shards_;
-  union DimUnion {
-    DimUnion() {}
-    ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-  } dim_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TrainingInfoProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
- public:
-  inline TrainingInfoProto() : TrainingInfoProto(nullptr) {};
-  virtual ~TrainingInfoProto();
-
-  TrainingInfoProto(const TrainingInfoProto& from);
-  TrainingInfoProto(TrainingInfoProto&& from) noexcept
-    : TrainingInfoProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TrainingInfoProto& operator=(TrainingInfoProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TrainingInfoProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TrainingInfoProto* internal_default_instance() {
-    return reinterpret_cast<const TrainingInfoProto*>(
-               &_TrainingInfoProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    8;
-
-  friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TrainingInfoProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TrainingInfoProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TrainingInfoProto* New() const final {
-    return CreateMaybeMessage<TrainingInfoProto>(nullptr);
-  }
-
-  TrainingInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TrainingInfoProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TrainingInfoProto& from);
-  void MergeFrom(const TrainingInfoProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TrainingInfoProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TrainingInfoProto";
-  }
-  protected:
-  explicit TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInitializationBindingFieldNumber = 3,
-    kUpdateBindingFieldNumber = 4,
-    kInitializationFieldNumber = 1,
-    kAlgorithmFieldNumber = 2,
-  };
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  int initialization_binding_size() const;
-  private:
-  int _internal_initialization_binding_size() const;
-  public:
-  void clear_initialization_binding();
-  ::onnx::StringStringEntryProto* mutable_initialization_binding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_initialization_binding();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_initialization_binding(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_initialization_binding();
-  public:
-  const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
-  ::onnx::StringStringEntryProto* add_initialization_binding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      initialization_binding() const;
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  int update_binding_size() const;
-  private:
-  int _internal_update_binding_size() const;
-  public:
-  void clear_update_binding();
-  ::onnx::StringStringEntryProto* mutable_update_binding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_update_binding();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_update_binding(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_update_binding();
-  public:
-  const ::onnx::StringStringEntryProto& update_binding(int index) const;
-  ::onnx::StringStringEntryProto* add_update_binding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      update_binding() const;
-
-  // optional .onnx.GraphProto initialization = 1;
-  bool has_initialization() const;
-  private:
-  bool _internal_has_initialization() const;
-  public:
-  void clear_initialization();
-  const ::onnx::GraphProto& initialization() const;
-  ::onnx::GraphProto* release_initialization();
-  ::onnx::GraphProto* mutable_initialization();
-  void set_allocated_initialization(::onnx::GraphProto* initialization);
-  private:
-  const ::onnx::GraphProto& _internal_initialization() const;
-  ::onnx::GraphProto* _internal_mutable_initialization();
-  public:
-  void unsafe_arena_set_allocated_initialization(
-      ::onnx::GraphProto* initialization);
-  ::onnx::GraphProto* unsafe_arena_release_initialization();
-
-  // optional .onnx.GraphProto algorithm = 2;
-  bool has_algorithm() const;
-  private:
-  bool _internal_has_algorithm() const;
-  public:
-  void clear_algorithm();
-  const ::onnx::GraphProto& algorithm() const;
-  ::onnx::GraphProto* release_algorithm();
-  ::onnx::GraphProto* mutable_algorithm();
-  void set_allocated_algorithm(::onnx::GraphProto* algorithm);
-  private:
-  const ::onnx::GraphProto& _internal_algorithm() const;
-  ::onnx::GraphProto* _internal_mutable_algorithm();
-  public:
-  void unsafe_arena_set_allocated_algorithm(
-      ::onnx::GraphProto* algorithm);
-  ::onnx::GraphProto* unsafe_arena_release_algorithm();
-
-  // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
-  ::onnx::GraphProto* initialization_;
-  ::onnx::GraphProto* algorithm_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class ModelProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
- public:
-  inline ModelProto() : ModelProto(nullptr) {};
-  virtual ~ModelProto();
-
-  ModelProto(const ModelProto& from);
-  ModelProto(ModelProto&& from) noexcept
-    : ModelProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ModelProto& operator=(const ModelProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ModelProto& operator=(ModelProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const ModelProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ModelProto* internal_default_instance() {
-    return reinterpret_cast<const ModelProto*>(
-               &_ModelProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    9;
-
-  friend void swap(ModelProto& a, ModelProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ModelProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ModelProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ModelProto* New() const final {
-    return CreateMaybeMessage<ModelProto>(nullptr);
-  }
-
-  ModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ModelProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ModelProto& from);
-  void MergeFrom(const ModelProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ModelProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ModelProto";
-  }
-  protected:
-  explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOpsetImportFieldNumber = 8,
-    kMetadataPropsFieldNumber = 14,
-    kTrainingInfoFieldNumber = 20,
-    kFunctionsFieldNumber = 25,
-    kConfigurationFieldNumber = 26,
-    kProducerNameFieldNumber = 2,
-    kProducerVersionFieldNumber = 3,
-    kDomainFieldNumber = 4,
-    kDocStringFieldNumber = 6,
-    kGraphFieldNumber = 7,
-    kIrVersionFieldNumber = 1,
-    kModelVersionFieldNumber = 5,
-  };
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  int opset_import_size() const;
-  private:
-  int _internal_opset_import_size() const;
-  public:
-  void clear_opset_import();
-  ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-      mutable_opset_import();
-  private:
-  const ::onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* _internal_add_opset_import();
-  public:
-  const ::onnx::OperatorSetIdProto& opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* add_opset_import();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-      opset_import() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  int training_info_size() const;
-  private:
-  int _internal_training_info_size() const;
-  public:
-  void clear_training_info();
-  ::onnx::TrainingInfoProto* mutable_training_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >*
-      mutable_training_info();
-  private:
-  const ::onnx::TrainingInfoProto& _internal_training_info(int index) const;
-  ::onnx::TrainingInfoProto* _internal_add_training_info();
-  public:
-  const ::onnx::TrainingInfoProto& training_info(int index) const;
-  ::onnx::TrainingInfoProto* add_training_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >&
-      training_info() const;
-
-  // repeated .onnx.FunctionProto functions = 25;
-  int functions_size() const;
-  private:
-  int _internal_functions_size() const;
-  public:
-  void clear_functions();
-  ::onnx::FunctionProto* mutable_functions(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >*
-      mutable_functions();
-  private:
-  const ::onnx::FunctionProto& _internal_functions(int index) const;
-  ::onnx::FunctionProto* _internal_add_functions();
-  public:
-  const ::onnx::FunctionProto& functions(int index) const;
-  ::onnx::FunctionProto* add_functions();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >&
-      functions() const;
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  int configuration_size() const;
-  private:
-  int _internal_configuration_size() const;
-  public:
-  void clear_configuration();
-  ::onnx::DeviceConfigurationProto* mutable_configuration(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >*
-      mutable_configuration();
-  private:
-  const ::onnx::DeviceConfigurationProto& _internal_configuration(int index) const;
-  ::onnx::DeviceConfigurationProto* _internal_add_configuration();
-  public:
-  const ::onnx::DeviceConfigurationProto& configuration(int index) const;
-  ::onnx::DeviceConfigurationProto* add_configuration();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >&
-      configuration() const;
-
-  // optional string producer_name = 2;
-  bool has_producer_name() const;
-  private:
-  bool _internal_has_producer_name() const;
-  public:
-  void clear_producer_name();
-  const std::string& producer_name() const;
-  void set_producer_name(const std::string& value);
-  void set_producer_name(std::string&& value);
-  void set_producer_name(const char* value);
-  void set_producer_name(const char* value, size_t size);
-  std::string* mutable_producer_name();
-  std::string* release_producer_name();
-  void set_allocated_producer_name(std::string* producer_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_producer_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_producer_name(
-      std::string* producer_name);
-  private:
-  const std::string& _internal_producer_name() const;
-  void _internal_set_producer_name(const std::string& value);
-  std::string* _internal_mutable_producer_name();
-  public:
-
-  // optional string producer_version = 3;
-  bool has_producer_version() const;
-  private:
-  bool _internal_has_producer_version() const;
-  public:
-  void clear_producer_version();
-  const std::string& producer_version() const;
-  void set_producer_version(const std::string& value);
-  void set_producer_version(std::string&& value);
-  void set_producer_version(const char* value);
-  void set_producer_version(const char* value, size_t size);
-  std::string* mutable_producer_version();
-  std::string* release_producer_version();
-  void set_allocated_producer_version(std::string* producer_version);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_producer_version();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_producer_version(
-      std::string* producer_version);
-  private:
-  const std::string& _internal_producer_version() const;
-  void _internal_set_producer_version(const std::string& value);
-  std::string* _internal_mutable_producer_version();
-  public:
-
-  // optional string domain = 4;
-  bool has_domain() const;
-  private:
-  bool _internal_has_domain() const;
-  public:
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // optional string doc_string = 6;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional .onnx.GraphProto graph = 7;
-  bool has_graph() const;
-  private:
-  bool _internal_has_graph() const;
-  public:
-  void clear_graph();
-  const ::onnx::GraphProto& graph() const;
-  ::onnx::GraphProto* release_graph();
-  ::onnx::GraphProto* mutable_graph();
-  void set_allocated_graph(::onnx::GraphProto* graph);
-  private:
-  const ::onnx::GraphProto& _internal_graph() const;
-  ::onnx::GraphProto* _internal_mutable_graph();
-  public:
-  void unsafe_arena_set_allocated_graph(
-      ::onnx::GraphProto* graph);
-  ::onnx::GraphProto* unsafe_arena_release_graph();
-
-  // optional int64 ir_version = 1;
-  bool has_ir_version() const;
-  private:
-  bool _internal_has_ir_version() const;
-  public:
-  void clear_ir_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 ir_version() const;
-  void set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_ir_version() const;
-  void _internal_set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // optional int64 model_version = 5;
-  bool has_model_version() const;
-  private:
-  bool _internal_has_model_version() const;
-  public:
-  void clear_model_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 model_version() const;
-  void set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_model_version() const;
-  void _internal_set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ModelProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto > functions_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto > configuration_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_version_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::GraphProto* graph_;
-  ::PROTOBUF_NAMESPACE_ID::int64 ir_version_;
-  ::PROTOBUF_NAMESPACE_ID::int64 model_version_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class DeviceConfigurationProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.DeviceConfigurationProto) */ {
- public:
-  inline DeviceConfigurationProto() : DeviceConfigurationProto(nullptr) {};
-  virtual ~DeviceConfigurationProto();
-
-  DeviceConfigurationProto(const DeviceConfigurationProto& from);
-  DeviceConfigurationProto(DeviceConfigurationProto&& from) noexcept
-    : DeviceConfigurationProto() {
-    *this = ::std::move(from);
-  }
-
-  inline DeviceConfigurationProto& operator=(const DeviceConfigurationProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DeviceConfigurationProto& operator=(DeviceConfigurationProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const DeviceConfigurationProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const DeviceConfigurationProto* internal_default_instance() {
-    return reinterpret_cast<const DeviceConfigurationProto*>(
-               &_DeviceConfigurationProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    10;
-
-  friend void swap(DeviceConfigurationProto& a, DeviceConfigurationProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DeviceConfigurationProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DeviceConfigurationProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline DeviceConfigurationProto* New() const final {
-    return CreateMaybeMessage<DeviceConfigurationProto>(nullptr);
-  }
-
-  DeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<DeviceConfigurationProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const DeviceConfigurationProto& from);
-  void MergeFrom(const DeviceConfigurationProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(DeviceConfigurationProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.DeviceConfigurationProto";
-  }
-  protected:
-  explicit DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDeviceFieldNumber = 3,
-    kNameFieldNumber = 1,
-    kNumDevicesFieldNumber = 2,
-  };
-  // repeated string device = 3;
-  int device_size() const;
-  private:
-  int _internal_device_size() const;
-  public:
-  void clear_device();
-  const std::string& device(int index) const;
-  std::string* mutable_device(int index);
-  void set_device(int index, const std::string& value);
-  void set_device(int index, std::string&& value);
-  void set_device(int index, const char* value);
-  void set_device(int index, const char* value, size_t size);
-  std::string* add_device();
-  void add_device(const std::string& value);
-  void add_device(std::string&& value);
-  void add_device(const char* value);
-  void add_device(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device();
-  private:
-  const std::string& _internal_device(int index) const;
-  std::string* _internal_add_device();
-  public:
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional int32 num_devices = 2;
-  bool has_num_devices() const;
-  private:
-  bool _internal_has_num_devices() const;
-  public:
-  void clear_num_devices();
-  ::PROTOBUF_NAMESPACE_ID::int32 num_devices() const;
-  void set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_devices() const;
-  void _internal_set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.DeviceConfigurationProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::int32 num_devices_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class StringStringEntryProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
- public:
-  inline StringStringEntryProto() : StringStringEntryProto(nullptr) {};
-  virtual ~StringStringEntryProto();
-
-  StringStringEntryProto(const StringStringEntryProto& from);
-  StringStringEntryProto(StringStringEntryProto&& from) noexcept
-    : StringStringEntryProto() {
-    *this = ::std::move(from);
-  }
-
-  inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const StringStringEntryProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const StringStringEntryProto* internal_default_instance() {
-    return reinterpret_cast<const StringStringEntryProto*>(
-               &_StringStringEntryProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    11;
-
-  friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(StringStringEntryProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(StringStringEntryProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline StringStringEntryProto* New() const final {
-    return CreateMaybeMessage<StringStringEntryProto>(nullptr);
-  }
-
-  StringStringEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<StringStringEntryProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const StringStringEntryProto& from);
-  void MergeFrom(const StringStringEntryProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(StringStringEntryProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.StringStringEntryProto";
-  }
-  protected:
-  explicit StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  // optional string key = 1;
-  bool has_key() const;
-  private:
-  bool _internal_has_key() const;
-  public:
-  void clear_key();
-  const std::string& key() const;
-  void set_key(const std::string& value);
-  void set_key(std::string&& value);
-  void set_key(const char* value);
-  void set_key(const char* value, size_t size);
-  std::string* mutable_key();
-  std::string* release_key();
-  void set_allocated_key(std::string* key);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_key();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_key(
-      std::string* key);
-  private:
-  const std::string& _internal_key() const;
-  void _internal_set_key(const std::string& value);
-  std::string* _internal_mutable_key();
-  public:
-
-  // optional string value = 2;
-  bool has_value() const;
-  private:
-  bool _internal_has_value() const;
-  public:
-  void clear_value();
-  const std::string& value() const;
-  void set_value(const std::string& value);
-  void set_value(std::string&& value);
-  void set_value(const char* value);
-  void set_value(const char* value, size_t size);
-  std::string* mutable_value();
-  std::string* release_value();
-  void set_allocated_value(std::string* value);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_value();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_value(
-      std::string* value);
-  private:
-  const std::string& _internal_value() const;
-  void _internal_set_value(const std::string& value);
-  std::string* _internal_mutable_value();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TensorAnnotation PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
- public:
-  inline TensorAnnotation() : TensorAnnotation(nullptr) {};
-  virtual ~TensorAnnotation();
-
-  TensorAnnotation(const TensorAnnotation& from);
-  TensorAnnotation(TensorAnnotation&& from) noexcept
-    : TensorAnnotation() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorAnnotation& operator=(const TensorAnnotation& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TensorAnnotation& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorAnnotation* internal_default_instance() {
-    return reinterpret_cast<const TensorAnnotation*>(
-               &_TensorAnnotation_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    12;
-
-  friend void swap(TensorAnnotation& a, TensorAnnotation& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorAnnotation* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorAnnotation* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorAnnotation* New() const final {
-    return CreateMaybeMessage<TensorAnnotation>(nullptr);
-  }
-
-  TensorAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorAnnotation>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorAnnotation& from);
-  void MergeFrom(const TensorAnnotation& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorAnnotation* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorAnnotation";
-  }
-  protected:
-  explicit TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kQuantParameterTensorNamesFieldNumber = 2,
-    kTensorNameFieldNumber = 1,
-  };
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  int quant_parameter_tensor_names_size() const;
-  private:
-  int _internal_quant_parameter_tensor_names_size() const;
-  public:
-  void clear_quant_parameter_tensor_names();
-  ::onnx::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_quant_parameter_tensor_names();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_quant_parameter_tensor_names(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_quant_parameter_tensor_names();
-  public:
-  const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
-  ::onnx::StringStringEntryProto* add_quant_parameter_tensor_names();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      quant_parameter_tensor_names() const;
-
-  // optional string tensor_name = 1;
-  bool has_tensor_name() const;
-  private:
-  bool _internal_has_tensor_name() const;
-  public:
-  void clear_tensor_name();
-  const std::string& tensor_name() const;
-  void set_tensor_name(const std::string& value);
-  void set_tensor_name(std::string&& value);
-  void set_tensor_name(const char* value);
-  void set_tensor_name(const char* value, size_t size);
-  std::string* mutable_tensor_name();
-  std::string* release_tensor_name();
-  void set_allocated_tensor_name(std::string* tensor_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_tensor_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_tensor_name(
-      std::string* tensor_name);
-  private:
-  const std::string& _internal_tensor_name() const;
-  void _internal_set_tensor_name(const std::string& value);
-  std::string* _internal_mutable_tensor_name();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class GraphProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
- public:
-  inline GraphProto() : GraphProto(nullptr) {};
-  virtual ~GraphProto();
-
-  GraphProto(const GraphProto& from);
-  GraphProto(GraphProto&& from) noexcept
-    : GraphProto() {
-    *this = ::std::move(from);
-  }
-
-  inline GraphProto& operator=(const GraphProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline GraphProto& operator=(GraphProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const GraphProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const GraphProto* internal_default_instance() {
-    return reinterpret_cast<const GraphProto*>(
-               &_GraphProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    13;
-
-  friend void swap(GraphProto& a, GraphProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(GraphProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(GraphProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline GraphProto* New() const final {
-    return CreateMaybeMessage<GraphProto>(nullptr);
-  }
-
-  GraphProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<GraphProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const GraphProto& from);
-  void MergeFrom(const GraphProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(GraphProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.GraphProto";
-  }
-  protected:
-  explicit GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNodeFieldNumber = 1,
-    kInitializerFieldNumber = 5,
-    kInputFieldNumber = 11,
-    kOutputFieldNumber = 12,
-    kValueInfoFieldNumber = 13,
-    kQuantizationAnnotationFieldNumber = 14,
-    kSparseInitializerFieldNumber = 15,
-    kMetadataPropsFieldNumber = 16,
-    kNameFieldNumber = 2,
-    kDocStringFieldNumber = 10,
-  };
-  // repeated .onnx.NodeProto node = 1;
-  int node_size() const;
-  private:
-  int _internal_node_size() const;
-  public:
-  void clear_node();
-  ::onnx::NodeProto* mutable_node(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-      mutable_node();
-  private:
-  const ::onnx::NodeProto& _internal_node(int index) const;
-  ::onnx::NodeProto* _internal_add_node();
-  public:
-  const ::onnx::NodeProto& node(int index) const;
-  ::onnx::NodeProto* add_node();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-      node() const;
-
-  // repeated .onnx.TensorProto initializer = 5;
-  int initializer_size() const;
-  private:
-  int _internal_initializer_size() const;
-  public:
-  void clear_initializer();
-  ::onnx::TensorProto* mutable_initializer(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-      mutable_initializer();
-  private:
-  const ::onnx::TensorProto& _internal_initializer(int index) const;
-  ::onnx::TensorProto* _internal_add_initializer();
-  public:
-  const ::onnx::TensorProto& initializer(int index) const;
-  ::onnx::TensorProto* add_initializer();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-      initializer() const;
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  ::onnx::ValueInfoProto* mutable_input(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_input();
-  private:
-  const ::onnx::ValueInfoProto& _internal_input(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_input();
-  public:
-  const ::onnx::ValueInfoProto& input(int index) const;
-  ::onnx::ValueInfoProto* add_input();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      input() const;
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  ::onnx::ValueInfoProto* mutable_output(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_output();
-  private:
-  const ::onnx::ValueInfoProto& _internal_output(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_output();
-  public:
-  const ::onnx::ValueInfoProto& output(int index) const;
-  ::onnx::ValueInfoProto* add_output();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      output() const;
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  int value_info_size() const;
-  private:
-  int _internal_value_info_size() const;
-  public:
-  void clear_value_info();
-  ::onnx::ValueInfoProto* mutable_value_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_value_info();
-  private:
-  const ::onnx::ValueInfoProto& _internal_value_info(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_value_info();
-  public:
-  const ::onnx::ValueInfoProto& value_info(int index) const;
-  ::onnx::ValueInfoProto* add_value_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      value_info() const;
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  int quantization_annotation_size() const;
-  private:
-  int _internal_quantization_annotation_size() const;
-  public:
-  void clear_quantization_annotation();
-  ::onnx::TensorAnnotation* mutable_quantization_annotation(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >*
-      mutable_quantization_annotation();
-  private:
-  const ::onnx::TensorAnnotation& _internal_quantization_annotation(int index) const;
-  ::onnx::TensorAnnotation* _internal_add_quantization_annotation();
-  public:
-  const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
-  ::onnx::TensorAnnotation* add_quantization_annotation();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >&
-      quantization_annotation() const;
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  int sparse_initializer_size() const;
-  private:
-  int _internal_sparse_initializer_size() const;
-  public:
-  void clear_sparse_initializer();
-  ::onnx::SparseTensorProto* mutable_sparse_initializer(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-      mutable_sparse_initializer();
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_initializer(int index) const;
-  ::onnx::SparseTensorProto* _internal_add_sparse_initializer();
-  public:
-  const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
-  ::onnx::SparseTensorProto* add_sparse_initializer();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-      sparse_initializer() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // optional string name = 2;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string doc_string = 10;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.GraphProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto > node_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto > initializer_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TensorProto_Segment PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
- public:
-  inline TensorProto_Segment() : TensorProto_Segment(nullptr) {};
-  virtual ~TensorProto_Segment();
-
-  TensorProto_Segment(const TensorProto_Segment& from);
-  TensorProto_Segment(TensorProto_Segment&& from) noexcept
-    : TensorProto_Segment() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TensorProto_Segment& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorProto_Segment* internal_default_instance() {
-    return reinterpret_cast<const TensorProto_Segment*>(
-               &_TensorProto_Segment_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    14;
-
-  friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorProto_Segment* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorProto_Segment* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorProto_Segment* New() const final {
-    return CreateMaybeMessage<TensorProto_Segment>(nullptr);
-  }
-
-  TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorProto_Segment>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorProto_Segment& from);
-  void MergeFrom(const TensorProto_Segment& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorProto_Segment* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorProto.Segment";
-  }
-  protected:
-  explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kBeginFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-  // optional int64 begin = 1;
-  bool has_begin() const;
-  private:
-  bool _internal_has_begin() const;
-  public:
-  void clear_begin();
-  ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
-  void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_begin() const;
-  void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // optional int64 end = 2;
-  bool has_end() const;
-  private:
-  bool _internal_has_end() const;
-  public:
-  void clear_end();
-  ::PROTOBUF_NAMESPACE_ID::int64 end() const;
-  void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end() const;
-  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::int64 begin_;
-  ::PROTOBUF_NAMESPACE_ID::int64 end_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TensorProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
- public:
-  inline TensorProto() : TensorProto(nullptr) {};
-  virtual ~TensorProto();
-
-  TensorProto(const TensorProto& from);
-  TensorProto(TensorProto&& from) noexcept
-    : TensorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorProto& operator=(const TensorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorProto& operator=(TensorProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TensorProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorProto* internal_default_instance() {
-    return reinterpret_cast<const TensorProto*>(
-               &_TensorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    15;
-
-  friend void swap(TensorProto& a, TensorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorProto* New() const final {
-    return CreateMaybeMessage<TensorProto>(nullptr);
-  }
-
-  TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorProto& from);
-  void MergeFrom(const TensorProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorProto";
-  }
-  protected:
-  explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TensorProto_Segment Segment;
-
-  typedef TensorProto_DataType DataType;
-  static constexpr DataType UNDEFINED =
-    TensorProto_DataType_UNDEFINED;
-  static constexpr DataType FLOAT =
-    TensorProto_DataType_FLOAT;
-  static constexpr DataType UINT8 =
-    TensorProto_DataType_UINT8;
-  static constexpr DataType INT8 =
-    TensorProto_DataType_INT8;
-  static constexpr DataType UINT16 =
-    TensorProto_DataType_UINT16;
-  static constexpr DataType INT16 =
-    TensorProto_DataType_INT16;
-  static constexpr DataType INT32 =
-    TensorProto_DataType_INT32;
-  static constexpr DataType INT64 =
-    TensorProto_DataType_INT64;
-  static constexpr DataType STRING =
-    TensorProto_DataType_STRING;
-  static constexpr DataType BOOL =
-    TensorProto_DataType_BOOL;
-  static constexpr DataType FLOAT16 =
-    TensorProto_DataType_FLOAT16;
-  static constexpr DataType DOUBLE =
-    TensorProto_DataType_DOUBLE;
-  static constexpr DataType UINT32 =
-    TensorProto_DataType_UINT32;
-  static constexpr DataType UINT64 =
-    TensorProto_DataType_UINT64;
-  static constexpr DataType COMPLEX64 =
-    TensorProto_DataType_COMPLEX64;
-  static constexpr DataType COMPLEX128 =
-    TensorProto_DataType_COMPLEX128;
-  static constexpr DataType BFLOAT16 =
-    TensorProto_DataType_BFLOAT16;
-  static constexpr DataType FLOAT8E4M3FN =
-    TensorProto_DataType_FLOAT8E4M3FN;
-  static constexpr DataType FLOAT8E4M3FNUZ =
-    TensorProto_DataType_FLOAT8E4M3FNUZ;
-  static constexpr DataType FLOAT8E5M2 =
-    TensorProto_DataType_FLOAT8E5M2;
-  static constexpr DataType FLOAT8E5M2FNUZ =
-    TensorProto_DataType_FLOAT8E5M2FNUZ;
-  static constexpr DataType UINT4 =
-    TensorProto_DataType_UINT4;
-  static constexpr DataType INT4 =
-    TensorProto_DataType_INT4;
-  static constexpr DataType FLOAT4E2M1 =
-    TensorProto_DataType_FLOAT4E2M1;
-  static constexpr DataType FLOAT8E8M0 =
-    TensorProto_DataType_FLOAT8E8M0;
-  static inline bool DataType_IsValid(int value) {
-    return TensorProto_DataType_IsValid(value);
-  }
-  static constexpr DataType DataType_MIN =
-    TensorProto_DataType_DataType_MIN;
-  static constexpr DataType DataType_MAX =
-    TensorProto_DataType_DataType_MAX;
-  static constexpr int DataType_ARRAYSIZE =
-    TensorProto_DataType_DataType_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& DataType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, DataType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function DataType_Name.");
-    return TensorProto_DataType_Name(enum_t_value);
-  }
-  static inline bool DataType_Parse(const std::string& name,
-      DataType* value) {
-    return TensorProto_DataType_Parse(name, value);
-  }
-
-  typedef TensorProto_DataLocation DataLocation;
-  static constexpr DataLocation DEFAULT =
-    TensorProto_DataLocation_DEFAULT;
-  static constexpr DataLocation EXTERNAL =
-    TensorProto_DataLocation_EXTERNAL;
-  static inline bool DataLocation_IsValid(int value) {
-    return TensorProto_DataLocation_IsValid(value);
-  }
-  static constexpr DataLocation DataLocation_MIN =
-    TensorProto_DataLocation_DataLocation_MIN;
-  static constexpr DataLocation DataLocation_MAX =
-    TensorProto_DataLocation_DataLocation_MAX;
-  static constexpr int DataLocation_ARRAYSIZE =
-    TensorProto_DataLocation_DataLocation_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& DataLocation_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, DataLocation>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function DataLocation_Name.");
-    return TensorProto_DataLocation_Name(enum_t_value);
-  }
-  static inline bool DataLocation_Parse(const std::string& name,
-      DataLocation* value) {
-    return TensorProto_DataLocation_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimsFieldNumber = 1,
-    kFloatDataFieldNumber = 4,
-    kInt32DataFieldNumber = 5,
-    kStringDataFieldNumber = 6,
-    kInt64DataFieldNumber = 7,
-    kDoubleDataFieldNumber = 10,
-    kUint64DataFieldNumber = 11,
-    kExternalDataFieldNumber = 13,
-    kMetadataPropsFieldNumber = 16,
-    kNameFieldNumber = 8,
-    kRawDataFieldNumber = 9,
-    kDocStringFieldNumber = 12,
-    kSegmentFieldNumber = 3,
-    kDataTypeFieldNumber = 2,
-    kDataLocationFieldNumber = 14,
-  };
-  // repeated int64 dims = 1;
-  int dims_size() const;
-  private:
-  int _internal_dims_size() const;
-  public:
-  void clear_dims();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_dims() const;
-  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_dims();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
-  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      dims() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_dims();
-
-  // repeated float float_data = 4 [packed = true];
-  int float_data_size() const;
-  private:
-  int _internal_float_data_size() const;
-  public:
-  void clear_float_data();
-  private:
-  float _internal_float_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      _internal_float_data() const;
-  void _internal_add_float_data(float value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      _internal_mutable_float_data();
-  public:
-  float float_data(int index) const;
-  void set_float_data(int index, float value);
-  void add_float_data(float value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      float_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      mutable_float_data();
-
-  // repeated int32 int32_data = 5 [packed = true];
-  int int32_data_size() const;
-  private:
-  int _internal_int32_data_size() const;
-  public:
-  void clear_int32_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-      _internal_int32_data() const;
-  void _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-      _internal_mutable_int32_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int32 int32_data(int index) const;
-  void set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
-  void add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-      int32_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-      mutable_int32_data();
-
-  // repeated bytes string_data = 6;
-  int string_data_size() const;
-  private:
-  int _internal_string_data_size() const;
-  public:
-  void clear_string_data();
-  const std::string& string_data(int index) const;
-  std::string* mutable_string_data(int index);
-  void set_string_data(int index, const std::string& value);
-  void set_string_data(int index, std::string&& value);
-  void set_string_data(int index, const char* value);
-  void set_string_data(int index, const void* value, size_t size);
-  std::string* add_string_data();
-  void add_string_data(const std::string& value);
-  void add_string_data(std::string&& value);
-  void add_string_data(const char* value);
-  void add_string_data(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
-  private:
-  const std::string& _internal_string_data(int index) const;
-  std::string* _internal_add_string_data();
-  public:
-
-  // repeated int64 int64_data = 7 [packed = true];
-  int int64_data_size() const;
-  private:
-  int _internal_int64_data_size() const;
-  public:
-  void clear_int64_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_int64_data() const;
-  void _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_int64_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 int64_data(int index) const;
-  void set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      int64_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_int64_data();
-
-  // repeated double double_data = 10 [packed = true];
-  int double_data_size() const;
-  private:
-  int _internal_double_data_size() const;
-  public:
-  void clear_double_data();
-  private:
-  double _internal_double_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-      _internal_double_data() const;
-  void _internal_add_double_data(double value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-      _internal_mutable_double_data();
-  public:
-  double double_data(int index) const;
-  void set_double_data(int index, double value);
-  void add_double_data(double value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-      double_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-      mutable_double_data();
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  int uint64_data_size() const;
-  private:
-  int _internal_uint64_data_size() const;
-  public:
-  void clear_uint64_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_uint64_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-      _internal_uint64_data() const;
-  void _internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-      _internal_mutable_uint64_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::uint64 uint64_data(int index) const;
-  void set_uint64_data(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
-  void add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-      uint64_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-      mutable_uint64_data();
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  int external_data_size() const;
-  private:
-  int _internal_external_data_size() const;
-  public:
-  void clear_external_data();
-  ::onnx::StringStringEntryProto* mutable_external_data(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_external_data();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_external_data(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_external_data();
-  public:
-  const ::onnx::StringStringEntryProto& external_data(int index) const;
-  ::onnx::StringStringEntryProto* add_external_data();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      external_data() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // optional string name = 8;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional bytes raw_data = 9;
-  bool has_raw_data() const;
-  private:
-  bool _internal_has_raw_data() const;
-  public:
-  void clear_raw_data();
-  const std::string& raw_data() const;
-  void set_raw_data(const std::string& value);
-  void set_raw_data(std::string&& value);
-  void set_raw_data(const char* value);
-  void set_raw_data(const void* value, size_t size);
-  std::string* mutable_raw_data();
-  std::string* release_raw_data();
-  void set_allocated_raw_data(std::string* raw_data);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_raw_data();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_raw_data(
-      std::string* raw_data);
-  private:
-  const std::string& _internal_raw_data() const;
-  void _internal_set_raw_data(const std::string& value);
-  std::string* _internal_mutable_raw_data();
-  public:
-
-  // optional string doc_string = 12;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional .onnx.TensorProto.Segment segment = 3;
-  bool has_segment() const;
-  private:
-  bool _internal_has_segment() const;
-  public:
-  void clear_segment();
-  const ::onnx::TensorProto_Segment& segment() const;
-  ::onnx::TensorProto_Segment* release_segment();
-  ::onnx::TensorProto_Segment* mutable_segment();
-  void set_allocated_segment(::onnx::TensorProto_Segment* segment);
-  private:
-  const ::onnx::TensorProto_Segment& _internal_segment() const;
-  ::onnx::TensorProto_Segment* _internal_mutable_segment();
-  public:
-  void unsafe_arena_set_allocated_segment(
-      ::onnx::TensorProto_Segment* segment);
-  ::onnx::TensorProto_Segment* unsafe_arena_release_segment();
-
-  // optional int32 data_type = 2;
-  bool has_data_type() const;
-  private:
-  bool _internal_has_data_type() const;
-  public:
-  void clear_data_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 data_type() const;
-  void set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_data_type() const;
-  void _internal_set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // optional .onnx.TensorProto.DataLocation data_location = 14;
-  bool has_data_location() const;
-  private:
-  bool _internal_has_data_location() const;
-  public:
-  void clear_data_location();
-  ::onnx::TensorProto_DataLocation data_location() const;
-  void set_data_location(::onnx::TensorProto_DataLocation value);
-  private:
-  ::onnx::TensorProto_DataLocation _internal_data_location() const;
-  void _internal_set_data_location(::onnx::TensorProto_DataLocation value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
-  mutable std::atomic<int> _float_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_data_;
-  mutable std::atomic<int> _int32_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_data_;
-  mutable std::atomic<int> _int64_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
-  mutable std::atomic<int> _double_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > uint64_data_;
-  mutable std::atomic<int> _uint64_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::TensorProto_Segment* segment_;
-  ::PROTOBUF_NAMESPACE_ID::int32 data_type_;
-  int data_location_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class SparseTensorProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
- public:
-  inline SparseTensorProto() : SparseTensorProto(nullptr) {};
-  virtual ~SparseTensorProto();
-
-  SparseTensorProto(const SparseTensorProto& from);
-  SparseTensorProto(SparseTensorProto&& from) noexcept
-    : SparseTensorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline SparseTensorProto& operator=(const SparseTensorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SparseTensorProto& operator=(SparseTensorProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const SparseTensorProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const SparseTensorProto* internal_default_instance() {
-    return reinterpret_cast<const SparseTensorProto*>(
-               &_SparseTensorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    16;
-
-  friend void swap(SparseTensorProto& a, SparseTensorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SparseTensorProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SparseTensorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline SparseTensorProto* New() const final {
-    return CreateMaybeMessage<SparseTensorProto>(nullptr);
-  }
-
-  SparseTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<SparseTensorProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const SparseTensorProto& from);
-  void MergeFrom(const SparseTensorProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(SparseTensorProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.SparseTensorProto";
-  }
-  protected:
-  explicit SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimsFieldNumber = 3,
-    kValuesFieldNumber = 1,
-    kIndicesFieldNumber = 2,
-  };
-  // repeated int64 dims = 3;
-  int dims_size() const;
-  private:
-  int _internal_dims_size() const;
-  public:
-  void clear_dims();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_dims() const;
-  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_dims();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
-  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      dims() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_dims();
-
-  // optional .onnx.TensorProto values = 1;
-  bool has_values() const;
-  private:
-  bool _internal_has_values() const;
-  public:
-  void clear_values();
-  const ::onnx::TensorProto& values() const;
-  ::onnx::TensorProto* release_values();
-  ::onnx::TensorProto* mutable_values();
-  void set_allocated_values(::onnx::TensorProto* values);
-  private:
-  const ::onnx::TensorProto& _internal_values() const;
-  ::onnx::TensorProto* _internal_mutable_values();
-  public:
-  void unsafe_arena_set_allocated_values(
-      ::onnx::TensorProto* values);
-  ::onnx::TensorProto* unsafe_arena_release_values();
-
-  // optional .onnx.TensorProto indices = 2;
-  bool has_indices() const;
-  private:
-  bool _internal_has_indices() const;
-  public:
-  void clear_indices();
-  const ::onnx::TensorProto& indices() const;
-  ::onnx::TensorProto* release_indices();
-  ::onnx::TensorProto* mutable_indices();
-  void set_allocated_indices(::onnx::TensorProto* indices);
-  private:
-  const ::onnx::TensorProto& _internal_indices() const;
-  ::onnx::TensorProto* _internal_mutable_indices();
-  public:
-  void unsafe_arena_set_allocated_indices(
-      ::onnx::TensorProto* indices);
-  ::onnx::TensorProto* unsafe_arena_release_indices();
-
-  // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
-  ::onnx::TensorProto* values_;
-  ::onnx::TensorProto* indices_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TensorShapeProto_Dimension PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
- public:
-  inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {};
-  virtual ~TensorShapeProto_Dimension();
-
-  TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
-  TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
-    : TensorShapeProto_Dimension() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TensorShapeProto_Dimension& default_instance();
-
-  enum ValueCase {
-    kDimValue = 1,
-    kDimParam = 2,
-    VALUE_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorShapeProto_Dimension* internal_default_instance() {
-    return reinterpret_cast<const TensorShapeProto_Dimension*>(
-               &_TensorShapeProto_Dimension_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    17;
-
-  friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorShapeProto_Dimension* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorShapeProto_Dimension* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorShapeProto_Dimension* New() const final {
-    return CreateMaybeMessage<TensorShapeProto_Dimension>(nullptr);
-  }
-
-  TensorShapeProto_Dimension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorShapeProto_Dimension>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorShapeProto_Dimension& from);
-  void MergeFrom(const TensorShapeProto_Dimension& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorShapeProto_Dimension* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorShapeProto.Dimension";
-  }
-  protected:
-  explicit TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDenotationFieldNumber = 3,
-    kDimValueFieldNumber = 1,
-    kDimParamFieldNumber = 2,
-  };
-  // optional string denotation = 3;
-  bool has_denotation() const;
-  private:
-  bool _internal_has_denotation() const;
-  public:
-  void clear_denotation();
-  const std::string& denotation() const;
-  void set_denotation(const std::string& value);
-  void set_denotation(std::string&& value);
-  void set_denotation(const char* value);
-  void set_denotation(const char* value, size_t size);
-  std::string* mutable_denotation();
-  std::string* release_denotation();
-  void set_allocated_denotation(std::string* denotation);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_denotation();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_denotation(
-      std::string* denotation);
-  private:
-  const std::string& _internal_denotation() const;
-  void _internal_set_denotation(const std::string& value);
-  std::string* _internal_mutable_denotation();
-  public:
-
-  // int64 dim_value = 1;
-  bool has_dim_value() const;
-  private:
-  bool _internal_has_dim_value() const;
-  public:
-  void clear_dim_value();
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value() const;
-  void set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dim_value() const;
-  void _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // string dim_param = 2;
-  bool has_dim_param() const;
-  private:
-  bool _internal_has_dim_param() const;
-  public:
-  void clear_dim_param();
-  const std::string& dim_param() const;
-  void set_dim_param(const std::string& value);
-  void set_dim_param(std::string&& value);
-  void set_dim_param(const char* value);
-  void set_dim_param(const char* value, size_t size);
-  std::string* mutable_dim_param();
-  std::string* release_dim_param();
-  void set_allocated_dim_param(std::string* dim_param);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_dim_param();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_dim_param(
-      std::string* dim_param);
-  private:
-  const std::string& _internal_dim_param() const;
-  void _internal_set_dim_param(const std::string& value);
-  std::string* _internal_mutable_dim_param();
-  public:
-
-  void clear_value();
-  ValueCase value_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
- private:
-  class _Internal;
-  void set_has_dim_value();
-  void set_has_dim_param();
-
-  inline bool has_value() const;
-  inline void clear_has_value();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
-  union ValueUnion {
-    ValueUnion() {}
-    ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-  } value_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TensorShapeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
- public:
-  inline TensorShapeProto() : TensorShapeProto(nullptr) {};
-  virtual ~TensorShapeProto();
-
-  TensorShapeProto(const TensorShapeProto& from);
-  TensorShapeProto(TensorShapeProto&& from) noexcept
-    : TensorShapeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorShapeProto& operator=(const TensorShapeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TensorShapeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorShapeProto* internal_default_instance() {
-    return reinterpret_cast<const TensorShapeProto*>(
-               &_TensorShapeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    18;
-
-  friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorShapeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorShapeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorShapeProto* New() const final {
-    return CreateMaybeMessage<TensorShapeProto>(nullptr);
-  }
-
-  TensorShapeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorShapeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorShapeProto& from);
-  void MergeFrom(const TensorShapeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorShapeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorShapeProto";
-  }
-  protected:
-  explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TensorShapeProto_Dimension Dimension;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimFieldNumber = 1,
-  };
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  int dim_size() const;
-  private:
-  int _internal_dim_size() const;
-  public:
-  void clear_dim();
-  ::onnx::TensorShapeProto_Dimension* mutable_dim(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >*
-      mutable_dim();
-  private:
-  const ::onnx::TensorShapeProto_Dimension& _internal_dim(int index) const;
-  ::onnx::TensorShapeProto_Dimension* _internal_add_dim();
-  public:
-  const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
-  ::onnx::TensorShapeProto_Dimension* add_dim();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >&
-      dim() const;
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Tensor PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
- public:
-  inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {};
-  virtual ~TypeProto_Tensor();
-
-  TypeProto_Tensor(const TypeProto_Tensor& from);
-  TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
-    : TypeProto_Tensor() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto_Tensor& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Tensor* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Tensor*>(
-               &_TypeProto_Tensor_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    19;
-
-  friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Tensor* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Tensor* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Tensor* New() const final {
-    return CreateMaybeMessage<TypeProto_Tensor>(nullptr);
-  }
-
-  TypeProto_Tensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Tensor>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Tensor& from);
-  void MergeFrom(const TypeProto_Tensor& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Tensor* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Tensor";
-  }
-  protected:
-  explicit TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShapeFieldNumber = 2,
-    kElemTypeFieldNumber = 1,
-  };
-  // optional .onnx.TensorShapeProto shape = 2;
-  bool has_shape() const;
-  private:
-  bool _internal_has_shape() const;
-  public:
-  void clear_shape();
-  const ::onnx::TensorShapeProto& shape() const;
-  ::onnx::TensorShapeProto* release_shape();
-  ::onnx::TensorShapeProto* mutable_shape();
-  void set_allocated_shape(::onnx::TensorShapeProto* shape);
-  private:
-  const ::onnx::TensorShapeProto& _internal_shape() const;
-  ::onnx::TensorShapeProto* _internal_mutable_shape();
-  public:
-  void unsafe_arena_set_allocated_shape(
-      ::onnx::TensorShapeProto* shape);
-  ::onnx::TensorShapeProto* unsafe_arena_release_shape();
-
-  // optional int32 elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
-  void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
-  void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::onnx::TensorShapeProto* shape_;
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Sequence PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
- public:
-  inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {};
-  virtual ~TypeProto_Sequence();
-
-  TypeProto_Sequence(const TypeProto_Sequence& from);
-  TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
-    : TypeProto_Sequence() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto_Sequence& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Sequence* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Sequence*>(
-               &_TypeProto_Sequence_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    20;
-
-  friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Sequence* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Sequence* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Sequence* New() const final {
-    return CreateMaybeMessage<TypeProto_Sequence>(nullptr);
-  }
-
-  TypeProto_Sequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Sequence>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Sequence& from);
-  void MergeFrom(const TypeProto_Sequence& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Sequence* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Sequence";
-  }
-  protected:
-  explicit TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kElemTypeFieldNumber = 1,
-  };
-  // optional .onnx.TypeProto elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  const ::onnx::TypeProto& elem_type() const;
-  ::onnx::TypeProto* release_elem_type();
-  ::onnx::TypeProto* mutable_elem_type();
-  void set_allocated_elem_type(::onnx::TypeProto* elem_type);
-  private:
-  const ::onnx::TypeProto& _internal_elem_type() const;
-  ::onnx::TypeProto* _internal_mutable_elem_type();
-  public:
-  void unsafe_arena_set_allocated_elem_type(
-      ::onnx::TypeProto* elem_type);
-  ::onnx::TypeProto* unsafe_arena_release_elem_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::onnx::TypeProto* elem_type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Map PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
- public:
-  inline TypeProto_Map() : TypeProto_Map(nullptr) {};
-  virtual ~TypeProto_Map();
-
-  TypeProto_Map(const TypeProto_Map& from);
-  TypeProto_Map(TypeProto_Map&& from) noexcept
-    : TypeProto_Map() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Map& operator=(const TypeProto_Map& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto_Map& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Map* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Map*>(
-               &_TypeProto_Map_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    21;
-
-  friend void swap(TypeProto_Map& a, TypeProto_Map& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Map* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Map* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Map* New() const final {
-    return CreateMaybeMessage<TypeProto_Map>(nullptr);
-  }
-
-  TypeProto_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Map>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Map& from);
-  void MergeFrom(const TypeProto_Map& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Map* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Map";
-  }
-  protected:
-  explicit TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueTypeFieldNumber = 2,
-    kKeyTypeFieldNumber = 1,
-  };
-  // optional .onnx.TypeProto value_type = 2;
-  bool has_value_type() const;
-  private:
-  bool _internal_has_value_type() const;
-  public:
-  void clear_value_type();
-  const ::onnx::TypeProto& value_type() const;
-  ::onnx::TypeProto* release_value_type();
-  ::onnx::TypeProto* mutable_value_type();
-  void set_allocated_value_type(::onnx::TypeProto* value_type);
-  private:
-  const ::onnx::TypeProto& _internal_value_type() const;
-  ::onnx::TypeProto* _internal_mutable_value_type();
-  public:
-  void unsafe_arena_set_allocated_value_type(
-      ::onnx::TypeProto* value_type);
-  ::onnx::TypeProto* unsafe_arena_release_value_type();
-
-  // optional int32 key_type = 1;
-  bool has_key_type() const;
-  private:
-  bool _internal_has_key_type() const;
-  public:
-  void clear_key_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 key_type() const;
-  void set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_key_type() const;
-  void _internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::onnx::TypeProto* value_type_;
-  ::PROTOBUF_NAMESPACE_ID::int32 key_type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Optional PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
- public:
-  inline TypeProto_Optional() : TypeProto_Optional(nullptr) {};
-  virtual ~TypeProto_Optional();
-
-  TypeProto_Optional(const TypeProto_Optional& from);
-  TypeProto_Optional(TypeProto_Optional&& from) noexcept
-    : TypeProto_Optional() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Optional& operator=(TypeProto_Optional&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto_Optional& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Optional* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Optional*>(
-               &_TypeProto_Optional_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    22;
-
-  friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Optional* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Optional* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Optional* New() const final {
-    return CreateMaybeMessage<TypeProto_Optional>(nullptr);
-  }
-
-  TypeProto_Optional* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Optional>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Optional& from);
-  void MergeFrom(const TypeProto_Optional& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Optional* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Optional";
-  }
-  protected:
-  explicit TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kElemTypeFieldNumber = 1,
-  };
-  // optional .onnx.TypeProto elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  const ::onnx::TypeProto& elem_type() const;
-  ::onnx::TypeProto* release_elem_type();
-  ::onnx::TypeProto* mutable_elem_type();
-  void set_allocated_elem_type(::onnx::TypeProto* elem_type);
-  private:
-  const ::onnx::TypeProto& _internal_elem_type() const;
-  ::onnx::TypeProto* _internal_mutable_elem_type();
-  public:
-  void unsafe_arena_set_allocated_elem_type(
-      ::onnx::TypeProto* elem_type);
-  ::onnx::TypeProto* unsafe_arena_release_elem_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::onnx::TypeProto* elem_type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_SparseTensor PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
- public:
-  inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {};
-  virtual ~TypeProto_SparseTensor();
-
-  TypeProto_SparseTensor(const TypeProto_SparseTensor& from);
-  TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
-    : TypeProto_SparseTensor() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto_SparseTensor& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_SparseTensor* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_SparseTensor*>(
-               &_TypeProto_SparseTensor_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    23;
-
-  friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_SparseTensor* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_SparseTensor* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_SparseTensor* New() const final {
-    return CreateMaybeMessage<TypeProto_SparseTensor>(nullptr);
-  }
-
-  TypeProto_SparseTensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_SparseTensor>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_SparseTensor& from);
-  void MergeFrom(const TypeProto_SparseTensor& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_SparseTensor* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.SparseTensor";
-  }
-  protected:
-  explicit TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShapeFieldNumber = 2,
-    kElemTypeFieldNumber = 1,
-  };
-  // optional .onnx.TensorShapeProto shape = 2;
-  bool has_shape() const;
-  private:
-  bool _internal_has_shape() const;
-  public:
-  void clear_shape();
-  const ::onnx::TensorShapeProto& shape() const;
-  ::onnx::TensorShapeProto* release_shape();
-  ::onnx::TensorShapeProto* mutable_shape();
-  void set_allocated_shape(::onnx::TensorShapeProto* shape);
-  private:
-  const ::onnx::TensorShapeProto& _internal_shape() const;
-  ::onnx::TensorShapeProto* _internal_mutable_shape();
-  public:
-  void unsafe_arena_set_allocated_shape(
-      ::onnx::TensorShapeProto* shape);
-  ::onnx::TensorShapeProto* unsafe_arena_release_shape();
-
-  // optional int32 elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
-  void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
-  void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::onnx::TensorShapeProto* shape_;
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TypeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
- public:
-  inline TypeProto() : TypeProto(nullptr) {};
-  virtual ~TypeProto();
-
-  TypeProto(const TypeProto& from);
-  TypeProto(TypeProto&& from) noexcept
-    : TypeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto& operator=(const TypeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto& operator=(TypeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const TypeProto& default_instance();
-
-  enum ValueCase {
-    kTensorType = 1,
-    kSequenceType = 4,
-    kMapType = 5,
-    kOptionalType = 9,
-    kSparseTensorType = 8,
-    VALUE_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto* internal_default_instance() {
-    return reinterpret_cast<const TypeProto*>(
-               &_TypeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    24;
-
-  friend void swap(TypeProto& a, TypeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto* New() const final {
-    return CreateMaybeMessage<TypeProto>(nullptr);
-  }
-
-  TypeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto& from);
-  void MergeFrom(const TypeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto";
-  }
-  protected:
-  explicit TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TypeProto_Tensor Tensor;
-  typedef TypeProto_Sequence Sequence;
-  typedef TypeProto_Map Map;
-  typedef TypeProto_Optional Optional;
-  typedef TypeProto_SparseTensor SparseTensor;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDenotationFieldNumber = 6,
-    kTensorTypeFieldNumber = 1,
-    kSequenceTypeFieldNumber = 4,
-    kMapTypeFieldNumber = 5,
-    kOptionalTypeFieldNumber = 9,
-    kSparseTensorTypeFieldNumber = 8,
-  };
-  // optional string denotation = 6;
-  bool has_denotation() const;
-  private:
-  bool _internal_has_denotation() const;
-  public:
-  void clear_denotation();
-  const std::string& denotation() const;
-  void set_denotation(const std::string& value);
-  void set_denotation(std::string&& value);
-  void set_denotation(const char* value);
-  void set_denotation(const char* value, size_t size);
-  std::string* mutable_denotation();
-  std::string* release_denotation();
-  void set_allocated_denotation(std::string* denotation);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_denotation();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_denotation(
-      std::string* denotation);
-  private:
-  const std::string& _internal_denotation() const;
-  void _internal_set_denotation(const std::string& value);
-  std::string* _internal_mutable_denotation();
-  public:
-
-  // .onnx.TypeProto.Tensor tensor_type = 1;
-  bool has_tensor_type() const;
-  private:
-  bool _internal_has_tensor_type() const;
-  public:
-  void clear_tensor_type();
-  const ::onnx::TypeProto_Tensor& tensor_type() const;
-  ::onnx::TypeProto_Tensor* release_tensor_type();
-  ::onnx::TypeProto_Tensor* mutable_tensor_type();
-  void set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type);
-  private:
-  const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
-  ::onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
-  public:
-  void unsafe_arena_set_allocated_tensor_type(
-      ::onnx::TypeProto_Tensor* tensor_type);
-  ::onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
-
-  // .onnx.TypeProto.Sequence sequence_type = 4;
-  bool has_sequence_type() const;
-  private:
-  bool _internal_has_sequence_type() const;
-  public:
-  void clear_sequence_type();
-  const ::onnx::TypeProto_Sequence& sequence_type() const;
-  ::onnx::TypeProto_Sequence* release_sequence_type();
-  ::onnx::TypeProto_Sequence* mutable_sequence_type();
-  void set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type);
-  private:
-  const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
-  ::onnx::TypeProto_Sequence* _internal_mutable_sequence_type();
-  public:
-  void unsafe_arena_set_allocated_sequence_type(
-      ::onnx::TypeProto_Sequence* sequence_type);
-  ::onnx::TypeProto_Sequence* unsafe_arena_release_sequence_type();
-
-  // .onnx.TypeProto.Map map_type = 5;
-  bool has_map_type() const;
-  private:
-  bool _internal_has_map_type() const;
-  public:
-  void clear_map_type();
-  const ::onnx::TypeProto_Map& map_type() const;
-  ::onnx::TypeProto_Map* release_map_type();
-  ::onnx::TypeProto_Map* mutable_map_type();
-  void set_allocated_map_type(::onnx::TypeProto_Map* map_type);
-  private:
-  const ::onnx::TypeProto_Map& _internal_map_type() const;
-  ::onnx::TypeProto_Map* _internal_mutable_map_type();
-  public:
-  void unsafe_arena_set_allocated_map_type(
-      ::onnx::TypeProto_Map* map_type);
-  ::onnx::TypeProto_Map* unsafe_arena_release_map_type();
-
-  // .onnx.TypeProto.Optional optional_type = 9;
-  bool has_optional_type() const;
-  private:
-  bool _internal_has_optional_type() const;
-  public:
-  void clear_optional_type();
-  const ::onnx::TypeProto_Optional& optional_type() const;
-  ::onnx::TypeProto_Optional* release_optional_type();
-  ::onnx::TypeProto_Optional* mutable_optional_type();
-  void set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type);
-  private:
-  const ::onnx::TypeProto_Optional& _internal_optional_type() const;
-  ::onnx::TypeProto_Optional* _internal_mutable_optional_type();
-  public:
-  void unsafe_arena_set_allocated_optional_type(
-      ::onnx::TypeProto_Optional* optional_type);
-  ::onnx::TypeProto_Optional* unsafe_arena_release_optional_type();
-
-  // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-  bool has_sparse_tensor_type() const;
-  private:
-  bool _internal_has_sparse_tensor_type() const;
-  public:
-  void clear_sparse_tensor_type();
-  const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
-  ::onnx::TypeProto_SparseTensor* release_sparse_tensor_type();
-  ::onnx::TypeProto_SparseTensor* mutable_sparse_tensor_type();
-  void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type);
-  private:
-  const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
-  ::onnx::TypeProto_SparseTensor* _internal_mutable_sparse_tensor_type();
-  public:
-  void unsafe_arena_set_allocated_sparse_tensor_type(
-      ::onnx::TypeProto_SparseTensor* sparse_tensor_type);
-  ::onnx::TypeProto_SparseTensor* unsafe_arena_release_sparse_tensor_type();
-
-  void clear_value();
-  ValueCase value_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto)
- private:
-  class _Internal;
-  void set_has_tensor_type();
-  void set_has_sequence_type();
-  void set_has_map_type();
-  void set_has_optional_type();
-  void set_has_sparse_tensor_type();
-
-  inline bool has_value() const;
-  inline void clear_has_value();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
-  union ValueUnion {
-    ValueUnion() {}
-    ::onnx::TypeProto_Tensor* tensor_type_;
-    ::onnx::TypeProto_Sequence* sequence_type_;
-    ::onnx::TypeProto_Map* map_type_;
-    ::onnx::TypeProto_Optional* optional_type_;
-    ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
-  } value_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class OperatorSetIdProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
- public:
-  inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {};
-  virtual ~OperatorSetIdProto();
-
-  OperatorSetIdProto(const OperatorSetIdProto& from);
-  OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
-    : OperatorSetIdProto() {
-    *this = ::std::move(from);
-  }
-
-  inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const OperatorSetIdProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const OperatorSetIdProto* internal_default_instance() {
-    return reinterpret_cast<const OperatorSetIdProto*>(
-               &_OperatorSetIdProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    25;
-
-  friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(OperatorSetIdProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(OperatorSetIdProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline OperatorSetIdProto* New() const final {
-    return CreateMaybeMessage<OperatorSetIdProto>(nullptr);
-  }
-
-  OperatorSetIdProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<OperatorSetIdProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const OperatorSetIdProto& from);
-  void MergeFrom(const OperatorSetIdProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(OperatorSetIdProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.OperatorSetIdProto";
-  }
-  protected:
-  explicit OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDomainFieldNumber = 1,
-    kVersionFieldNumber = 2,
-  };
-  // optional string domain = 1;
-  bool has_domain() const;
-  private:
-  bool _internal_has_domain() const;
-  public:
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // optional int64 version = 2;
-  bool has_version() const;
-  private:
-  bool _internal_has_version() const;
-  public:
-  void clear_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 version() const;
-  void set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_version() const;
-  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::int64 version_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// -------------------------------------------------------------------
-
-class FunctionProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
- public:
-  inline FunctionProto() : FunctionProto(nullptr) {};
-  virtual ~FunctionProto();
-
-  FunctionProto(const FunctionProto& from);
-  FunctionProto(FunctionProto&& from) noexcept
-    : FunctionProto() {
-    *this = ::std::move(from);
-  }
-
-  inline FunctionProto& operator=(const FunctionProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FunctionProto& operator=(FunctionProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const std::string& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
-  }
-  inline std::string* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<std::string>();
-  }
-
-  static const FunctionProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const FunctionProto* internal_default_instance() {
-    return reinterpret_cast<const FunctionProto*>(
-               &_FunctionProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    26;
-
-  friend void swap(FunctionProto& a, FunctionProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FunctionProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FunctionProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline FunctionProto* New() const final {
-    return CreateMaybeMessage<FunctionProto>(nullptr);
-  }
-
-  FunctionProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<FunctionProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const FunctionProto& from);
-  void MergeFrom(const FunctionProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(FunctionProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.FunctionProto";
-  }
-  protected:
-  explicit FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInputFieldNumber = 4,
-    kOutputFieldNumber = 5,
-    kAttributeFieldNumber = 6,
-    kNodeFieldNumber = 7,
-    kOpsetImportFieldNumber = 9,
-    kAttributeProtoFieldNumber = 11,
-    kValueInfoFieldNumber = 12,
-    kMetadataPropsFieldNumber = 14,
-    kNameFieldNumber = 1,
-    kDocStringFieldNumber = 8,
-    kDomainFieldNumber = 10,
-    kOverloadFieldNumber = 13,
-  };
-  // repeated string input = 4;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  const std::string& input(int index) const;
-  std::string* mutable_input(int index);
-  void set_input(int index, const std::string& value);
-  void set_input(int index, std::string&& value);
-  void set_input(int index, const char* value);
-  void set_input(int index, const char* value, size_t size);
-  std::string* add_input();
-  void add_input(const std::string& value);
-  void add_input(std::string&& value);
-  void add_input(const char* value);
-  void add_input(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
-  private:
-  const std::string& _internal_input(int index) const;
-  std::string* _internal_add_input();
-  public:
-
-  // repeated string output = 5;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  const std::string& output(int index) const;
-  std::string* mutable_output(int index);
-  void set_output(int index, const std::string& value);
-  void set_output(int index, std::string&& value);
-  void set_output(int index, const char* value);
-  void set_output(int index, const char* value, size_t size);
-  std::string* add_output();
-  void add_output(const std::string& value);
-  void add_output(std::string&& value);
-  void add_output(const char* value);
-  void add_output(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
-  private:
-  const std::string& _internal_output(int index) const;
-  std::string* _internal_add_output();
-  public:
-
-  // repeated string attribute = 6;
-  int attribute_size() const;
-  private:
-  int _internal_attribute_size() const;
-  public:
-  void clear_attribute();
-  const std::string& attribute(int index) const;
-  std::string* mutable_attribute(int index);
-  void set_attribute(int index, const std::string& value);
-  void set_attribute(int index, std::string&& value);
-  void set_attribute(int index, const char* value);
-  void set_attribute(int index, const char* value, size_t size);
-  std::string* add_attribute();
-  void add_attribute(const std::string& value);
-  void add_attribute(std::string&& value);
-  void add_attribute(const char* value);
-  void add_attribute(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& attribute() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_attribute();
-  private:
-  const std::string& _internal_attribute(int index) const;
-  std::string* _internal_add_attribute();
-  public:
-
-  // repeated .onnx.NodeProto node = 7;
-  int node_size() const;
-  private:
-  int _internal_node_size() const;
-  public:
-  void clear_node();
-  ::onnx::NodeProto* mutable_node(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-      mutable_node();
-  private:
-  const ::onnx::NodeProto& _internal_node(int index) const;
-  ::onnx::NodeProto* _internal_add_node();
-  public:
-  const ::onnx::NodeProto& node(int index) const;
-  ::onnx::NodeProto* add_node();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-      node() const;
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  int opset_import_size() const;
-  private:
-  int _internal_opset_import_size() const;
-  public:
-  void clear_opset_import();
-  ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-      mutable_opset_import();
-  private:
-  const ::onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* _internal_add_opset_import();
-  public:
-  const ::onnx::OperatorSetIdProto& opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* add_opset_import();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-      opset_import() const;
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  int attribute_proto_size() const;
-  private:
-  int _internal_attribute_proto_size() const;
-  public:
-  void clear_attribute_proto();
-  ::onnx::AttributeProto* mutable_attribute_proto(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-      mutable_attribute_proto();
-  private:
-  const ::onnx::AttributeProto& _internal_attribute_proto(int index) const;
-  ::onnx::AttributeProto* _internal_add_attribute_proto();
-  public:
-  const ::onnx::AttributeProto& attribute_proto(int index) const;
-  ::onnx::AttributeProto* add_attribute_proto();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-      attribute_proto() const;
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  int value_info_size() const;
-  private:
-  int _internal_value_info_size() const;
-  public:
-  void clear_value_info();
-  ::onnx::ValueInfoProto* mutable_value_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_value_info();
-  private:
-  const ::onnx::ValueInfoProto& _internal_value_info(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_value_info();
-  public:
-  const ::onnx::ValueInfoProto& value_info(int index) const;
-  ::onnx::ValueInfoProto* add_value_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      value_info() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string doc_string = 8;
-  bool has_doc_string() const;
-  private:
-  bool _internal_has_doc_string() const;
-  public:
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // optional string domain = 10;
-  bool has_domain() const;
-  private:
-  bool _internal_has_domain() const;
-  public:
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // optional string overload = 13;
-  bool has_overload() const;
-  private:
-  bool _internal_has_overload() const;
-  public:
-  void clear_overload();
-  const std::string& overload() const;
-  void set_overload(const std::string& value);
-  void set_overload(std::string&& value);
-  void set_overload(const char* value);
-  void set_overload(const char* value, size_t size);
-  std::string* mutable_overload();
-  std::string* release_overload();
-  void set_allocated_overload(std::string* overload);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_overload();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_overload(
-      std::string* overload);
-  private:
-  const std::string& _internal_overload() const;
-  void _internal_set_overload(const std::string& value);
-  std::string* _internal_mutable_overload();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> attribute_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto > node_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
-  friend struct ::TableStruct_onnx_2eproto;
-};
-// ===================================================================
-
-
-// ===================================================================
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// AttributeProto
-
-// optional string name = 1;
-inline bool AttributeProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_name() const {
-  return _internal_has_name();
-}
-inline void AttributeProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& AttributeProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
-  return _internal_name();
-}
-inline void AttributeProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& AttributeProto::_internal_name() const {
-  return name_.Get();
-}
-inline void AttributeProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.name)
-}
-inline void AttributeProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.name)
-}
-inline void AttributeProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.name)
-}
-
-// optional string ref_attr_name = 21;
-inline bool AttributeProto::_internal_has_ref_attr_name() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_ref_attr_name() const {
-  return _internal_has_ref_attr_name();
-}
-inline void AttributeProto::clear_ref_attr_name() {
-  ref_attr_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& AttributeProto::ref_attr_name() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
-  return _internal_ref_attr_name();
-}
-inline void AttributeProto::set_ref_attr_name(const std::string& value) {
-  _internal_set_ref_attr_name(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::mutable_ref_attr_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
-  return _internal_mutable_ref_attr_name();
-}
-inline const std::string& AttributeProto::_internal_ref_attr_name() const {
-  return ref_attr_name_.Get();
-}
-inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000008u;
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_ref_attr_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000008u;
-  ref_attr_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.ref_attr_name)
-}
-inline void AttributeProto::set_ref_attr_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000008u;
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.ref_attr_name)
-}
-inline void AttributeProto::set_ref_attr_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000008u;
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
-  _has_bits_[0] |= 0x00000008u;
-  return ref_attr_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_ref_attr_name() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
-  if (!_internal_has_ref_attr_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000008u;
-  return ref_attr_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_ref_attr_name(std::string* ref_attr_name) {
-  if (ref_attr_name != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  ref_attr_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ref_attr_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::unsafe_arena_release_ref_attr_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.ref_attr_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000008u;
-  return ref_attr_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_ref_attr_name(
-    std::string* ref_attr_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (ref_attr_name != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  ref_attr_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ref_attr_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.ref_attr_name)
-}
-
-// optional string doc_string = 13;
-inline bool AttributeProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void AttributeProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& AttributeProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
-  return _internal_doc_string();
-}
-inline void AttributeProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& AttributeProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.doc_string)
-}
-inline void AttributeProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.doc_string)
-}
-inline void AttributeProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000004u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.doc_string)
-}
-
-// optional .onnx.AttributeProto.AttributeType type = 20;
-inline bool AttributeProto::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000400u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_type() const {
-  return _internal_has_type();
-}
-inline void AttributeProto::clear_type() {
-  type_ = 0;
-  _has_bits_[0] &= ~0x00000400u;
-}
-inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
-  return static_cast< ::onnx::AttributeProto_AttributeType >(type_);
-}
-inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
-  return _internal_type();
-}
-inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
-  assert(::onnx::AttributeProto_AttributeType_IsValid(value));
-  _has_bits_[0] |= 0x00000400u;
-  type_ = value;
-}
-inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
-  _internal_set_type(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
-}
-
-// optional float f = 2;
-inline bool AttributeProto::_internal_has_f() const {
-  bool value = (_has_bits_[0] & 0x00000200u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_f() const {
-  return _internal_has_f();
-}
-inline void AttributeProto::clear_f() {
-  f_ = 0;
-  _has_bits_[0] &= ~0x00000200u;
-}
-inline float AttributeProto::_internal_f() const {
-  return f_;
-}
-inline float AttributeProto::f() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
-  return _internal_f();
-}
-inline void AttributeProto::_internal_set_f(float value) {
-  _has_bits_[0] |= 0x00000200u;
-  f_ = value;
-}
-inline void AttributeProto::set_f(float value) {
-  _internal_set_f(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
-}
-
-// optional int64 i = 3;
-inline bool AttributeProto::_internal_has_i() const {
-  bool value = (_has_bits_[0] & 0x00000100u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_i() const {
-  return _internal_has_i();
-}
-inline void AttributeProto::clear_i() {
-  i_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000100u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::_internal_i() const {
-  return i_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::i() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
-  return _internal_i();
-}
-inline void AttributeProto::_internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000100u;
-  i_ = value;
-}
-inline void AttributeProto::set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_i(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
-}
-
-// optional bytes s = 4;
-inline bool AttributeProto::_internal_has_s() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool AttributeProto::has_s() const {
-  return _internal_has_s();
-}
-inline void AttributeProto::clear_s() {
-  s_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& AttributeProto::s() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
-  return _internal_s();
-}
-inline void AttributeProto::set_s(const std::string& value) {
-  _internal_set_s(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::mutable_s() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
-  return _internal_mutable_s();
-}
-inline const std::string& AttributeProto::_internal_s() const {
-  return s_.Get();
-}
-inline void AttributeProto::_internal_set_s(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_s(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  s_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.s)
-}
-inline void AttributeProto::set_s(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.s)
-}
-inline void AttributeProto::set_s(const void* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::_internal_mutable_s() {
-  _has_bits_[0] |= 0x00000002u;
-  return s_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_s() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
-  if (!_internal_has_s()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return s_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_s(std::string* s) {
-  if (s != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  s_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), s,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::unsafe_arena_release_s() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.s)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return s_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_s(
-    std::string* s) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (s != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  s_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      s, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.s)
-}
-
-// optional .onnx.TensorProto t = 5;
-inline bool AttributeProto::_internal_has_t() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
-  PROTOBUF_ASSUME(!value || t_ != nullptr);
-  return value;
-}
-inline bool AttributeProto::has_t() const {
-  return _internal_has_t();
-}
-inline void AttributeProto::clear_t() {
-  if (t_ != nullptr) t_->Clear();
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
-  const ::onnx::TensorProto* p = t_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& AttributeProto::t() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
-  return _internal_t();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_t(
-    ::onnx::TensorProto* t) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
-  }
-  t_ = t;
-  if (t) {
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
-}
-inline ::onnx::TensorProto* AttributeProto::release_t() {
-  auto temp = unsafe_arena_release_t();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)
-  _has_bits_[0] &= ~0x00000010u;
-  ::onnx::TensorProto* temp = t_;
-  t_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* AttributeProto::_internal_mutable_t() {
-  _has_bits_[0] |= 0x00000010u;
-  if (t_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    t_ = p;
-  }
-  return t_;
-}
-inline ::onnx::TensorProto* AttributeProto::mutable_t() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
-  return _internal_mutable_t();
-}
-inline void AttributeProto::set_allocated_t(::onnx::TensorProto* t) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete t_;
-  }
-  if (t) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(t);
-    if (message_arena != submessage_arena) {
-      t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, t, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  t_ = t;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
-}
-
-// optional .onnx.GraphProto g = 6;
-inline bool AttributeProto::_internal_has_g() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
-  PROTOBUF_ASSUME(!value || g_ != nullptr);
-  return value;
-}
-inline bool AttributeProto::has_g() const {
-  return _internal_has_g();
-}
-inline void AttributeProto::clear_g() {
-  if (g_ != nullptr) g_->Clear();
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
-  const ::onnx::GraphProto* p = g_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& AttributeProto::g() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
-  return _internal_g();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_g(
-    ::onnx::GraphProto* g) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(g_);
-  }
-  g_ = g;
-  if (g) {
-    _has_bits_[0] |= 0x00000020u;
-  } else {
-    _has_bits_[0] &= ~0x00000020u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
-}
-inline ::onnx::GraphProto* AttributeProto::release_g() {
-  auto temp = unsafe_arena_release_g();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)
-  _has_bits_[0] &= ~0x00000020u;
-  ::onnx::GraphProto* temp = g_;
-  g_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* AttributeProto::_internal_mutable_g() {
-  _has_bits_[0] |= 0x00000020u;
-  if (g_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    g_ = p;
-  }
-  return g_;
-}
-inline ::onnx::GraphProto* AttributeProto::mutable_g() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
-  return _internal_mutable_g();
-}
-inline void AttributeProto::set_allocated_g(::onnx::GraphProto* g) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete g_;
-  }
-  if (g) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(g);
-    if (message_arena != submessage_arena) {
-      g = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, g, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000020u;
-  } else {
-    _has_bits_[0] &= ~0x00000020u;
-  }
-  g_ = g;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
-}
-
-// optional .onnx.SparseTensorProto sparse_tensor = 22;
-inline bool AttributeProto::_internal_has_sparse_tensor() const {
-  bool value = (_has_bits_[0] & 0x00000080u) != 0;
-  PROTOBUF_ASSUME(!value || sparse_tensor_ != nullptr);
-  return value;
-}
-inline bool AttributeProto::has_sparse_tensor() const {
-  return _internal_has_sparse_tensor();
-}
-inline void AttributeProto::clear_sparse_tensor() {
-  if (sparse_tensor_ != nullptr) sparse_tensor_->Clear();
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
-  const ::onnx::SparseTensorProto* p = sparse_tensor_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::SparseTensorProto*>(
-      &::onnx::_SparseTensorProto_default_instance_);
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
-  return _internal_sparse_tensor();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(
-    ::onnx::SparseTensorProto* sparse_tensor) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_);
-  }
-  sparse_tensor_ = sparse_tensor;
-  if (sparse_tensor) {
-    _has_bits_[0] |= 0x00000080u;
-  } else {
-    _has_bits_[0] &= ~0x00000080u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
-}
-inline ::onnx::SparseTensorProto* AttributeProto::release_sparse_tensor() {
-  auto temp = unsafe_arena_release_sparse_tensor();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::unsafe_arena_release_sparse_tensor() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)
-  _has_bits_[0] &= ~0x00000080u;
-  ::onnx::SparseTensorProto* temp = sparse_tensor_;
-  sparse_tensor_ = nullptr;
-  return temp;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::_internal_mutable_sparse_tensor() {
-  _has_bits_[0] |= 0x00000080u;
-  if (sparse_tensor_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::SparseTensorProto>(GetArena());
-    sparse_tensor_ = p;
-  }
-  return sparse_tensor_;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensor() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
-  return _internal_mutable_sparse_tensor();
-}
-inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* sparse_tensor) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete sparse_tensor_;
-  }
-  if (sparse_tensor) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sparse_tensor);
-    if (message_arena != submessage_arena) {
-      sparse_tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sparse_tensor, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000080u;
-  } else {
-    _has_bits_[0] &= ~0x00000080u;
-  }
-  sparse_tensor_ = sparse_tensor;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
-}
-
-// optional .onnx.TypeProto tp = 14;
-inline bool AttributeProto::_internal_has_tp() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
-  PROTOBUF_ASSUME(!value || tp_ != nullptr);
-  return value;
-}
-inline bool AttributeProto::has_tp() const {
-  return _internal_has_tp();
-}
-inline void AttributeProto::clear_tp() {
-  if (tp_ != nullptr) tp_->Clear();
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
-  const ::onnx::TypeProto* p = tp_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& AttributeProto::tp() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
-  return _internal_tp();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_tp(
-    ::onnx::TypeProto* tp) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tp_);
-  }
-  tp_ = tp;
-  if (tp) {
-    _has_bits_[0] |= 0x00000040u;
-  } else {
-    _has_bits_[0] &= ~0x00000040u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
-}
-inline ::onnx::TypeProto* AttributeProto::release_tp() {
-  auto temp = unsafe_arena_release_tp();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* AttributeProto::unsafe_arena_release_tp() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)
-  _has_bits_[0] &= ~0x00000040u;
-  ::onnx::TypeProto* temp = tp_;
-  tp_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* AttributeProto::_internal_mutable_tp() {
-  _has_bits_[0] |= 0x00000040u;
-  if (tp_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    tp_ = p;
-  }
-  return tp_;
-}
-inline ::onnx::TypeProto* AttributeProto::mutable_tp() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
-  return _internal_mutable_tp();
-}
-inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* tp) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete tp_;
-  }
-  if (tp) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tp);
-    if (message_arena != submessage_arena) {
-      tp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, tp, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000040u;
-  } else {
-    _has_bits_[0] &= ~0x00000040u;
-  }
-  tp_ = tp;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
-}
-
-// repeated float floats = 7;
-inline int AttributeProto::_internal_floats_size() const {
-  return floats_.size();
-}
-inline int AttributeProto::floats_size() const {
-  return _internal_floats_size();
-}
-inline void AttributeProto::clear_floats() {
-  floats_.Clear();
-}
-inline float AttributeProto::_internal_floats(int index) const {
-  return floats_.Get(index);
-}
-inline float AttributeProto::floats(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
-  return _internal_floats(index);
-}
-inline void AttributeProto::set_floats(int index, float value) {
-  floats_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
-}
-inline void AttributeProto::_internal_add_floats(float value) {
-  floats_.Add(value);
-}
-inline void AttributeProto::add_floats(float value) {
-  _internal_add_floats(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-AttributeProto::_internal_floats() const {
-  return floats_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-AttributeProto::floats() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
-  return _internal_floats();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-AttributeProto::_internal_mutable_floats() {
-  return &floats_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-AttributeProto::mutable_floats() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
-  return _internal_mutable_floats();
-}
-
-// repeated int64 ints = 8;
-inline int AttributeProto::_internal_ints_size() const {
-  return ints_.size();
-}
-inline int AttributeProto::ints_size() const {
-  return _internal_ints_size();
-}
-inline void AttributeProto::clear_ints() {
-  ints_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::_internal_ints(int index) const {
-  return ints_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::ints(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
-  return _internal_ints(index);
-}
-inline void AttributeProto::set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  ints_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
-}
-inline void AttributeProto::_internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  ints_.Add(value);
-}
-inline void AttributeProto::add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_ints(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-AttributeProto::_internal_ints() const {
-  return ints_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-AttributeProto::ints() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
-  return _internal_ints();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-AttributeProto::_internal_mutable_ints() {
-  return &ints_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-AttributeProto::mutable_ints() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
-  return _internal_mutable_ints();
-}
-
-// repeated bytes strings = 9;
-inline int AttributeProto::_internal_strings_size() const {
-  return strings_.size();
-}
-inline int AttributeProto::strings_size() const {
-  return _internal_strings_size();
-}
-inline void AttributeProto::clear_strings() {
-  strings_.Clear();
-}
-inline std::string* AttributeProto::add_strings() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
-  return _internal_add_strings();
-}
-inline const std::string& AttributeProto::_internal_strings(int index) const {
-  return strings_.Get(index);
-}
-inline const std::string& AttributeProto::strings(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
-  return _internal_strings(index);
-}
-inline std::string* AttributeProto::mutable_strings(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
-  return strings_.Mutable(index);
-}
-inline void AttributeProto::set_strings(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
-  strings_.Mutable(index)->assign(value);
-}
-inline void AttributeProto::set_strings(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
-  strings_.Mutable(index)->assign(std::move(value));
-}
-inline void AttributeProto::set_strings(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  strings_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
-  strings_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.strings)
-}
-inline std::string* AttributeProto::_internal_add_strings() {
-  return strings_.Add();
-}
-inline void AttributeProto::add_strings(const std::string& value) {
-  strings_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(std::string&& value) {
-  strings_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  strings_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(const void* value, size_t size) {
-  strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.AttributeProto.strings)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-AttributeProto::strings() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
-  return strings_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-AttributeProto::mutable_strings() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
-  return &strings_;
-}
-
-// repeated .onnx.TensorProto tensors = 10;
-inline int AttributeProto::_internal_tensors_size() const {
-  return tensors_.size();
-}
-inline int AttributeProto::tensors_size() const {
-  return _internal_tensors_size();
-}
-inline void AttributeProto::clear_tensors() {
-  tensors_.Clear();
-}
-inline ::onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
-  return tensors_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-AttributeProto::mutable_tensors() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
-  return &tensors_;
-}
-inline const ::onnx::TensorProto& AttributeProto::_internal_tensors(int index) const {
-  return tensors_.Get(index);
-}
-inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
-  return _internal_tensors(index);
-}
-inline ::onnx::TensorProto* AttributeProto::_internal_add_tensors() {
-  return tensors_.Add();
-}
-inline ::onnx::TensorProto* AttributeProto::add_tensors() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
-  return _internal_add_tensors();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-AttributeProto::tensors() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
-  return tensors_;
-}
-
-// repeated .onnx.GraphProto graphs = 11;
-inline int AttributeProto::_internal_graphs_size() const {
-  return graphs_.size();
-}
-inline int AttributeProto::graphs_size() const {
-  return _internal_graphs_size();
-}
-inline void AttributeProto::clear_graphs() {
-  graphs_.Clear();
-}
-inline ::onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
-  return graphs_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >*
-AttributeProto::mutable_graphs() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
-  return &graphs_;
-}
-inline const ::onnx::GraphProto& AttributeProto::_internal_graphs(int index) const {
-  return graphs_.Get(index);
-}
-inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
-  return _internal_graphs(index);
-}
-inline ::onnx::GraphProto* AttributeProto::_internal_add_graphs() {
-  return graphs_.Add();
-}
-inline ::onnx::GraphProto* AttributeProto::add_graphs() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
-  return _internal_add_graphs();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >&
-AttributeProto::graphs() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
-  return graphs_;
-}
-
-// repeated .onnx.SparseTensorProto sparse_tensors = 23;
-inline int AttributeProto::_internal_sparse_tensors_size() const {
-  return sparse_tensors_.size();
-}
-inline int AttributeProto::sparse_tensors_size() const {
-  return _internal_sparse_tensors_size();
-}
-inline void AttributeProto::clear_sparse_tensors() {
-  sparse_tensors_.Clear();
-}
-inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensors(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
-  return sparse_tensors_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-AttributeProto::mutable_sparse_tensors() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
-  return &sparse_tensors_;
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensors(int index) const {
-  return sparse_tensors_.Get(index);
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
-  return _internal_sparse_tensors(index);
-}
-inline ::onnx::SparseTensorProto* AttributeProto::_internal_add_sparse_tensors() {
-  return sparse_tensors_.Add();
-}
-inline ::onnx::SparseTensorProto* AttributeProto::add_sparse_tensors() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
-  return _internal_add_sparse_tensors();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-AttributeProto::sparse_tensors() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
-  return sparse_tensors_;
-}
-
-// repeated .onnx.TypeProto type_protos = 15;
-inline int AttributeProto::_internal_type_protos_size() const {
-  return type_protos_.size();
-}
-inline int AttributeProto::type_protos_size() const {
-  return _internal_type_protos_size();
-}
-inline void AttributeProto::clear_type_protos() {
-  type_protos_.Clear();
-}
-inline ::onnx::TypeProto* AttributeProto::mutable_type_protos(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
-  return type_protos_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >*
-AttributeProto::mutable_type_protos() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
-  return &type_protos_;
-}
-inline const ::onnx::TypeProto& AttributeProto::_internal_type_protos(int index) const {
-  return type_protos_.Get(index);
-}
-inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
-  return _internal_type_protos(index);
-}
-inline ::onnx::TypeProto* AttributeProto::_internal_add_type_protos() {
-  return type_protos_.Add();
-}
-inline ::onnx::TypeProto* AttributeProto::add_type_protos() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
-  return _internal_add_type_protos();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >&
-AttributeProto::type_protos() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
-  return type_protos_;
-}
-
-// -------------------------------------------------------------------
-
-// ValueInfoProto
-
-// optional string name = 1;
-inline bool ValueInfoProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ValueInfoProto::has_name() const {
-  return _internal_has_name();
-}
-inline void ValueInfoProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& ValueInfoProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
-  return _internal_name();
-}
-inline void ValueInfoProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& ValueInfoProto::_internal_name() const {
-  return name_.Get();
-}
-inline void ValueInfoProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ValueInfoProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ValueInfoProto.name)
-}
-inline void ValueInfoProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ValueInfoProto.name)
-}
-inline void ValueInfoProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ValueInfoProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ValueInfoProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ValueInfoProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.name)
-}
-
-// optional .onnx.TypeProto type = 2;
-inline bool ValueInfoProto::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  PROTOBUF_ASSUME(!value || type_ != nullptr);
-  return value;
-}
-inline bool ValueInfoProto::has_type() const {
-  return _internal_has_type();
-}
-inline void ValueInfoProto::clear_type() {
-  if (type_ != nullptr) type_->Clear();
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
-  const ::onnx::TypeProto* p = type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& ValueInfoProto::type() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
-  return _internal_type();
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_type(
-    ::onnx::TypeProto* type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
-  }
-  type_ = type;
-  if (type) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
-}
-inline ::onnx::TypeProto* ValueInfoProto::release_type() {
-  auto temp = unsafe_arena_release_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)
-  _has_bits_[0] &= ~0x00000004u;
-  ::onnx::TypeProto* temp = type_;
-  type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
-  _has_bits_[0] |= 0x00000004u;
-  if (type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    type_ = p;
-  }
-  return type_;
-}
-inline ::onnx::TypeProto* ValueInfoProto::mutable_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
-  return _internal_mutable_type();
-}
-inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete type_;
-  }
-  if (type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type);
-    if (message_arena != submessage_arena) {
-      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, type, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  type_ = type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
-}
-
-// optional string doc_string = 3;
-inline bool ValueInfoProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool ValueInfoProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void ValueInfoProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& ValueInfoProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
-  return _internal_doc_string();
-}
-inline void ValueInfoProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& ValueInfoProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ValueInfoProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ValueInfoProto.doc_string)
-}
-inline void ValueInfoProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ValueInfoProto.doc_string)
-}
-inline void ValueInfoProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000002u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ValueInfoProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ValueInfoProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ValueInfoProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.doc_string)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 4;
-inline int ValueInfoProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int ValueInfoProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void ValueInfoProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-ValueInfoProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& ValueInfoProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-ValueInfoProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// NodeProto
-
-// repeated string input = 1;
-inline int NodeProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int NodeProto::input_size() const {
-  return _internal_input_size();
-}
-inline void NodeProto::clear_input() {
-  input_.Clear();
-}
-inline std::string* NodeProto::add_input() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
-  return _internal_add_input();
-}
-inline const std::string& NodeProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const std::string& NodeProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
-  return _internal_input(index);
-}
-inline std::string* NodeProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
-  return input_.Mutable(index);
-}
-inline void NodeProto::set_input(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
-  input_.Mutable(index)->assign(value);
-}
-inline void NodeProto::set_input(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
-  input_.Mutable(index)->assign(std::move(value));
-}
-inline void NodeProto::set_input(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.input)
-}
-inline void NodeProto::set_input(int index, const char* value, size_t size) {
-  input_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.input)
-}
-inline std::string* NodeProto::_internal_add_input() {
-  return input_.Add();
-}
-inline void NodeProto::add_input(const std::string& value) {
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(std::string&& value) {
-  input_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(const char* value, size_t size) {
-  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.NodeProto.input)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-NodeProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
-  return input_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-NodeProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
-  return &input_;
-}
-
-// repeated string output = 2;
-inline int NodeProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int NodeProto::output_size() const {
-  return _internal_output_size();
-}
-inline void NodeProto::clear_output() {
-  output_.Clear();
-}
-inline std::string* NodeProto::add_output() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
-  return _internal_add_output();
-}
-inline const std::string& NodeProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const std::string& NodeProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
-  return _internal_output(index);
-}
-inline std::string* NodeProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
-  return output_.Mutable(index);
-}
-inline void NodeProto::set_output(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
-  output_.Mutable(index)->assign(value);
-}
-inline void NodeProto::set_output(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
-  output_.Mutable(index)->assign(std::move(value));
-}
-inline void NodeProto::set_output(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.output)
-}
-inline void NodeProto::set_output(int index, const char* value, size_t size) {
-  output_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.output)
-}
-inline std::string* NodeProto::_internal_add_output() {
-  return output_.Add();
-}
-inline void NodeProto::add_output(const std::string& value) {
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(std::string&& value) {
-  output_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(const char* value, size_t size) {
-  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.NodeProto.output)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-NodeProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
-  return output_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-NodeProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
-  return &output_;
-}
-
-// optional string name = 3;
-inline bool NodeProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool NodeProto::has_name() const {
-  return _internal_has_name();
-}
-inline void NodeProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& NodeProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
-  return _internal_name();
-}
-inline void NodeProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& NodeProto::_internal_name() const {
-  return name_.Get();
-}
-inline void NodeProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.name)
-}
-inline void NodeProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.name)
-}
-inline void NodeProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.name)
-}
-
-// optional string op_type = 4;
-inline bool NodeProto::_internal_has_op_type() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool NodeProto::has_op_type() const {
-  return _internal_has_op_type();
-}
-inline void NodeProto::clear_op_type() {
-  op_type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& NodeProto::op_type() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
-  return _internal_op_type();
-}
-inline void NodeProto::set_op_type(const std::string& value) {
-  _internal_set_op_type(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::mutable_op_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
-  return _internal_mutable_op_type();
-}
-inline const std::string& NodeProto::_internal_op_type() const {
-  return op_type_.Get();
-}
-inline void NodeProto::_internal_set_op_type(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_op_type(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  op_type_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.op_type)
-}
-inline void NodeProto::set_op_type(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.op_type)
-}
-inline void NodeProto::set_op_type(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::_internal_mutable_op_type() {
-  _has_bits_[0] |= 0x00000002u;
-  return op_type_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_op_type() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
-  if (!_internal_has_op_type()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return op_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_op_type(std::string* op_type) {
-  if (op_type != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  op_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_type,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::unsafe_arena_release_op_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.op_type)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return op_type_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_op_type(
-    std::string* op_type) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (op_type != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  op_type_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      op_type, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.op_type)
-}
-
-// optional string domain = 7;
-inline bool NodeProto::_internal_has_domain() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool NodeProto::has_domain() const {
-  return _internal_has_domain();
-}
-inline void NodeProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& NodeProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
-  return _internal_domain();
-}
-inline void NodeProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& NodeProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void NodeProto::_internal_set_domain(const std::string& value) {
-  _has_bits_[0] |= 0x00000008u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_domain(std::string&& value) {
-  _has_bits_[0] |= 0x00000008u;
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.domain)
-}
-inline void NodeProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000008u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.domain)
-}
-inline void NodeProto::set_domain(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000008u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::_internal_mutable_domain() {
-  _has_bits_[0] |= 0x00000008u;
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
-  if (!_internal_has_domain()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000008u;
-  return domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000008u;
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.domain)
-}
-
-// optional string overload = 8;
-inline bool NodeProto::_internal_has_overload() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool NodeProto::has_overload() const {
-  return _internal_has_overload();
-}
-inline void NodeProto::clear_overload() {
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline const std::string& NodeProto::overload() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.overload)
-  return _internal_overload();
-}
-inline void NodeProto::set_overload(const std::string& value) {
-  _internal_set_overload(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::mutable_overload() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload)
-  return _internal_mutable_overload();
-}
-inline const std::string& NodeProto::_internal_overload() const {
-  return overload_.Get();
-}
-inline void NodeProto::_internal_set_overload(const std::string& value) {
-  _has_bits_[0] |= 0x00000010u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_overload(std::string&& value) {
-  _has_bits_[0] |= 0x00000010u;
-  overload_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.overload)
-}
-inline void NodeProto::set_overload(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000010u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.overload)
-}
-inline void NodeProto::set_overload(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000010u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::_internal_mutable_overload() {
-  _has_bits_[0] |= 0x00000010u;
-  return overload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_overload() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.overload)
-  if (!_internal_has_overload()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000010u;
-  return overload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_overload(std::string* overload) {
-  if (overload != nullptr) {
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::unsafe_arena_release_overload() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.overload)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000010u;
-  return overload_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_overload(
-    std::string* overload) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (overload != nullptr) {
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  overload_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      overload, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.overload)
-}
-
-// repeated .onnx.AttributeProto attribute = 5;
-inline int NodeProto::_internal_attribute_size() const {
-  return attribute_.size();
-}
-inline int NodeProto::attribute_size() const {
-  return _internal_attribute_size();
-}
-inline void NodeProto::clear_attribute() {
-  attribute_.Clear();
-}
-inline ::onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
-  return attribute_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-NodeProto::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
-  return &attribute_;
-}
-inline const ::onnx::AttributeProto& NodeProto::_internal_attribute(int index) const {
-  return attribute_.Get(index);
-}
-inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
-  return _internal_attribute(index);
-}
-inline ::onnx::AttributeProto* NodeProto::_internal_add_attribute() {
-  return attribute_.Add();
-}
-inline ::onnx::AttributeProto* NodeProto::add_attribute() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
-  return _internal_add_attribute();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-NodeProto::attribute() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
-  return attribute_;
-}
-
-// optional string doc_string = 6;
-inline bool NodeProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool NodeProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void NodeProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& NodeProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
-  return _internal_doc_string();
-}
-inline void NodeProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& NodeProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void NodeProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.doc_string)
-}
-inline void NodeProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.doc_string)
-}
-inline void NodeProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000004u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.doc_string)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 9;
-inline int NodeProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int NodeProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void NodeProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* NodeProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-NodeProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& NodeProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* NodeProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* NodeProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-NodeProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props)
-  return metadata_props_;
-}
-
-// repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-inline int NodeProto::_internal_device_configurations_size() const {
-  return device_configurations_.size();
-}
-inline int NodeProto::device_configurations_size() const {
-  return _internal_device_configurations_size();
-}
-inline void NodeProto::clear_device_configurations() {
-  device_configurations_.Clear();
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::mutable_device_configurations(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.device_configurations)
-  return device_configurations_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >*
-NodeProto::mutable_device_configurations() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.device_configurations)
-  return &device_configurations_;
-}
-inline const ::onnx::NodeDeviceConfigurationProto& NodeProto::_internal_device_configurations(int index) const {
-  return device_configurations_.Get(index);
-}
-inline const ::onnx::NodeDeviceConfigurationProto& NodeProto::device_configurations(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.device_configurations)
-  return _internal_device_configurations(index);
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::_internal_add_device_configurations() {
-  return device_configurations_.Add();
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::add_device_configurations() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.device_configurations)
-  return _internal_add_device_configurations();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >&
-NodeProto::device_configurations() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.device_configurations)
-  return device_configurations_;
-}
-
-// -------------------------------------------------------------------
-
-// IntIntListEntryProto
-
-// optional int64 key = 1;
-inline bool IntIntListEntryProto::_internal_has_key() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool IntIntListEntryProto::has_key() const {
-  return _internal_has_key();
-}
-inline void IntIntListEntryProto::clear_key() {
-  key_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::_internal_key() const {
-  return key_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::key() const {
-  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.key)
-  return _internal_key();
-}
-inline void IntIntListEntryProto::_internal_set_key(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000001u;
-  key_ = value;
-}
-inline void IntIntListEntryProto::set_key(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_key(value);
-  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.key)
-}
-
-// repeated int64 value = 2;
-inline int IntIntListEntryProto::_internal_value_size() const {
-  return value_.size();
-}
-inline int IntIntListEntryProto::value_size() const {
-  return _internal_value_size();
-}
-inline void IntIntListEntryProto::clear_value() {
-  value_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::_internal_value(int index) const {
-  return value_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::value(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.value)
-  return _internal_value(index);
-}
-inline void IntIntListEntryProto::set_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  value_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.value)
-}
-inline void IntIntListEntryProto::_internal_add_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  value_.Add(value);
-}
-inline void IntIntListEntryProto::add_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_value(value);
-  // @@protoc_insertion_point(field_add:onnx.IntIntListEntryProto.value)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-IntIntListEntryProto::_internal_value() const {
-  return value_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-IntIntListEntryProto::value() const {
-  // @@protoc_insertion_point(field_list:onnx.IntIntListEntryProto.value)
-  return _internal_value();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-IntIntListEntryProto::_internal_mutable_value() {
-  return &value_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-IntIntListEntryProto::mutable_value() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.IntIntListEntryProto.value)
-  return _internal_mutable_value();
-}
-
-// -------------------------------------------------------------------
-
-// NodeDeviceConfigurationProto
-
-// optional string configuration_id = 1;
-inline bool NodeDeviceConfigurationProto::_internal_has_configuration_id() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool NodeDeviceConfigurationProto::has_configuration_id() const {
-  return _internal_has_configuration_id();
-}
-inline void NodeDeviceConfigurationProto::clear_configuration_id() {
-  configuration_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& NodeDeviceConfigurationProto::configuration_id() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.configuration_id)
-  return _internal_configuration_id();
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const std::string& value) {
-  _internal_set_configuration_id(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::mutable_configuration_id() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.configuration_id)
-  return _internal_mutable_configuration_id();
-}
-inline const std::string& NodeDeviceConfigurationProto::_internal_configuration_id() const {
-  return configuration_id_.Get();
-}
-inline void NodeDeviceConfigurationProto::_internal_set_configuration_id(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  configuration_id_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::_internal_mutable_configuration_id() {
-  _has_bits_[0] |= 0x00000001u;
-  return configuration_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeDeviceConfigurationProto::release_configuration_id() {
-  // @@protoc_insertion_point(field_release:onnx.NodeDeviceConfigurationProto.configuration_id)
-  if (!_internal_has_configuration_id()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return configuration_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeDeviceConfigurationProto::set_allocated_configuration_id(std::string* configuration_id) {
-  if (configuration_id != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  configuration_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), configuration_id,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::unsafe_arena_release_configuration_id() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeDeviceConfigurationProto.configuration_id)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return configuration_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeDeviceConfigurationProto::unsafe_arena_set_allocated_configuration_id(
-    std::string* configuration_id) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (configuration_id != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  configuration_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      configuration_id, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-
-// repeated .onnx.ShardingSpecProto sharding_spec = 2;
-inline int NodeDeviceConfigurationProto::_internal_sharding_spec_size() const {
-  return sharding_spec_.size();
-}
-inline int NodeDeviceConfigurationProto::sharding_spec_size() const {
-  return _internal_sharding_spec_size();
-}
-inline void NodeDeviceConfigurationProto::clear_sharding_spec() {
-  sharding_spec_.Clear();
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::mutable_sharding_spec(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return sharding_spec_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >*
-NodeDeviceConfigurationProto::mutable_sharding_spec() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return &sharding_spec_;
-}
-inline const ::onnx::ShardingSpecProto& NodeDeviceConfigurationProto::_internal_sharding_spec(int index) const {
-  return sharding_spec_.Get(index);
-}
-inline const ::onnx::ShardingSpecProto& NodeDeviceConfigurationProto::sharding_spec(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return _internal_sharding_spec(index);
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::_internal_add_sharding_spec() {
-  return sharding_spec_.Add();
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::add_sharding_spec() {
-  // @@protoc_insertion_point(field_add:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return _internal_add_sharding_spec();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >&
-NodeDeviceConfigurationProto::sharding_spec() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return sharding_spec_;
-}
-
-// optional int32 pipeline_stage = 3;
-inline bool NodeDeviceConfigurationProto::_internal_has_pipeline_stage() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool NodeDeviceConfigurationProto::has_pipeline_stage() const {
-  return _internal_has_pipeline_stage();
-}
-inline void NodeDeviceConfigurationProto::clear_pipeline_stage() {
-  pipeline_stage_ = 0;
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 NodeDeviceConfigurationProto::_internal_pipeline_stage() const {
-  return pipeline_stage_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 NodeDeviceConfigurationProto::pipeline_stage() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.pipeline_stage)
-  return _internal_pipeline_stage();
-}
-inline void NodeDeviceConfigurationProto::_internal_set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000002u;
-  pipeline_stage_ = value;
-}
-inline void NodeDeviceConfigurationProto::set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_pipeline_stage(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.pipeline_stage)
-}
-
-// -------------------------------------------------------------------
-
-// ShardingSpecProto
-
-// optional string tensor_name = 1;
-inline bool ShardingSpecProto::_internal_has_tensor_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ShardingSpecProto::has_tensor_name() const {
-  return _internal_has_tensor_name();
-}
-inline void ShardingSpecProto::clear_tensor_name() {
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& ShardingSpecProto::tensor_name() const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.tensor_name)
-  return _internal_tensor_name();
-}
-inline void ShardingSpecProto::set_tensor_name(const std::string& value) {
-  _internal_set_tensor_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::mutable_tensor_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.tensor_name)
-  return _internal_mutable_tensor_name();
-}
-inline const std::string& ShardingSpecProto::_internal_tensor_name() const {
-  return tensor_name_.Get();
-}
-inline void ShardingSpecProto::_internal_set_tensor_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ShardingSpecProto::set_tensor_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ShardingSpecProto.tensor_name)
-}
-inline void ShardingSpecProto::set_tensor_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ShardingSpecProto.tensor_name)
-}
-inline void ShardingSpecProto::set_tensor_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::_internal_mutable_tensor_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return tensor_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ShardingSpecProto::release_tensor_name() {
-  // @@protoc_insertion_point(field_release:onnx.ShardingSpecProto.tensor_name)
-  if (!_internal_has_tensor_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return tensor_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ShardingSpecProto::set_allocated_tensor_name(std::string* tensor_name) {
-  if (tensor_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::unsafe_arena_release_tensor_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ShardingSpecProto.tensor_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return tensor_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ShardingSpecProto::unsafe_arena_set_allocated_tensor_name(
-    std::string* tensor_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (tensor_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  tensor_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      tensor_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ShardingSpecProto.tensor_name)
-}
-
-// repeated int64 device = 2;
-inline int ShardingSpecProto::_internal_device_size() const {
-  return device_.size();
-}
-inline int ShardingSpecProto::device_size() const {
-  return _internal_device_size();
-}
-inline void ShardingSpecProto::clear_device() {
-  device_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardingSpecProto::_internal_device(int index) const {
-  return device_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardingSpecProto::device(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.device)
-  return _internal_device(index);
-}
-inline void ShardingSpecProto::set_device(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  device_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.device)
-}
-inline void ShardingSpecProto::_internal_add_device(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  device_.Add(value);
-}
-inline void ShardingSpecProto::add_device(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_device(value);
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.device)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-ShardingSpecProto::_internal_device() const {
-  return device_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-ShardingSpecProto::device() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.device)
-  return _internal_device();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-ShardingSpecProto::_internal_mutable_device() {
-  return &device_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-ShardingSpecProto::mutable_device() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.device)
-  return _internal_mutable_device();
-}
-
-// repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-inline int ShardingSpecProto::_internal_index_to_device_group_map_size() const {
-  return index_to_device_group_map_.size();
-}
-inline int ShardingSpecProto::index_to_device_group_map_size() const {
-  return _internal_index_to_device_group_map_size();
-}
-inline void ShardingSpecProto::clear_index_to_device_group_map() {
-  index_to_device_group_map_.Clear();
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::mutable_index_to_device_group_map(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.index_to_device_group_map)
-  return index_to_device_group_map_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >*
-ShardingSpecProto::mutable_index_to_device_group_map() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.index_to_device_group_map)
-  return &index_to_device_group_map_;
-}
-inline const ::onnx::IntIntListEntryProto& ShardingSpecProto::_internal_index_to_device_group_map(int index) const {
-  return index_to_device_group_map_.Get(index);
-}
-inline const ::onnx::IntIntListEntryProto& ShardingSpecProto::index_to_device_group_map(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.index_to_device_group_map)
-  return _internal_index_to_device_group_map(index);
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::_internal_add_index_to_device_group_map() {
-  return index_to_device_group_map_.Add();
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::add_index_to_device_group_map() {
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.index_to_device_group_map)
-  return _internal_add_index_to_device_group_map();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >&
-ShardingSpecProto::index_to_device_group_map() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.index_to_device_group_map)
-  return index_to_device_group_map_;
-}
-
-// repeated .onnx.ShardedDimProto sharded_dim = 4;
-inline int ShardingSpecProto::_internal_sharded_dim_size() const {
-  return sharded_dim_.size();
-}
-inline int ShardingSpecProto::sharded_dim_size() const {
-  return _internal_sharded_dim_size();
-}
-inline void ShardingSpecProto::clear_sharded_dim() {
-  sharded_dim_.Clear();
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::mutable_sharded_dim(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.sharded_dim)
-  return sharded_dim_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >*
-ShardingSpecProto::mutable_sharded_dim() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.sharded_dim)
-  return &sharded_dim_;
-}
-inline const ::onnx::ShardedDimProto& ShardingSpecProto::_internal_sharded_dim(int index) const {
-  return sharded_dim_.Get(index);
-}
-inline const ::onnx::ShardedDimProto& ShardingSpecProto::sharded_dim(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.sharded_dim)
-  return _internal_sharded_dim(index);
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::_internal_add_sharded_dim() {
-  return sharded_dim_.Add();
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::add_sharded_dim() {
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.sharded_dim)
-  return _internal_add_sharded_dim();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >&
-ShardingSpecProto::sharded_dim() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.sharded_dim)
-  return sharded_dim_;
-}
-
-// -------------------------------------------------------------------
-
-// ShardedDimProto
-
-// optional int64 axis = 1;
-inline bool ShardedDimProto::_internal_has_axis() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ShardedDimProto::has_axis() const {
-  return _internal_has_axis();
-}
-inline void ShardedDimProto::clear_axis() {
-  axis_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardedDimProto::_internal_axis() const {
-  return axis_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardedDimProto::axis() const {
-  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.axis)
-  return _internal_axis();
-}
-inline void ShardedDimProto::_internal_set_axis(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000001u;
-  axis_ = value;
-}
-inline void ShardedDimProto::set_axis(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_axis(value);
-  // @@protoc_insertion_point(field_set:onnx.ShardedDimProto.axis)
-}
-
-// repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-inline int ShardedDimProto::_internal_simple_sharding_size() const {
-  return simple_sharding_.size();
-}
-inline int ShardedDimProto::simple_sharding_size() const {
-  return _internal_simple_sharding_size();
-}
-inline void ShardedDimProto::clear_simple_sharding() {
-  simple_sharding_.Clear();
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::mutable_simple_sharding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardedDimProto.simple_sharding)
-  return simple_sharding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >*
-ShardedDimProto::mutable_simple_sharding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardedDimProto.simple_sharding)
-  return &simple_sharding_;
-}
-inline const ::onnx::SimpleShardedDimProto& ShardedDimProto::_internal_simple_sharding(int index) const {
-  return simple_sharding_.Get(index);
-}
-inline const ::onnx::SimpleShardedDimProto& ShardedDimProto::simple_sharding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.simple_sharding)
-  return _internal_simple_sharding(index);
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::_internal_add_simple_sharding() {
-  return simple_sharding_.Add();
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::add_simple_sharding() {
-  // @@protoc_insertion_point(field_add:onnx.ShardedDimProto.simple_sharding)
-  return _internal_add_simple_sharding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >&
-ShardedDimProto::simple_sharding() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardedDimProto.simple_sharding)
-  return simple_sharding_;
-}
-
-// -------------------------------------------------------------------
-
-// SimpleShardedDimProto
-
-// int64 dim_value = 1;
-inline bool SimpleShardedDimProto::_internal_has_dim_value() const {
-  return dim_case() == kDimValue;
-}
-inline bool SimpleShardedDimProto::has_dim_value() const {
-  return _internal_has_dim_value();
-}
-inline void SimpleShardedDimProto::set_has_dim_value() {
-  _oneof_case_[0] = kDimValue;
-}
-inline void SimpleShardedDimProto::clear_dim_value() {
-  if (_internal_has_dim_value()) {
-    dim_.dim_value_ = PROTOBUF_LONGLONG(0);
-    clear_has_dim();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::_internal_dim_value() const {
-  if (_internal_has_dim_value()) {
-    return dim_.dim_value_;
-  }
-  return PROTOBUF_LONGLONG(0);
-}
-inline void SimpleShardedDimProto::_internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  if (!_internal_has_dim_value()) {
-    clear_dim();
-    set_has_dim_value();
-  }
-  dim_.dim_value_ = value;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::dim_value() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_value)
-  return _internal_dim_value();
-}
-inline void SimpleShardedDimProto::set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_dim_value(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_value)
-}
-
-// string dim_param = 2;
-inline bool SimpleShardedDimProto::_internal_has_dim_param() const {
-  return dim_case() == kDimParam;
-}
-inline bool SimpleShardedDimProto::has_dim_param() const {
-  return _internal_has_dim_param();
-}
-inline void SimpleShardedDimProto::set_has_dim_param() {
-  _oneof_case_[0] = kDimParam;
-}
-inline void SimpleShardedDimProto::clear_dim_param() {
-  if (_internal_has_dim_param()) {
-    dim_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-    clear_has_dim();
-  }
-}
-inline const std::string& SimpleShardedDimProto::dim_param() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_param)
-  return _internal_dim_param();
-}
-inline void SimpleShardedDimProto::set_dim_param(const std::string& value) {
-  _internal_set_dim_param(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::mutable_dim_param() {
-  // @@protoc_insertion_point(field_mutable:onnx.SimpleShardedDimProto.dim_param)
-  return _internal_mutable_dim_param();
-}
-inline const std::string& SimpleShardedDimProto::_internal_dim_param() const {
-  if (_internal_has_dim_param()) {
-    return dim_.dim_param_.Get();
-  }
-  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void SimpleShardedDimProto::_internal_set_dim_param(const std::string& value) {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void SimpleShardedDimProto::set_dim_param(std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_param)
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.SimpleShardedDimProto.dim_param)
-}
-inline void SimpleShardedDimProto::set_dim_param(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.SimpleShardedDimProto.dim_param)
-}
-inline void SimpleShardedDimProto::set_dim_param(const char* value,
-                             size_t size) {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size),
-      GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::_internal_mutable_dim_param() {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  return dim_.dim_param_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* SimpleShardedDimProto::release_dim_param() {
-  // @@protoc_insertion_point(field_release:onnx.SimpleShardedDimProto.dim_param)
-  if (_internal_has_dim_param()) {
-    clear_has_dim();
-    return dim_.dim_param_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void SimpleShardedDimProto::set_allocated_dim_param(std::string* dim_param) {
-  if (has_dim()) {
-    clear_dim();
-  }
-  if (dim_param != nullptr) {
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(dim_param);
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::unsafe_arena_release_dim_param() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.SimpleShardedDimProto.dim_param)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (_internal_has_dim_param()) {
-    clear_has_dim();
-    return dim_.dim_param_.UnsafeArenaRelease(
-        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void SimpleShardedDimProto::unsafe_arena_set_allocated_dim_param(std::string* dim_param) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (!_internal_has_dim_param()) {
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_dim();
-  if (dim_param) {
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dim_param, GetArena());
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SimpleShardedDimProto.dim_param)
-}
-
-// optional int64 num_shards = 3;
-inline bool SimpleShardedDimProto::_internal_has_num_shards() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool SimpleShardedDimProto::has_num_shards() const {
-  return _internal_has_num_shards();
-}
-inline void SimpleShardedDimProto::clear_num_shards() {
-  num_shards_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::_internal_num_shards() const {
-  return num_shards_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::num_shards() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.num_shards)
-  return _internal_num_shards();
-}
-inline void SimpleShardedDimProto::_internal_set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000001u;
-  num_shards_ = value;
-}
-inline void SimpleShardedDimProto::set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_num_shards(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.num_shards)
-}
-
-inline bool SimpleShardedDimProto::has_dim() const {
-  return dim_case() != DIM_NOT_SET;
-}
-inline void SimpleShardedDimProto::clear_has_dim() {
-  _oneof_case_[0] = DIM_NOT_SET;
-}
-inline SimpleShardedDimProto::DimCase SimpleShardedDimProto::dim_case() const {
-  return SimpleShardedDimProto::DimCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// TrainingInfoProto
-
-// optional .onnx.GraphProto initialization = 1;
-inline bool TrainingInfoProto::_internal_has_initialization() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || initialization_ != nullptr);
-  return value;
-}
-inline bool TrainingInfoProto::has_initialization() const {
-  return _internal_has_initialization();
-}
-inline void TrainingInfoProto::clear_initialization() {
-  if (initialization_ != nullptr) initialization_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
-  const ::onnx::GraphProto* p = initialization_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
-  return _internal_initialization();
-}
-inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(
-    ::onnx::GraphProto* initialization) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(initialization_);
-  }
-  initialization_ = initialization;
-  if (initialization) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
-}
-inline ::onnx::GraphProto* TrainingInfoProto::release_initialization() {
-  auto temp = unsafe_arena_release_initialization();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_initialization() {
-  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::GraphProto* temp = initialization_;
-  initialization_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_initialization() {
-  _has_bits_[0] |= 0x00000001u;
-  if (initialization_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    initialization_ = p;
-  }
-  return initialization_;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::mutable_initialization() {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
-  return _internal_mutable_initialization();
-}
-inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* initialization) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete initialization_;
-  }
-  if (initialization) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(initialization);
-    if (message_arena != submessage_arena) {
-      initialization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, initialization, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  initialization_ = initialization;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
-}
-
-// optional .onnx.GraphProto algorithm = 2;
-inline bool TrainingInfoProto::_internal_has_algorithm() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || algorithm_ != nullptr);
-  return value;
-}
-inline bool TrainingInfoProto::has_algorithm() const {
-  return _internal_has_algorithm();
-}
-inline void TrainingInfoProto::clear_algorithm() {
-  if (algorithm_ != nullptr) algorithm_->Clear();
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
-  const ::onnx::GraphProto* p = algorithm_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
-  return _internal_algorithm();
-}
-inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(
-    ::onnx::GraphProto* algorithm) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(algorithm_);
-  }
-  algorithm_ = algorithm;
-  if (algorithm) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
-}
-inline ::onnx::GraphProto* TrainingInfoProto::release_algorithm() {
-  auto temp = unsafe_arena_release_algorithm();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_algorithm() {
-  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)
-  _has_bits_[0] &= ~0x00000002u;
-  ::onnx::GraphProto* temp = algorithm_;
-  algorithm_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_algorithm() {
-  _has_bits_[0] |= 0x00000002u;
-  if (algorithm_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    algorithm_ = p;
-  }
-  return algorithm_;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::mutable_algorithm() {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
-  return _internal_mutable_algorithm();
-}
-inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* algorithm) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete algorithm_;
-  }
-  if (algorithm) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(algorithm);
-    if (message_arena != submessage_arena) {
-      algorithm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, algorithm, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  algorithm_ = algorithm;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
-}
-
-// repeated .onnx.StringStringEntryProto initialization_binding = 3;
-inline int TrainingInfoProto::_internal_initialization_binding_size() const {
-  return initialization_binding_.size();
-}
-inline int TrainingInfoProto::initialization_binding_size() const {
-  return _internal_initialization_binding_size();
-}
-inline void TrainingInfoProto::clear_initialization_binding() {
-  initialization_binding_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_initialization_binding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
-  return initialization_binding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TrainingInfoProto::mutable_initialization_binding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
-  return &initialization_binding_;
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::_internal_initialization_binding(int index) const {
-  return initialization_binding_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
-  return _internal_initialization_binding(index);
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_initialization_binding() {
-  return initialization_binding_.Add();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_initialization_binding() {
-  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
-  return _internal_add_initialization_binding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TrainingInfoProto::initialization_binding() const {
-  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
-  return initialization_binding_;
-}
-
-// repeated .onnx.StringStringEntryProto update_binding = 4;
-inline int TrainingInfoProto::_internal_update_binding_size() const {
-  return update_binding_.size();
-}
-inline int TrainingInfoProto::update_binding_size() const {
-  return _internal_update_binding_size();
-}
-inline void TrainingInfoProto::clear_update_binding() {
-  update_binding_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_update_binding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
-  return update_binding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TrainingInfoProto::mutable_update_binding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
-  return &update_binding_;
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::_internal_update_binding(int index) const {
-  return update_binding_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
-  return _internal_update_binding(index);
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_update_binding() {
-  return update_binding_.Add();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_update_binding() {
-  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
-  return _internal_add_update_binding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TrainingInfoProto::update_binding() const {
-  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
-  return update_binding_;
-}
-
-// -------------------------------------------------------------------
-
-// ModelProto
-
-// optional int64 ir_version = 1;
-inline bool ModelProto::_internal_has_ir_version() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool ModelProto::has_ir_version() const {
-  return _internal_has_ir_version();
-}
-inline void ModelProto::clear_ir_version() {
-  ir_version_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::_internal_ir_version() const {
-  return ir_version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::ir_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
-  return _internal_ir_version();
-}
-inline void ModelProto::_internal_set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000020u;
-  ir_version_ = value;
-}
-inline void ModelProto::set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_ir_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
-}
-
-// repeated .onnx.OperatorSetIdProto opset_import = 8;
-inline int ModelProto::_internal_opset_import_size() const {
-  return opset_import_.size();
-}
-inline int ModelProto::opset_import_size() const {
-  return _internal_opset_import_size();
-}
-inline void ModelProto::clear_opset_import() {
-  opset_import_.Clear();
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
-  return opset_import_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-ModelProto::mutable_opset_import() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
-  return &opset_import_;
-}
-inline const ::onnx::OperatorSetIdProto& ModelProto::_internal_opset_import(int index) const {
-  return opset_import_.Get(index);
-}
-inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
-  return _internal_opset_import(index);
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::_internal_add_opset_import() {
-  return opset_import_.Add();
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
-  return _internal_add_opset_import();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-ModelProto::opset_import() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
-  return opset_import_;
-}
-
-// optional string producer_name = 2;
-inline bool ModelProto::_internal_has_producer_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ModelProto::has_producer_name() const {
-  return _internal_has_producer_name();
-}
-inline void ModelProto::clear_producer_name() {
-  producer_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& ModelProto::producer_name() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
-  return _internal_producer_name();
-}
-inline void ModelProto::set_producer_name(const std::string& value) {
-  _internal_set_producer_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::mutable_producer_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
-  return _internal_mutable_producer_name();
-}
-inline const std::string& ModelProto::_internal_producer_name() const {
-  return producer_name_.Get();
-}
-inline void ModelProto::_internal_set_producer_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_producer_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  producer_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.producer_name)
-}
-inline void ModelProto::set_producer_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.producer_name)
-}
-inline void ModelProto::set_producer_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::_internal_mutable_producer_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return producer_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_producer_name() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
-  if (!_internal_has_producer_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return producer_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_producer_name(std::string* producer_name) {
-  if (producer_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  producer_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::unsafe_arena_release_producer_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.producer_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return producer_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_producer_name(
-    std::string* producer_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (producer_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  producer_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      producer_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.producer_name)
-}
-
-// optional string producer_version = 3;
-inline bool ModelProto::_internal_has_producer_version() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool ModelProto::has_producer_version() const {
-  return _internal_has_producer_version();
-}
-inline void ModelProto::clear_producer_version() {
-  producer_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& ModelProto::producer_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
-  return _internal_producer_version();
-}
-inline void ModelProto::set_producer_version(const std::string& value) {
-  _internal_set_producer_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::mutable_producer_version() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
-  return _internal_mutable_producer_version();
-}
-inline const std::string& ModelProto::_internal_producer_version() const {
-  return producer_version_.Get();
-}
-inline void ModelProto::_internal_set_producer_version(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_producer_version(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  producer_version_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.producer_version)
-}
-inline void ModelProto::set_producer_version(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.producer_version)
-}
-inline void ModelProto::set_producer_version(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::_internal_mutable_producer_version() {
-  _has_bits_[0] |= 0x00000002u;
-  return producer_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_producer_version() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
-  if (!_internal_has_producer_version()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return producer_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_producer_version(std::string* producer_version) {
-  if (producer_version != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  producer_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_version,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::unsafe_arena_release_producer_version() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.producer_version)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return producer_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_producer_version(
-    std::string* producer_version) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (producer_version != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  producer_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      producer_version, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.producer_version)
-}
-
-// optional string domain = 4;
-inline bool ModelProto::_internal_has_domain() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool ModelProto::has_domain() const {
-  return _internal_has_domain();
-}
-inline void ModelProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& ModelProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
-  return _internal_domain();
-}
-inline void ModelProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& ModelProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void ModelProto::_internal_set_domain(const std::string& value) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_domain(std::string&& value) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.domain)
-}
-inline void ModelProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.domain)
-}
-inline void ModelProto::set_domain(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::_internal_mutable_domain() {
-  _has_bits_[0] |= 0x00000004u;
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
-  if (!_internal_has_domain()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000004u;
-  return domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000004u;
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.domain)
-}
-
-// optional int64 model_version = 5;
-inline bool ModelProto::_internal_has_model_version() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
-  return value;
-}
-inline bool ModelProto::has_model_version() const {
-  return _internal_has_model_version();
-}
-inline void ModelProto::clear_model_version() {
-  model_version_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::_internal_model_version() const {
-  return model_version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::model_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
-  return _internal_model_version();
-}
-inline void ModelProto::_internal_set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000040u;
-  model_version_ = value;
-}
-inline void ModelProto::set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_model_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
-}
-
-// optional string doc_string = 6;
-inline bool ModelProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool ModelProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void ModelProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& ModelProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
-  return _internal_doc_string();
-}
-inline void ModelProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& ModelProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void ModelProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000008u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000008u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.doc_string)
-}
-inline void ModelProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000008u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.doc_string)
-}
-inline void ModelProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000008u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000008u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000008u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000008u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.doc_string)
-}
-
-// optional .onnx.GraphProto graph = 7;
-inline bool ModelProto::_internal_has_graph() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
-  PROTOBUF_ASSUME(!value || graph_ != nullptr);
-  return value;
-}
-inline bool ModelProto::has_graph() const {
-  return _internal_has_graph();
-}
-inline void ModelProto::clear_graph() {
-  if (graph_ != nullptr) graph_->Clear();
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
-  const ::onnx::GraphProto* p = graph_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& ModelProto::graph() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
-  return _internal_graph();
-}
-inline void ModelProto::unsafe_arena_set_allocated_graph(
-    ::onnx::GraphProto* graph) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_);
-  }
-  graph_ = graph;
-  if (graph) {
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
-}
-inline ::onnx::GraphProto* ModelProto::release_graph() {
-  auto temp = unsafe_arena_release_graph();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)
-  _has_bits_[0] &= ~0x00000010u;
-  ::onnx::GraphProto* temp = graph_;
-  graph_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* ModelProto::_internal_mutable_graph() {
-  _has_bits_[0] |= 0x00000010u;
-  if (graph_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    graph_ = p;
-  }
-  return graph_;
-}
-inline ::onnx::GraphProto* ModelProto::mutable_graph() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
-  return _internal_mutable_graph();
-}
-inline void ModelProto::set_allocated_graph(::onnx::GraphProto* graph) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete graph_;
-  }
-  if (graph) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(graph);
-    if (message_arena != submessage_arena) {
-      graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, graph, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000010u;
-  } else {
-    _has_bits_[0] &= ~0x00000010u;
-  }
-  graph_ = graph;
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 14;
-inline int ModelProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int ModelProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void ModelProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-ModelProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& ModelProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* ModelProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-ModelProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
-  return metadata_props_;
-}
-
-// repeated .onnx.TrainingInfoProto training_info = 20;
-inline int ModelProto::_internal_training_info_size() const {
-  return training_info_.size();
-}
-inline int ModelProto::training_info_size() const {
-  return _internal_training_info_size();
-}
-inline void ModelProto::clear_training_info() {
-  training_info_.Clear();
-}
-inline ::onnx::TrainingInfoProto* ModelProto::mutable_training_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
-  return training_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >*
-ModelProto::mutable_training_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
-  return &training_info_;
-}
-inline const ::onnx::TrainingInfoProto& ModelProto::_internal_training_info(int index) const {
-  return training_info_.Get(index);
-}
-inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
-  return _internal_training_info(index);
-}
-inline ::onnx::TrainingInfoProto* ModelProto::_internal_add_training_info() {
-  return training_info_.Add();
-}
-inline ::onnx::TrainingInfoProto* ModelProto::add_training_info() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
-  return _internal_add_training_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >&
-ModelProto::training_info() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
-  return training_info_;
-}
-
-// repeated .onnx.FunctionProto functions = 25;
-inline int ModelProto::_internal_functions_size() const {
-  return functions_.size();
-}
-inline int ModelProto::functions_size() const {
-  return _internal_functions_size();
-}
-inline void ModelProto::clear_functions() {
-  functions_.Clear();
-}
-inline ::onnx::FunctionProto* ModelProto::mutable_functions(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
-  return functions_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >*
-ModelProto::mutable_functions() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
-  return &functions_;
-}
-inline const ::onnx::FunctionProto& ModelProto::_internal_functions(int index) const {
-  return functions_.Get(index);
-}
-inline const ::onnx::FunctionProto& ModelProto::functions(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
-  return _internal_functions(index);
-}
-inline ::onnx::FunctionProto* ModelProto::_internal_add_functions() {
-  return functions_.Add();
-}
-inline ::onnx::FunctionProto* ModelProto::add_functions() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
-  return _internal_add_functions();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >&
-ModelProto::functions() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
-  return functions_;
-}
-
-// repeated .onnx.DeviceConfigurationProto configuration = 26;
-inline int ModelProto::_internal_configuration_size() const {
-  return configuration_.size();
-}
-inline int ModelProto::configuration_size() const {
-  return _internal_configuration_size();
-}
-inline void ModelProto::clear_configuration() {
-  configuration_.Clear();
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::mutable_configuration(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.configuration)
-  return configuration_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >*
-ModelProto::mutable_configuration() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.configuration)
-  return &configuration_;
-}
-inline const ::onnx::DeviceConfigurationProto& ModelProto::_internal_configuration(int index) const {
-  return configuration_.Get(index);
-}
-inline const ::onnx::DeviceConfigurationProto& ModelProto::configuration(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.configuration)
-  return _internal_configuration(index);
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::_internal_add_configuration() {
-  return configuration_.Add();
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::add_configuration() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.configuration)
-  return _internal_add_configuration();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >&
-ModelProto::configuration() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.configuration)
-  return configuration_;
-}
-
-// -------------------------------------------------------------------
-
-// DeviceConfigurationProto
-
-// optional string name = 1;
-inline bool DeviceConfigurationProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool DeviceConfigurationProto::has_name() const {
-  return _internal_has_name();
-}
-inline void DeviceConfigurationProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& DeviceConfigurationProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.name)
-  return _internal_name();
-}
-inline void DeviceConfigurationProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& DeviceConfigurationProto::_internal_name() const {
-  return name_.Get();
-}
-inline void DeviceConfigurationProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void DeviceConfigurationProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.DeviceConfigurationProto.name)
-}
-inline void DeviceConfigurationProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.DeviceConfigurationProto.name)
-}
-inline void DeviceConfigurationProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* DeviceConfigurationProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.DeviceConfigurationProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void DeviceConfigurationProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.DeviceConfigurationProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void DeviceConfigurationProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.DeviceConfigurationProto.name)
-}
-
-// optional int32 num_devices = 2;
-inline bool DeviceConfigurationProto::_internal_has_num_devices() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool DeviceConfigurationProto::has_num_devices() const {
-  return _internal_has_num_devices();
-}
-inline void DeviceConfigurationProto::clear_num_devices() {
-  num_devices_ = 0;
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceConfigurationProto::_internal_num_devices() const {
-  return num_devices_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceConfigurationProto::num_devices() const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.num_devices)
-  return _internal_num_devices();
-}
-inline void DeviceConfigurationProto::_internal_set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000002u;
-  num_devices_ = value;
-}
-inline void DeviceConfigurationProto::set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_num_devices(value);
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.num_devices)
-}
-
-// repeated string device = 3;
-inline int DeviceConfigurationProto::_internal_device_size() const {
-  return device_.size();
-}
-inline int DeviceConfigurationProto::device_size() const {
-  return _internal_device_size();
-}
-inline void DeviceConfigurationProto::clear_device() {
-  device_.Clear();
-}
-inline std::string* DeviceConfigurationProto::add_device() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.DeviceConfigurationProto.device)
-  return _internal_add_device();
-}
-inline const std::string& DeviceConfigurationProto::_internal_device(int index) const {
-  return device_.Get(index);
-}
-inline const std::string& DeviceConfigurationProto::device(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.device)
-  return _internal_device(index);
-}
-inline std::string* DeviceConfigurationProto::mutable_device(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.device)
-  return device_.Mutable(index);
-}
-inline void DeviceConfigurationProto::set_device(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.device)
-  device_.Mutable(index)->assign(value);
-}
-inline void DeviceConfigurationProto::set_device(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.device)
-  device_.Mutable(index)->assign(std::move(value));
-}
-inline void DeviceConfigurationProto::set_device(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  device_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::set_device(int index, const char* value, size_t size) {
-  device_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.DeviceConfigurationProto.device)
-}
-inline std::string* DeviceConfigurationProto::_internal_add_device() {
-  return device_.Add();
-}
-inline void DeviceConfigurationProto::add_device(const std::string& value) {
-  device_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(std::string&& value) {
-  device_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  device_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(const char* value, size_t size) {
-  device_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.DeviceConfigurationProto.device)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-DeviceConfigurationProto::device() const {
-  // @@protoc_insertion_point(field_list:onnx.DeviceConfigurationProto.device)
-  return device_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-DeviceConfigurationProto::mutable_device() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.DeviceConfigurationProto.device)
-  return &device_;
-}
-
-// -------------------------------------------------------------------
-
-// StringStringEntryProto
-
-// optional string key = 1;
-inline bool StringStringEntryProto::_internal_has_key() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool StringStringEntryProto::has_key() const {
-  return _internal_has_key();
-}
-inline void StringStringEntryProto::clear_key() {
-  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& StringStringEntryProto::key() const {
-  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
-  return _internal_key();
-}
-inline void StringStringEntryProto::set_key(const std::string& value) {
-  _internal_set_key(value);
-  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::mutable_key() {
-  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
-  return _internal_mutable_key();
-}
-inline const std::string& StringStringEntryProto::_internal_key() const {
-  return key_.Get();
-}
-inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void StringStringEntryProto::set_key(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  key_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.StringStringEntryProto.key)
-}
-inline void StringStringEntryProto::set_key(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.StringStringEntryProto.key)
-}
-inline void StringStringEntryProto::set_key(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::_internal_mutable_key() {
-  _has_bits_[0] |= 0x00000001u;
-  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* StringStringEntryProto::release_key() {
-  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
-  if (!_internal_has_key()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void StringStringEntryProto::set_allocated_key(std::string* key) {
-  if (key != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::unsafe_arena_release_key() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.StringStringEntryProto.key)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return key_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void StringStringEntryProto::unsafe_arena_set_allocated_key(
-    std::string* key) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (key != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  key_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      key, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.StringStringEntryProto.key)
-}
-
-// optional string value = 2;
-inline bool StringStringEntryProto::_internal_has_value() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool StringStringEntryProto::has_value() const {
-  return _internal_has_value();
-}
-inline void StringStringEntryProto::clear_value() {
-  value_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& StringStringEntryProto::value() const {
-  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
-  return _internal_value();
-}
-inline void StringStringEntryProto::set_value(const std::string& value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::mutable_value() {
-  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
-  return _internal_mutable_value();
-}
-inline const std::string& StringStringEntryProto::_internal_value() const {
-  return value_.Get();
-}
-inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void StringStringEntryProto::set_value(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  value_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.StringStringEntryProto.value)
-}
-inline void StringStringEntryProto::set_value(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.StringStringEntryProto.value)
-}
-inline void StringStringEntryProto::set_value(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::_internal_mutable_value() {
-  _has_bits_[0] |= 0x00000002u;
-  return value_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* StringStringEntryProto::release_value() {
-  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
-  if (!_internal_has_value()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void StringStringEntryProto::set_allocated_value(std::string* value) {
-  if (value != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::unsafe_arena_release_value() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.StringStringEntryProto.value)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return value_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void StringStringEntryProto::unsafe_arena_set_allocated_value(
-    std::string* value) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (value != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  value_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      value, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.StringStringEntryProto.value)
-}
-
-// -------------------------------------------------------------------
-
-// TensorAnnotation
-
-// optional string tensor_name = 1;
-inline bool TensorAnnotation::_internal_has_tensor_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool TensorAnnotation::has_tensor_name() const {
-  return _internal_has_tensor_name();
-}
-inline void TensorAnnotation::clear_tensor_name() {
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& TensorAnnotation::tensor_name() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
-  return _internal_tensor_name();
-}
-inline void TensorAnnotation::set_tensor_name(const std::string& value) {
-  _internal_set_tensor_name(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::mutable_tensor_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
-  return _internal_mutable_tensor_name();
-}
-inline const std::string& TensorAnnotation::_internal_tensor_name() const {
-  return tensor_name_.Get();
-}
-inline void TensorAnnotation::_internal_set_tensor_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorAnnotation::set_tensor_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorAnnotation.tensor_name)
-}
-inline void TensorAnnotation::set_tensor_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorAnnotation.tensor_name)
-}
-inline void TensorAnnotation::set_tensor_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::_internal_mutable_tensor_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return tensor_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorAnnotation::release_tensor_name() {
-  // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
-  if (!_internal_has_tensor_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return tensor_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorAnnotation::set_allocated_tensor_name(std::string* tensor_name) {
-  if (tensor_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::unsafe_arena_release_tensor_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorAnnotation.tensor_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return tensor_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorAnnotation::unsafe_arena_set_allocated_tensor_name(
-    std::string* tensor_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (tensor_name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  tensor_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      tensor_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorAnnotation.tensor_name)
-}
-
-// repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
-  return quant_parameter_tensor_names_.size();
-}
-inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
-  return _internal_quant_parameter_tensor_names_size();
-}
-inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
-  quant_parameter_tensor_names_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return quant_parameter_tensor_names_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorAnnotation::mutable_quant_parameter_tensor_names() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return &quant_parameter_tensor_names_;
-}
-inline const ::onnx::StringStringEntryProto& TensorAnnotation::_internal_quant_parameter_tensor_names(int index) const {
-  return quant_parameter_tensor_names_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return _internal_quant_parameter_tensor_names(index);
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::_internal_add_quant_parameter_tensor_names() {
-  return quant_parameter_tensor_names_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() {
-  // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return _internal_add_quant_parameter_tensor_names();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorAnnotation::quant_parameter_tensor_names() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return quant_parameter_tensor_names_;
-}
-
-// -------------------------------------------------------------------
-
-// GraphProto
-
-// repeated .onnx.NodeProto node = 1;
-inline int GraphProto::_internal_node_size() const {
-  return node_.size();
-}
-inline int GraphProto::node_size() const {
-  return _internal_node_size();
-}
-inline void GraphProto::clear_node() {
-  node_.Clear();
-}
-inline ::onnx::NodeProto* GraphProto::mutable_node(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
-  return node_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-GraphProto::mutable_node() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
-  return &node_;
-}
-inline const ::onnx::NodeProto& GraphProto::_internal_node(int index) const {
-  return node_.Get(index);
-}
-inline const ::onnx::NodeProto& GraphProto::node(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
-  return _internal_node(index);
-}
-inline ::onnx::NodeProto* GraphProto::_internal_add_node() {
-  return node_.Add();
-}
-inline ::onnx::NodeProto* GraphProto::add_node() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
-  return _internal_add_node();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-GraphProto::node() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
-  return node_;
-}
-
-// optional string name = 2;
-inline bool GraphProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool GraphProto::has_name() const {
-  return _internal_has_name();
-}
-inline void GraphProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& GraphProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
-  return _internal_name();
-}
-inline void GraphProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& GraphProto::_internal_name() const {
-  return name_.Get();
-}
-inline void GraphProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void GraphProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.GraphProto.name)
-}
-inline void GraphProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.GraphProto.name)
-}
-inline void GraphProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* GraphProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GraphProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.GraphProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void GraphProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.GraphProto.name)
-}
-
-// repeated .onnx.TensorProto initializer = 5;
-inline int GraphProto::_internal_initializer_size() const {
-  return initializer_.size();
-}
-inline int GraphProto::initializer_size() const {
-  return _internal_initializer_size();
-}
-inline void GraphProto::clear_initializer() {
-  initializer_.Clear();
-}
-inline ::onnx::TensorProto* GraphProto::mutable_initializer(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
-  return initializer_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-GraphProto::mutable_initializer() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
-  return &initializer_;
-}
-inline const ::onnx::TensorProto& GraphProto::_internal_initializer(int index) const {
-  return initializer_.Get(index);
-}
-inline const ::onnx::TensorProto& GraphProto::initializer(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
-  return _internal_initializer(index);
-}
-inline ::onnx::TensorProto* GraphProto::_internal_add_initializer() {
-  return initializer_.Add();
-}
-inline ::onnx::TensorProto* GraphProto::add_initializer() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
-  return _internal_add_initializer();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-GraphProto::initializer() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
-  return initializer_;
-}
-
-// repeated .onnx.SparseTensorProto sparse_initializer = 15;
-inline int GraphProto::_internal_sparse_initializer_size() const {
-  return sparse_initializer_.size();
-}
-inline int GraphProto::sparse_initializer_size() const {
-  return _internal_sparse_initializer_size();
-}
-inline void GraphProto::clear_sparse_initializer() {
-  sparse_initializer_.Clear();
-}
-inline ::onnx::SparseTensorProto* GraphProto::mutable_sparse_initializer(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
-  return sparse_initializer_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-GraphProto::mutable_sparse_initializer() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
-  return &sparse_initializer_;
-}
-inline const ::onnx::SparseTensorProto& GraphProto::_internal_sparse_initializer(int index) const {
-  return sparse_initializer_.Get(index);
-}
-inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
-  return _internal_sparse_initializer(index);
-}
-inline ::onnx::SparseTensorProto* GraphProto::_internal_add_sparse_initializer() {
-  return sparse_initializer_.Add();
-}
-inline ::onnx::SparseTensorProto* GraphProto::add_sparse_initializer() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
-  return _internal_add_sparse_initializer();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-GraphProto::sparse_initializer() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
-  return sparse_initializer_;
-}
-
-// optional string doc_string = 10;
-inline bool GraphProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool GraphProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void GraphProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& GraphProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
-  return _internal_doc_string();
-}
-inline void GraphProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& GraphProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void GraphProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void GraphProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.GraphProto.doc_string)
-}
-inline void GraphProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.GraphProto.doc_string)
-}
-inline void GraphProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000002u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* GraphProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GraphProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.GraphProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void GraphProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.GraphProto.doc_string)
-}
-
-// repeated .onnx.ValueInfoProto input = 11;
-inline int GraphProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int GraphProto::input_size() const {
-  return _internal_input_size();
-}
-inline void GraphProto::clear_input() {
-  input_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
-  return input_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
-  return &input_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
-  return _internal_input(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_input() {
-  return input_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_input() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
-  return _internal_add_input();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
-  return input_;
-}
-
-// repeated .onnx.ValueInfoProto output = 12;
-inline int GraphProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int GraphProto::output_size() const {
-  return _internal_output_size();
-}
-inline void GraphProto::clear_output() {
-  output_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
-  return output_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
-  return &output_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
-  return _internal_output(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_output() {
-  return output_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_output() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
-  return _internal_add_output();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
-  return output_;
-}
-
-// repeated .onnx.ValueInfoProto value_info = 13;
-inline int GraphProto::_internal_value_info_size() const {
-  return value_info_.size();
-}
-inline int GraphProto::value_info_size() const {
-  return _internal_value_info_size();
-}
-inline void GraphProto::clear_value_info() {
-  value_info_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
-  return value_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_value_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
-  return &value_info_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_value_info(int index) const {
-  return value_info_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
-  return _internal_value_info(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_value_info() {
-  return value_info_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_value_info() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
-  return _internal_add_value_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::value_info() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
-  return value_info_;
-}
-
-// repeated .onnx.TensorAnnotation quantization_annotation = 14;
-inline int GraphProto::_internal_quantization_annotation_size() const {
-  return quantization_annotation_.size();
-}
-inline int GraphProto::quantization_annotation_size() const {
-  return _internal_quantization_annotation_size();
-}
-inline void GraphProto::clear_quantization_annotation() {
-  quantization_annotation_.Clear();
-}
-inline ::onnx::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
-  return quantization_annotation_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >*
-GraphProto::mutable_quantization_annotation() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
-  return &quantization_annotation_;
-}
-inline const ::onnx::TensorAnnotation& GraphProto::_internal_quantization_annotation(int index) const {
-  return quantization_annotation_.Get(index);
-}
-inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
-  return _internal_quantization_annotation(index);
-}
-inline ::onnx::TensorAnnotation* GraphProto::_internal_add_quantization_annotation() {
-  return quantization_annotation_.Add();
-}
-inline ::onnx::TensorAnnotation* GraphProto::add_quantization_annotation() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
-  return _internal_add_quantization_annotation();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >&
-GraphProto::quantization_annotation() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
-  return quantization_annotation_;
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 16;
-inline int GraphProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int GraphProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void GraphProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* GraphProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-GraphProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& GraphProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* GraphProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* GraphProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-GraphProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// TensorProto_Segment
-
-// optional int64 begin = 1;
-inline bool TensorProto_Segment::_internal_has_begin() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool TensorProto_Segment::has_begin() const {
-  return _internal_has_begin();
-}
-inline void TensorProto_Segment::clear_begin() {
-  begin_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_begin() const {
-  return begin_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::begin() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
-  return _internal_begin();
-}
-inline void TensorProto_Segment::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000001u;
-  begin_ = value;
-}
-inline void TensorProto_Segment::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_begin(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
-}
-
-// optional int64 end = 2;
-inline bool TensorProto_Segment::_internal_has_end() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool TensorProto_Segment::has_end() const {
-  return _internal_has_end();
-}
-inline void TensorProto_Segment::clear_end() {
-  end_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_end() const {
-  return end_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::end() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
-  return _internal_end();
-}
-inline void TensorProto_Segment::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000002u;
-  end_ = value;
-}
-inline void TensorProto_Segment::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
-}
-
-// -------------------------------------------------------------------
-
-// TensorProto
-
-// repeated int64 dims = 1;
-inline int TensorProto::_internal_dims_size() const {
-  return dims_.size();
-}
-inline int TensorProto::dims_size() const {
-  return _internal_dims_size();
-}
-inline void TensorProto::clear_dims() {
-  dims_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_dims(int index) const {
-  return dims_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::dims(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
-  return _internal_dims(index);
-}
-inline void TensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
-}
-inline void TensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Add(value);
-}
-inline void TensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_dims(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::_internal_dims() const {
-  return dims_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::dims() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
-  return _internal_dims();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::_internal_mutable_dims() {
-  return &dims_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::mutable_dims() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
-  return _internal_mutable_dims();
-}
-
-// optional int32 data_type = 2;
-inline bool TensorProto::_internal_has_data_type() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool TensorProto::has_data_type() const {
-  return _internal_has_data_type();
-}
-inline void TensorProto::clear_data_type() {
-  data_type_ = 0;
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_data_type() const {
-  return data_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::data_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
-  return _internal_data_type();
-}
-inline void TensorProto::_internal_set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000010u;
-  data_type_ = value;
-}
-inline void TensorProto::set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_data_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
-}
-
-// optional .onnx.TensorProto.Segment segment = 3;
-inline bool TensorProto::_internal_has_segment() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
-  PROTOBUF_ASSUME(!value || segment_ != nullptr);
-  return value;
-}
-inline bool TensorProto::has_segment() const {
-  return _internal_has_segment();
-}
-inline void TensorProto::clear_segment() {
-  if (segment_ != nullptr) segment_->Clear();
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
-  const ::onnx::TensorProto_Segment* p = segment_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto_Segment*>(
-      &::onnx::_TensorProto_Segment_default_instance_);
-}
-inline const ::onnx::TensorProto_Segment& TensorProto::segment() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
-  return _internal_segment();
-}
-inline void TensorProto::unsafe_arena_set_allocated_segment(
-    ::onnx::TensorProto_Segment* segment) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
-  }
-  segment_ = segment;
-  if (segment) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
-}
-inline ::onnx::TensorProto_Segment* TensorProto::release_segment() {
-  auto temp = unsafe_arena_release_segment();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)
-  _has_bits_[0] &= ~0x00000008u;
-  ::onnx::TensorProto_Segment* temp = segment_;
-  segment_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
-  _has_bits_[0] |= 0x00000008u;
-  if (segment_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto_Segment>(GetArena());
-    segment_ = p;
-  }
-  return segment_;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::mutable_segment() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
-  return _internal_mutable_segment();
-}
-inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* segment) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete segment_;
-  }
-  if (segment) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(segment);
-    if (message_arena != submessage_arena) {
-      segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, segment, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  segment_ = segment;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
-}
-
-// repeated float float_data = 4 [packed = true];
-inline int TensorProto::_internal_float_data_size() const {
-  return float_data_.size();
-}
-inline int TensorProto::float_data_size() const {
-  return _internal_float_data_size();
-}
-inline void TensorProto::clear_float_data() {
-  float_data_.Clear();
-}
-inline float TensorProto::_internal_float_data(int index) const {
-  return float_data_.Get(index);
-}
-inline float TensorProto::float_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
-  return _internal_float_data(index);
-}
-inline void TensorProto::set_float_data(int index, float value) {
-  float_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
-}
-inline void TensorProto::_internal_add_float_data(float value) {
-  float_data_.Add(value);
-}
-inline void TensorProto::add_float_data(float value) {
-  _internal_add_float_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-TensorProto::_internal_float_data() const {
-  return float_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-TensorProto::float_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
-  return _internal_float_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-TensorProto::_internal_mutable_float_data() {
-  return &float_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-TensorProto::mutable_float_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
-  return _internal_mutable_float_data();
-}
-
-// repeated int32 int32_data = 5 [packed = true];
-inline int TensorProto::_internal_int32_data_size() const {
-  return int32_data_.size();
-}
-inline int TensorProto::int32_data_size() const {
-  return _internal_int32_data_size();
-}
-inline void TensorProto::clear_int32_data() {
-  int32_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_int32_data(int index) const {
-  return int32_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::int32_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
-  return _internal_int32_data(index);
-}
-inline void TensorProto::set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
-  int32_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
-}
-inline void TensorProto::_internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  int32_data_.Add(value);
-}
-inline void TensorProto::add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_add_int32_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-TensorProto::_internal_int32_data() const {
-  return int32_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-TensorProto::int32_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
-  return _internal_int32_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-TensorProto::_internal_mutable_int32_data() {
-  return &int32_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-TensorProto::mutable_int32_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
-  return _internal_mutable_int32_data();
-}
-
-// repeated bytes string_data = 6;
-inline int TensorProto::_internal_string_data_size() const {
-  return string_data_.size();
-}
-inline int TensorProto::string_data_size() const {
-  return _internal_string_data_size();
-}
-inline void TensorProto::clear_string_data() {
-  string_data_.Clear();
-}
-inline std::string* TensorProto::add_string_data() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
-  return _internal_add_string_data();
-}
-inline const std::string& TensorProto::_internal_string_data(int index) const {
-  return string_data_.Get(index);
-}
-inline const std::string& TensorProto::string_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
-  return _internal_string_data(index);
-}
-inline std::string* TensorProto::mutable_string_data(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
-  return string_data_.Mutable(index);
-}
-inline void TensorProto::set_string_data(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
-  string_data_.Mutable(index)->assign(value);
-}
-inline void TensorProto::set_string_data(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
-  string_data_.Mutable(index)->assign(std::move(value));
-}
-inline void TensorProto::set_string_data(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  string_data_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.string_data)
-}
-inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
-  string_data_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.string_data)
-}
-inline std::string* TensorProto::_internal_add_string_data() {
-  return string_data_.Add();
-}
-inline void TensorProto::add_string_data(const std::string& value) {
-  string_data_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(std::string&& value) {
-  string_data_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  string_data_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(const void* value, size_t size) {
-  string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.TensorProto.string_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-TensorProto::string_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
-  return string_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-TensorProto::mutable_string_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
-  return &string_data_;
-}
-
-// repeated int64 int64_data = 7 [packed = true];
-inline int TensorProto::_internal_int64_data_size() const {
-  return int64_data_.size();
-}
-inline int TensorProto::int64_data_size() const {
-  return _internal_int64_data_size();
-}
-inline void TensorProto::clear_int64_data() {
-  int64_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_int64_data(int index) const {
-  return int64_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::int64_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
-  return _internal_int64_data(index);
-}
-inline void TensorProto::set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  int64_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
-}
-inline void TensorProto::_internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  int64_data_.Add(value);
-}
-inline void TensorProto::add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_int64_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::_internal_int64_data() const {
-  return int64_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::int64_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
-  return _internal_int64_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::_internal_mutable_int64_data() {
-  return &int64_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::mutable_int64_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
-  return _internal_mutable_int64_data();
-}
-
-// optional string name = 8;
-inline bool TensorProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool TensorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void TensorProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& TensorProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
-  return _internal_name();
-}
-inline void TensorProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& TensorProto::_internal_name() const {
-  return name_.Get();
-}
-inline void TensorProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.name)
-}
-inline void TensorProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.name)
-}
-inline void TensorProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.name)
-}
-
-// optional string doc_string = 12;
-inline bool TensorProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool TensorProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void TensorProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& TensorProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
-  return _internal_doc_string();
-}
-inline void TensorProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& TensorProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void TensorProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.doc_string)
-}
-inline void TensorProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.doc_string)
-}
-inline void TensorProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000004u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000004u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000004u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.doc_string)
-}
-
-// optional bytes raw_data = 9;
-inline bool TensorProto::_internal_has_raw_data() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool TensorProto::has_raw_data() const {
-  return _internal_has_raw_data();
-}
-inline void TensorProto::clear_raw_data() {
-  raw_data_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& TensorProto::raw_data() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
-  return _internal_raw_data();
-}
-inline void TensorProto::set_raw_data(const std::string& value) {
-  _internal_set_raw_data(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::mutable_raw_data() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
-  return _internal_mutable_raw_data();
-}
-inline const std::string& TensorProto::_internal_raw_data() const {
-  return raw_data_.Get();
-}
-inline void TensorProto::_internal_set_raw_data(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_raw_data(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  raw_data_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.raw_data)
-}
-inline void TensorProto::set_raw_data(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.raw_data)
-}
-inline void TensorProto::set_raw_data(const void* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::_internal_mutable_raw_data() {
-  _has_bits_[0] |= 0x00000002u;
-  return raw_data_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_raw_data() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
-  if (!_internal_has_raw_data()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return raw_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
-  if (raw_data != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  raw_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_data,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::unsafe_arena_release_raw_data() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.raw_data)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return raw_data_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_raw_data(
-    std::string* raw_data) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (raw_data != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  raw_data_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      raw_data, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.raw_data)
-}
-
-// repeated .onnx.StringStringEntryProto external_data = 13;
-inline int TensorProto::_internal_external_data_size() const {
-  return external_data_.size();
-}
-inline int TensorProto::external_data_size() const {
-  return _internal_external_data_size();
-}
-inline void TensorProto::clear_external_data() {
-  external_data_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::mutable_external_data(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
-  return external_data_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorProto::mutable_external_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
-  return &external_data_;
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::_internal_external_data(int index) const {
-  return external_data_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
-  return _internal_external_data(index);
-}
-inline ::onnx::StringStringEntryProto* TensorProto::_internal_add_external_data() {
-  return external_data_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::add_external_data() {
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
-  return _internal_add_external_data();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorProto::external_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
-  return external_data_;
-}
-
-// optional .onnx.TensorProto.DataLocation data_location = 14;
-inline bool TensorProto::_internal_has_data_location() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool TensorProto::has_data_location() const {
-  return _internal_has_data_location();
-}
-inline void TensorProto::clear_data_location() {
-  data_location_ = 0;
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
-  return static_cast< ::onnx::TensorProto_DataLocation >(data_location_);
-}
-inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
-  return _internal_data_location();
-}
-inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
-  assert(::onnx::TensorProto_DataLocation_IsValid(value));
-  _has_bits_[0] |= 0x00000020u;
-  data_location_ = value;
-}
-inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
-  _internal_set_data_location(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
-}
-
-// repeated double double_data = 10 [packed = true];
-inline int TensorProto::_internal_double_data_size() const {
-  return double_data_.size();
-}
-inline int TensorProto::double_data_size() const {
-  return _internal_double_data_size();
-}
-inline void TensorProto::clear_double_data() {
-  double_data_.Clear();
-}
-inline double TensorProto::_internal_double_data(int index) const {
-  return double_data_.Get(index);
-}
-inline double TensorProto::double_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
-  return _internal_double_data(index);
-}
-inline void TensorProto::set_double_data(int index, double value) {
-  double_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
-}
-inline void TensorProto::_internal_add_double_data(double value) {
-  double_data_.Add(value);
-}
-inline void TensorProto::add_double_data(double value) {
-  _internal_add_double_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-TensorProto::_internal_double_data() const {
-  return double_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-TensorProto::double_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
-  return _internal_double_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-TensorProto::_internal_mutable_double_data() {
-  return &double_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-TensorProto::mutable_double_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
-  return _internal_mutable_double_data();
-}
-
-// repeated uint64 uint64_data = 11 [packed = true];
-inline int TensorProto::_internal_uint64_data_size() const {
-  return uint64_data_.size();
-}
-inline int TensorProto::uint64_data_size() const {
-  return _internal_uint64_data_size();
-}
-inline void TensorProto::clear_uint64_data() {
-  uint64_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::uint64 TensorProto::_internal_uint64_data(int index) const {
-  return uint64_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::uint64 TensorProto::uint64_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
-  return _internal_uint64_data(index);
-}
-inline void TensorProto::set_uint64_data(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  uint64_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
-}
-inline void TensorProto::_internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  uint64_data_.Add(value);
-}
-inline void TensorProto::add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  _internal_add_uint64_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-TensorProto::_internal_uint64_data() const {
-  return uint64_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-TensorProto::uint64_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
-  return _internal_uint64_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-TensorProto::_internal_mutable_uint64_data() {
-  return &uint64_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-TensorProto::mutable_uint64_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
-  return _internal_mutable_uint64_data();
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 16;
-inline int TensorProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int TensorProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void TensorProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* TensorProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// SparseTensorProto
-
-// optional .onnx.TensorProto values = 1;
-inline bool SparseTensorProto::_internal_has_values() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || values_ != nullptr);
-  return value;
-}
-inline bool SparseTensorProto::has_values() const {
-  return _internal_has_values();
-}
-inline void SparseTensorProto::clear_values() {
-  if (values_ != nullptr) values_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
-  const ::onnx::TensorProto* p = values_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& SparseTensorProto::values() const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
-  return _internal_values();
-}
-inline void SparseTensorProto::unsafe_arena_set_allocated_values(
-    ::onnx::TensorProto* values) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(values_);
-  }
-  values_ = values;
-  if (values) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
-}
-inline ::onnx::TensorProto* SparseTensorProto::release_values() {
-  auto temp = unsafe_arena_release_values();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_values() {
-  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TensorProto* temp = values_;
-  values_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_values() {
-  _has_bits_[0] |= 0x00000001u;
-  if (values_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    values_ = p;
-  }
-  return values_;
-}
-inline ::onnx::TensorProto* SparseTensorProto::mutable_values() {
-  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
-  return _internal_mutable_values();
-}
-inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* values) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete values_;
-  }
-  if (values) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(values);
-    if (message_arena != submessage_arena) {
-      values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, values, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  values_ = values;
-  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
-}
-
-// optional .onnx.TensorProto indices = 2;
-inline bool SparseTensorProto::_internal_has_indices() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || indices_ != nullptr);
-  return value;
-}
-inline bool SparseTensorProto::has_indices() const {
-  return _internal_has_indices();
-}
-inline void SparseTensorProto::clear_indices() {
-  if (indices_ != nullptr) indices_->Clear();
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
-  const ::onnx::TensorProto* p = indices_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& SparseTensorProto::indices() const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
-  return _internal_indices();
-}
-inline void SparseTensorProto::unsafe_arena_set_allocated_indices(
-    ::onnx::TensorProto* indices) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(indices_);
-  }
-  indices_ = indices;
-  if (indices) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
-}
-inline ::onnx::TensorProto* SparseTensorProto::release_indices() {
-  auto temp = unsafe_arena_release_indices();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_indices() {
-  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)
-  _has_bits_[0] &= ~0x00000002u;
-  ::onnx::TensorProto* temp = indices_;
-  indices_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_indices() {
-  _has_bits_[0] |= 0x00000002u;
-  if (indices_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    indices_ = p;
-  }
-  return indices_;
-}
-inline ::onnx::TensorProto* SparseTensorProto::mutable_indices() {
-  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
-  return _internal_mutable_indices();
-}
-inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* indices) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete indices_;
-  }
-  if (indices) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(indices);
-    if (message_arena != submessage_arena) {
-      indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, indices, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  indices_ = indices;
-  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
-}
-
-// repeated int64 dims = 3;
-inline int SparseTensorProto::_internal_dims_size() const {
-  return dims_.size();
-}
-inline int SparseTensorProto::dims_size() const {
-  return _internal_dims_size();
-}
-inline void SparseTensorProto::clear_dims() {
-  dims_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SparseTensorProto::_internal_dims(int index) const {
-  return dims_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SparseTensorProto::dims(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
-  return _internal_dims(index);
-}
-inline void SparseTensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
-}
-inline void SparseTensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Add(value);
-}
-inline void SparseTensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_dims(value);
-  // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-SparseTensorProto::_internal_dims() const {
-  return dims_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-SparseTensorProto::dims() const {
-  // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
-  return _internal_dims();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-SparseTensorProto::_internal_mutable_dims() {
-  return &dims_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-SparseTensorProto::mutable_dims() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
-  return _internal_mutable_dims();
-}
-
-// -------------------------------------------------------------------
-
-// TensorShapeProto_Dimension
-
-// int64 dim_value = 1;
-inline bool TensorShapeProto_Dimension::_internal_has_dim_value() const {
-  return value_case() == kDimValue;
-}
-inline bool TensorShapeProto_Dimension::has_dim_value() const {
-  return _internal_has_dim_value();
-}
-inline void TensorShapeProto_Dimension::set_has_dim_value() {
-  _oneof_case_[0] = kDimValue;
-}
-inline void TensorShapeProto_Dimension::clear_dim_value() {
-  if (_internal_has_dim_value()) {
-    value_.dim_value_ = PROTOBUF_LONGLONG(0);
-    clear_has_value();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShapeProto_Dimension::_internal_dim_value() const {
-  if (_internal_has_dim_value()) {
-    return value_.dim_value_;
-  }
-  return PROTOBUF_LONGLONG(0);
-}
-inline void TensorShapeProto_Dimension::_internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  if (!_internal_has_dim_value()) {
-    clear_value();
-    set_has_dim_value();
-  }
-  value_.dim_value_ = value;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShapeProto_Dimension::dim_value() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
-  return _internal_dim_value();
-}
-inline void TensorShapeProto_Dimension::set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_dim_value(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
-}
-
-// string dim_param = 2;
-inline bool TensorShapeProto_Dimension::_internal_has_dim_param() const {
-  return value_case() == kDimParam;
-}
-inline bool TensorShapeProto_Dimension::has_dim_param() const {
-  return _internal_has_dim_param();
-}
-inline void TensorShapeProto_Dimension::set_has_dim_param() {
-  _oneof_case_[0] = kDimParam;
-}
-inline void TensorShapeProto_Dimension::clear_dim_param() {
-  if (_internal_has_dim_param()) {
-    value_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-    clear_has_value();
-  }
-}
-inline const std::string& TensorShapeProto_Dimension::dim_param() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
-  return _internal_dim_param();
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const std::string& value) {
-  _internal_set_dim_param(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::mutable_dim_param() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
-  return _internal_mutable_dim_param();
-}
-inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
-  if (_internal_has_dim_param()) {
-    return value_.dim_param_.Get();
-  }
-  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorShapeProto_Dimension::set_dim_param(std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const char* value,
-                             size_t size) {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size),
-      GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  return value_.dim_param_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorShapeProto_Dimension::release_dim_param() {
-  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
-  if (_internal_has_dim_param()) {
-    clear_has_value();
-    return value_.dim_param_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* dim_param) {
-  if (has_value()) {
-    clear_value();
-  }
-  if (dim_param != nullptr) {
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(dim_param);
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::unsafe_arena_release_dim_param() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorShapeProto.Dimension.dim_param)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (_internal_has_dim_param()) {
-    clear_has_value();
-    return value_.dim_param_.UnsafeArenaRelease(
-        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void TensorShapeProto_Dimension::unsafe_arena_set_allocated_dim_param(std::string* dim_param) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (!_internal_has_dim_param()) {
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_value();
-  if (dim_param) {
-    set_has_dim_param();
-    value_.dim_param_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dim_param, GetArena());
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
-}
-
-// optional string denotation = 3;
-inline bool TensorShapeProto_Dimension::_internal_has_denotation() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool TensorShapeProto_Dimension::has_denotation() const {
-  return _internal_has_denotation();
-}
-inline void TensorShapeProto_Dimension::clear_denotation() {
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& TensorShapeProto_Dimension::denotation() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
-  return _internal_denotation();
-}
-inline void TensorShapeProto_Dimension::set_denotation(const std::string& value) {
-  _internal_set_denotation(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::mutable_denotation() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
-  return _internal_mutable_denotation();
-}
-inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
-  return denotation_.Get();
-}
-inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorShapeProto_Dimension::set_denotation(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline void TensorShapeProto_Dimension::set_denotation(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
-  _has_bits_[0] |= 0x00000001u;
-  return denotation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorShapeProto_Dimension::release_denotation() {
-  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
-  if (!_internal_has_denotation()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return denotation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* denotation) {
-  if (denotation != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::unsafe_arena_release_denotation() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorShapeProto.Dimension.denotation)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return denotation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorShapeProto_Dimension::unsafe_arena_set_allocated_denotation(
-    std::string* denotation) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (denotation != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  denotation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      denotation, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
-}
-
-inline bool TensorShapeProto_Dimension::has_value() const {
-  return value_case() != VALUE_NOT_SET;
-}
-inline void TensorShapeProto_Dimension::clear_has_value() {
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
-  return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// TensorShapeProto
-
-// repeated .onnx.TensorShapeProto.Dimension dim = 1;
-inline int TensorShapeProto::_internal_dim_size() const {
-  return dim_.size();
-}
-inline int TensorShapeProto::dim_size() const {
-  return _internal_dim_size();
-}
-inline void TensorShapeProto::clear_dim() {
-  dim_.Clear();
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
-  return dim_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >*
-TensorShapeProto::mutable_dim() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
-  return &dim_;
-}
-inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::_internal_dim(int index) const {
-  return dim_.Get(index);
-}
-inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
-  return _internal_dim(index);
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::_internal_add_dim() {
-  return dim_.Add();
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
-  // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
-  return _internal_add_dim();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >&
-TensorShapeProto::dim() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
-  return dim_;
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Tensor
-
-// optional int32 elem_type = 1;
-inline bool TypeProto_Tensor::_internal_has_elem_type() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool TypeProto_Tensor::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_Tensor::clear_elem_type() {
-  elem_type_ = 0;
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Tensor::_internal_elem_type() const {
-  return elem_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Tensor::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Tensor::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000002u;
-  elem_type_ = value;
-}
-inline void TypeProto_Tensor::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_elem_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
-}
-
-// optional .onnx.TensorShapeProto shape = 2;
-inline bool TypeProto_Tensor::_internal_has_shape() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || shape_ != nullptr);
-  return value;
-}
-inline bool TypeProto_Tensor::has_shape() const {
-  return _internal_has_shape();
-}
-inline void TypeProto_Tensor::clear_shape() {
-  if (shape_ != nullptr) shape_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
-  const ::onnx::TensorShapeProto* p = shape_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorShapeProto*>(
-      &::onnx::_TensorShapeProto_default_instance_);
-}
-inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
-  return _internal_shape();
-}
-inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
-    ::onnx::TensorShapeProto* shape) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
-  }
-  shape_ = shape;
-  if (shape) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
-  auto temp = unsafe_arena_release_shape();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TensorShapeProto* temp = shape_;
-  shape_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
-  _has_bits_[0] |= 0x00000001u;
-  if (shape_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorShapeProto>(GetArena());
-    shape_ = p;
-  }
-  return shape_;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
-  return _internal_mutable_shape();
-}
-inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* shape) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete shape_;
-  }
-  if (shape) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
-    if (message_arena != submessage_arena) {
-      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, shape, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  shape_ = shape;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Sequence
-
-// optional .onnx.TypeProto elem_type = 1;
-inline bool TypeProto_Sequence::_internal_has_elem_type() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || elem_type_ != nullptr);
-  return value;
-}
-inline bool TypeProto_Sequence::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_Sequence::clear_elem_type() {
-  if (elem_type_ != nullptr) elem_type_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
-  const ::onnx::TypeProto* p = elem_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(
-    ::onnx::TypeProto* elem_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
-  }
-  elem_type_ = elem_type;
-  if (elem_type) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::release_elem_type() {
-  auto temp = unsafe_arena_release_elem_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::unsafe_arena_release_elem_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TypeProto* temp = elem_type_;
-  elem_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::_internal_mutable_elem_type() {
-  _has_bits_[0] |= 0x00000001u;
-  if (elem_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    elem_type_ = p;
-  }
-  return elem_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::mutable_elem_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
-  return _internal_mutable_elem_type();
-}
-inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* elem_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete elem_type_;
-  }
-  if (elem_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(elem_type);
-    if (message_arena != submessage_arena) {
-      elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, elem_type, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  elem_type_ = elem_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Map
-
-// optional int32 key_type = 1;
-inline bool TypeProto_Map::_internal_has_key_type() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool TypeProto_Map::has_key_type() const {
-  return _internal_has_key_type();
-}
-inline void TypeProto_Map::clear_key_type() {
-  key_type_ = 0;
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Map::_internal_key_type() const {
-  return key_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Map::key_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
-  return _internal_key_type();
-}
-inline void TypeProto_Map::_internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000002u;
-  key_type_ = value;
-}
-inline void TypeProto_Map::set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_key_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
-}
-
-// optional .onnx.TypeProto value_type = 2;
-inline bool TypeProto_Map::_internal_has_value_type() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || value_type_ != nullptr);
-  return value;
-}
-inline bool TypeProto_Map::has_value_type() const {
-  return _internal_has_value_type();
-}
-inline void TypeProto_Map::clear_value_type() {
-  if (value_type_ != nullptr) value_type_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
-  const ::onnx::TypeProto* p = value_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Map::value_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
-  return _internal_value_type();
-}
-inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(
-    ::onnx::TypeProto* value_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_);
-  }
-  value_type_ = value_type;
-  if (value_type) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
-}
-inline ::onnx::TypeProto* TypeProto_Map::release_value_type() {
-  auto temp = unsafe_arena_release_value_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Map::unsafe_arena_release_value_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TypeProto* temp = value_type_;
-  value_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Map::_internal_mutable_value_type() {
-  _has_bits_[0] |= 0x00000001u;
-  if (value_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    value_type_ = p;
-  }
-  return value_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Map::mutable_value_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
-  return _internal_mutable_value_type();
-}
-inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* value_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete value_type_;
-  }
-  if (value_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value_type);
-    if (message_arena != submessage_arena) {
-      value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, value_type, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  value_type_ = value_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Optional
-
-// optional .onnx.TypeProto elem_type = 1;
-inline bool TypeProto_Optional::_internal_has_elem_type() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || elem_type_ != nullptr);
-  return value;
-}
-inline bool TypeProto_Optional::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_Optional::clear_elem_type() {
-  if (elem_type_ != nullptr) elem_type_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
-  const ::onnx::TypeProto* p = elem_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(
-    ::onnx::TypeProto* elem_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
-  }
-  elem_type_ = elem_type;
-  if (elem_type) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
-}
-inline ::onnx::TypeProto* TypeProto_Optional::release_elem_type() {
-  auto temp = unsafe_arena_release_elem_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::unsafe_arena_release_elem_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TypeProto* temp = elem_type_;
-  elem_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::_internal_mutable_elem_type() {
-  _has_bits_[0] |= 0x00000001u;
-  if (elem_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    elem_type_ = p;
-  }
-  return elem_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::mutable_elem_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
-  return _internal_mutable_elem_type();
-}
-inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* elem_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete elem_type_;
-  }
-  if (elem_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(elem_type);
-    if (message_arena != submessage_arena) {
-      elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, elem_type, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  elem_type_ = elem_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_SparseTensor
-
-// optional int32 elem_type = 1;
-inline bool TypeProto_SparseTensor::_internal_has_elem_type() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool TypeProto_SparseTensor::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_SparseTensor::clear_elem_type() {
-  elem_type_ = 0;
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_SparseTensor::_internal_elem_type() const {
-  return elem_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_SparseTensor::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_SparseTensor::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000002u;
-  elem_type_ = value;
-}
-inline void TypeProto_SparseTensor::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_elem_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
-}
-
-// optional .onnx.TensorShapeProto shape = 2;
-inline bool TypeProto_SparseTensor::_internal_has_shape() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || shape_ != nullptr);
-  return value;
-}
-inline bool TypeProto_SparseTensor::has_shape() const {
-  return _internal_has_shape();
-}
-inline void TypeProto_SparseTensor::clear_shape() {
-  if (shape_ != nullptr) shape_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
-  const ::onnx::TensorShapeProto* p = shape_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorShapeProto*>(
-      &::onnx::_TensorShapeProto_default_instance_);
-}
-inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
-  return _internal_shape();
-}
-inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(
-    ::onnx::TensorShapeProto* shape) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
-  }
-  shape_ = shape;
-  if (shape) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
-  auto temp = unsafe_arena_release_shape();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::unsafe_arena_release_shape() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)
-  _has_bits_[0] &= ~0x00000001u;
-  ::onnx::TensorShapeProto* temp = shape_;
-  shape_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::_internal_mutable_shape() {
-  _has_bits_[0] |= 0x00000001u;
-  if (shape_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorShapeProto>(GetArena());
-    shape_ = p;
-  }
-  return shape_;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
-  return _internal_mutable_shape();
-}
-inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* shape) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete shape_;
-  }
-  if (shape) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
-    if (message_arena != submessage_arena) {
-      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, shape, submessage_arena);
-    }
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  shape_ = shape;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto
-
-// .onnx.TypeProto.Tensor tensor_type = 1;
-inline bool TypeProto::_internal_has_tensor_type() const {
-  return value_case() == kTensorType;
-}
-inline bool TypeProto::has_tensor_type() const {
-  return _internal_has_tensor_type();
-}
-inline void TypeProto::set_has_tensor_type() {
-  _oneof_case_[0] = kTensorType;
-}
-inline void TypeProto::clear_tensor_type() {
-  if (_internal_has_tensor_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.tensor_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
-  if (_internal_has_tensor_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Tensor* temp = value_.tensor_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
-  return _internal_has_tensor_type()
-      ? *value_.tensor_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Tensor*>(&::onnx::_TypeProto_Tensor_default_instance_);
-}
-inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
-  return _internal_tensor_type();
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
-  if (_internal_has_tensor_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Tensor* temp = value_.tensor_type_;
-    value_.tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type) {
-  clear_value();
-  if (tensor_type) {
-    set_has_tensor_type();
-    value_.tensor_type_ = tensor_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
-  if (!_internal_has_tensor_type()) {
-    clear_value();
-    set_has_tensor_type();
-    value_.tensor_type_ = CreateMaybeMessage< ::onnx::TypeProto_Tensor >(GetArena());
-  }
-  return value_.tensor_type_;
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
-  return _internal_mutable_tensor_type();
-}
-
-// .onnx.TypeProto.Sequence sequence_type = 4;
-inline bool TypeProto::_internal_has_sequence_type() const {
-  return value_case() == kSequenceType;
-}
-inline bool TypeProto::has_sequence_type() const {
-  return _internal_has_sequence_type();
-}
-inline void TypeProto::set_has_sequence_type() {
-  _oneof_case_[0] = kSequenceType;
-}
-inline void TypeProto::clear_sequence_type() {
-  if (_internal_has_sequence_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.sequence_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::release_sequence_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
-  if (_internal_has_sequence_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Sequence* temp = value_.sequence_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.sequence_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
-  return _internal_has_sequence_type()
-      ? *value_.sequence_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Sequence*>(&::onnx::_TypeProto_Sequence_default_instance_);
-}
-inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
-  return _internal_sequence_type();
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::unsafe_arena_release_sequence_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
-  if (_internal_has_sequence_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Sequence* temp = value_.sequence_type_;
-    value_.sequence_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type) {
-  clear_value();
-  if (sequence_type) {
-    set_has_sequence_type();
-    value_.sequence_type_ = sequence_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::_internal_mutable_sequence_type() {
-  if (!_internal_has_sequence_type()) {
-    clear_value();
-    set_has_sequence_type();
-    value_.sequence_type_ = CreateMaybeMessage< ::onnx::TypeProto_Sequence >(GetArena());
-  }
-  return value_.sequence_type_;
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::mutable_sequence_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
-  return _internal_mutable_sequence_type();
-}
-
-// .onnx.TypeProto.Map map_type = 5;
-inline bool TypeProto::_internal_has_map_type() const {
-  return value_case() == kMapType;
-}
-inline bool TypeProto::has_map_type() const {
-  return _internal_has_map_type();
-}
-inline void TypeProto::set_has_map_type() {
-  _oneof_case_[0] = kMapType;
-}
-inline void TypeProto::clear_map_type() {
-  if (_internal_has_map_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.map_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Map* TypeProto::release_map_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
-  if (_internal_has_map_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Map* temp = value_.map_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.map_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
-  return _internal_has_map_type()
-      ? *value_.map_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Map*>(&::onnx::_TypeProto_Map_default_instance_);
-}
-inline const ::onnx::TypeProto_Map& TypeProto::map_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
-  return _internal_map_type();
-}
-inline ::onnx::TypeProto_Map* TypeProto::unsafe_arena_release_map_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
-  if (_internal_has_map_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Map* temp = value_.map_type_;
-    value_.map_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* map_type) {
-  clear_value();
-  if (map_type) {
-    set_has_map_type();
-    value_.map_type_ = map_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
-}
-inline ::onnx::TypeProto_Map* TypeProto::_internal_mutable_map_type() {
-  if (!_internal_has_map_type()) {
-    clear_value();
-    set_has_map_type();
-    value_.map_type_ = CreateMaybeMessage< ::onnx::TypeProto_Map >(GetArena());
-  }
-  return value_.map_type_;
-}
-inline ::onnx::TypeProto_Map* TypeProto::mutable_map_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
-  return _internal_mutable_map_type();
-}
-
-// .onnx.TypeProto.Optional optional_type = 9;
-inline bool TypeProto::_internal_has_optional_type() const {
-  return value_case() == kOptionalType;
-}
-inline bool TypeProto::has_optional_type() const {
-  return _internal_has_optional_type();
-}
-inline void TypeProto::set_has_optional_type() {
-  _oneof_case_[0] = kOptionalType;
-}
-inline void TypeProto::clear_optional_type() {
-  if (_internal_has_optional_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.optional_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Optional* TypeProto::release_optional_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
-  if (_internal_has_optional_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Optional* temp = value_.optional_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.optional_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
-  return _internal_has_optional_type()
-      ? *value_.optional_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Optional*>(&::onnx::_TypeProto_Optional_default_instance_);
-}
-inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
-  return _internal_optional_type();
-}
-inline ::onnx::TypeProto_Optional* TypeProto::unsafe_arena_release_optional_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
-  if (_internal_has_optional_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Optional* temp = value_.optional_type_;
-    value_.optional_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type) {
-  clear_value();
-  if (optional_type) {
-    set_has_optional_type();
-    value_.optional_type_ = optional_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
-}
-inline ::onnx::TypeProto_Optional* TypeProto::_internal_mutable_optional_type() {
-  if (!_internal_has_optional_type()) {
-    clear_value();
-    set_has_optional_type();
-    value_.optional_type_ = CreateMaybeMessage< ::onnx::TypeProto_Optional >(GetArena());
-  }
-  return value_.optional_type_;
-}
-inline ::onnx::TypeProto_Optional* TypeProto::mutable_optional_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
-  return _internal_mutable_optional_type();
-}
-
-// .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-inline bool TypeProto::_internal_has_sparse_tensor_type() const {
-  return value_case() == kSparseTensorType;
-}
-inline bool TypeProto::has_sparse_tensor_type() const {
-  return _internal_has_sparse_tensor_type();
-}
-inline void TypeProto::set_has_sparse_tensor_type() {
-  _oneof_case_[0] = kSparseTensorType;
-}
-inline void TypeProto::clear_sparse_tensor_type() {
-  if (_internal_has_sparse_tensor_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.sparse_tensor_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
-  if (_internal_has_sparse_tensor_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.sparse_tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
-  return _internal_has_sparse_tensor_type()
-      ? *value_.sparse_tensor_type_
-      : *reinterpret_cast< ::onnx::TypeProto_SparseTensor*>(&::onnx::_TypeProto_SparseTensor_default_instance_);
-}
-inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
-  return _internal_sparse_tensor_type();
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::unsafe_arena_release_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
-  if (_internal_has_sparse_tensor_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
-    value_.sparse_tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type) {
-  clear_value();
-  if (sparse_tensor_type) {
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = sparse_tensor_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::_internal_mutable_sparse_tensor_type() {
-  if (!_internal_has_sparse_tensor_type()) {
-    clear_value();
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = CreateMaybeMessage< ::onnx::TypeProto_SparseTensor >(GetArena());
-  }
-  return value_.sparse_tensor_type_;
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
-  return _internal_mutable_sparse_tensor_type();
-}
-
-// optional string denotation = 6;
-inline bool TypeProto::_internal_has_denotation() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool TypeProto::has_denotation() const {
-  return _internal_has_denotation();
-}
-inline void TypeProto::clear_denotation() {
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& TypeProto::denotation() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
-  return _internal_denotation();
-}
-inline void TypeProto::set_denotation(const std::string& value) {
-  _internal_set_denotation(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::mutable_denotation() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
-  return _internal_mutable_denotation();
-}
-inline const std::string& TypeProto::_internal_denotation() const {
-  return denotation_.Get();
-}
-inline void TypeProto::_internal_set_denotation(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TypeProto::set_denotation(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TypeProto.denotation)
-}
-inline void TypeProto::set_denotation(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TypeProto.denotation)
-}
-inline void TypeProto::set_denotation(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::_internal_mutable_denotation() {
-  _has_bits_[0] |= 0x00000001u;
-  return denotation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TypeProto::release_denotation() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
-  if (!_internal_has_denotation()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return denotation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TypeProto::set_allocated_denotation(std::string* denotation) {
-  if (denotation != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::unsafe_arena_release_denotation() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.denotation)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return denotation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TypeProto::unsafe_arena_set_allocated_denotation(
-    std::string* denotation) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (denotation != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  denotation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      denotation, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.denotation)
-}
-
-inline bool TypeProto::has_value() const {
-  return value_case() != VALUE_NOT_SET;
-}
-inline void TypeProto::clear_has_value() {
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-inline TypeProto::ValueCase TypeProto::value_case() const {
-  return TypeProto::ValueCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// OperatorSetIdProto
-
-// optional string domain = 1;
-inline bool OperatorSetIdProto::_internal_has_domain() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool OperatorSetIdProto::has_domain() const {
-  return _internal_has_domain();
-}
-inline void OperatorSetIdProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& OperatorSetIdProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
-  return _internal_domain();
-}
-inline void OperatorSetIdProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& OperatorSetIdProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void OperatorSetIdProto::set_domain(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.OperatorSetIdProto.domain)
-}
-inline void OperatorSetIdProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.OperatorSetIdProto.domain)
-}
-inline void OperatorSetIdProto::set_domain(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
-  _has_bits_[0] |= 0x00000001u;
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* OperatorSetIdProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
-  if (!_internal_has_domain()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void OperatorSetIdProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.OperatorSetIdProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void OperatorSetIdProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OperatorSetIdProto.domain)
-}
-
-// optional int64 version = 2;
-inline bool OperatorSetIdProto::_internal_has_version() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool OperatorSetIdProto::has_version() const {
-  return _internal_has_version();
-}
-inline void OperatorSetIdProto::clear_version() {
-  version_ = PROTOBUF_LONGLONG(0);
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorSetIdProto::_internal_version() const {
-  return version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorSetIdProto::version() const {
-  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
-  return _internal_version();
-}
-inline void OperatorSetIdProto::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000002u;
-  version_ = value;
-}
-inline void OperatorSetIdProto::set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_version(value);
-  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
-}
-
-// -------------------------------------------------------------------
-
-// FunctionProto
-
-// optional string name = 1;
-inline bool FunctionProto::_internal_has_name() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool FunctionProto::has_name() const {
-  return _internal_has_name();
-}
-inline void FunctionProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& FunctionProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
-  return _internal_name();
-}
-inline void FunctionProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& FunctionProto::_internal_name() const {
-  return name_.Get();
-}
-inline void FunctionProto::_internal_set_name(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_name(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.name)
-}
-inline void FunctionProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.name)
-}
-inline void FunctionProto::set_name(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::_internal_mutable_name() {
-  _has_bits_[0] |= 0x00000001u;
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000001u;
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.name)
-}
-
-// repeated string input = 4;
-inline int FunctionProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int FunctionProto::input_size() const {
-  return _internal_input_size();
-}
-inline void FunctionProto::clear_input() {
-  input_.Clear();
-}
-inline std::string* FunctionProto::add_input() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
-  return _internal_add_input();
-}
-inline const std::string& FunctionProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const std::string& FunctionProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
-  return _internal_input(index);
-}
-inline std::string* FunctionProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
-  return input_.Mutable(index);
-}
-inline void FunctionProto::set_input(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
-  input_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_input(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
-  input_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_input(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.input)
-}
-inline void FunctionProto::set_input(int index, const char* value, size_t size) {
-  input_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.input)
-}
-inline std::string* FunctionProto::_internal_add_input() {
-  return input_.Add();
-}
-inline void FunctionProto::add_input(const std::string& value) {
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(std::string&& value) {
-  input_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(const char* value, size_t size) {
-  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.input)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
-  return input_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
-  return &input_;
-}
-
-// repeated string output = 5;
-inline int FunctionProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int FunctionProto::output_size() const {
-  return _internal_output_size();
-}
-inline void FunctionProto::clear_output() {
-  output_.Clear();
-}
-inline std::string* FunctionProto::add_output() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
-  return _internal_add_output();
-}
-inline const std::string& FunctionProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const std::string& FunctionProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
-  return _internal_output(index);
-}
-inline std::string* FunctionProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
-  return output_.Mutable(index);
-}
-inline void FunctionProto::set_output(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
-  output_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_output(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
-  output_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_output(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.output)
-}
-inline void FunctionProto::set_output(int index, const char* value, size_t size) {
-  output_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.output)
-}
-inline std::string* FunctionProto::_internal_add_output() {
-  return output_.Add();
-}
-inline void FunctionProto::add_output(const std::string& value) {
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(std::string&& value) {
-  output_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(const char* value, size_t size) {
-  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.output)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
-  return output_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
-  return &output_;
-}
-
-// repeated string attribute = 6;
-inline int FunctionProto::_internal_attribute_size() const {
-  return attribute_.size();
-}
-inline int FunctionProto::attribute_size() const {
-  return _internal_attribute_size();
-}
-inline void FunctionProto::clear_attribute() {
-  attribute_.Clear();
-}
-inline std::string* FunctionProto::add_attribute() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
-  return _internal_add_attribute();
-}
-inline const std::string& FunctionProto::_internal_attribute(int index) const {
-  return attribute_.Get(index);
-}
-inline const std::string& FunctionProto::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
-  return _internal_attribute(index);
-}
-inline std::string* FunctionProto::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
-  return attribute_.Mutable(index);
-}
-inline void FunctionProto::set_attribute(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
-  attribute_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_attribute(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
-  attribute_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_attribute(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  attribute_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::set_attribute(int index, const char* value, size_t size) {
-  attribute_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.attribute)
-}
-inline std::string* FunctionProto::_internal_add_attribute() {
-  return attribute_.Add();
-}
-inline void FunctionProto::add_attribute(const std::string& value) {
-  attribute_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(std::string&& value) {
-  attribute_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  attribute_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(const char* value, size_t size) {
-  attribute_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.attribute)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::attribute() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
-  return attribute_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
-  return &attribute_;
-}
-
-// repeated .onnx.AttributeProto attribute_proto = 11;
-inline int FunctionProto::_internal_attribute_proto_size() const {
-  return attribute_proto_.size();
-}
-inline int FunctionProto::attribute_proto_size() const {
-  return _internal_attribute_proto_size();
-}
-inline void FunctionProto::clear_attribute_proto() {
-  attribute_proto_.Clear();
-}
-inline ::onnx::AttributeProto* FunctionProto::mutable_attribute_proto(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
-  return attribute_proto_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-FunctionProto::mutable_attribute_proto() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
-  return &attribute_proto_;
-}
-inline const ::onnx::AttributeProto& FunctionProto::_internal_attribute_proto(int index) const {
-  return attribute_proto_.Get(index);
-}
-inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
-  return _internal_attribute_proto(index);
-}
-inline ::onnx::AttributeProto* FunctionProto::_internal_add_attribute_proto() {
-  return attribute_proto_.Add();
-}
-inline ::onnx::AttributeProto* FunctionProto::add_attribute_proto() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
-  return _internal_add_attribute_proto();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-FunctionProto::attribute_proto() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
-  return attribute_proto_;
-}
-
-// repeated .onnx.NodeProto node = 7;
-inline int FunctionProto::_internal_node_size() const {
-  return node_.size();
-}
-inline int FunctionProto::node_size() const {
-  return _internal_node_size();
-}
-inline void FunctionProto::clear_node() {
-  node_.Clear();
-}
-inline ::onnx::NodeProto* FunctionProto::mutable_node(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
-  return node_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-FunctionProto::mutable_node() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
-  return &node_;
-}
-inline const ::onnx::NodeProto& FunctionProto::_internal_node(int index) const {
-  return node_.Get(index);
-}
-inline const ::onnx::NodeProto& FunctionProto::node(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
-  return _internal_node(index);
-}
-inline ::onnx::NodeProto* FunctionProto::_internal_add_node() {
-  return node_.Add();
-}
-inline ::onnx::NodeProto* FunctionProto::add_node() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
-  return _internal_add_node();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-FunctionProto::node() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
-  return node_;
-}
-
-// optional string doc_string = 8;
-inline bool FunctionProto::_internal_has_doc_string() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool FunctionProto::has_doc_string() const {
-  return _internal_has_doc_string();
-}
-inline void FunctionProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& FunctionProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
-  return _internal_doc_string();
-}
-inline void FunctionProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& FunctionProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void FunctionProto::_internal_set_doc_string(const std::string& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_doc_string(std::string&& value) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.doc_string)
-}
-inline void FunctionProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.doc_string)
-}
-inline void FunctionProto::set_doc_string(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000002u;
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::_internal_mutable_doc_string() {
-  _has_bits_[0] |= 0x00000002u;
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
-  if (!_internal_has_doc_string()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000002u;
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    _has_bits_[0] |= 0x00000002u;
-  } else {
-    _has_bits_[0] &= ~0x00000002u;
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.doc_string)
-}
-
-// repeated .onnx.OperatorSetIdProto opset_import = 9;
-inline int FunctionProto::_internal_opset_import_size() const {
-  return opset_import_.size();
-}
-inline int FunctionProto::opset_import_size() const {
-  return _internal_opset_import_size();
-}
-inline void FunctionProto::clear_opset_import() {
-  opset_import_.Clear();
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::mutable_opset_import(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
-  return opset_import_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-FunctionProto::mutable_opset_import() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
-  return &opset_import_;
-}
-inline const ::onnx::OperatorSetIdProto& FunctionProto::_internal_opset_import(int index) const {
-  return opset_import_.Get(index);
-}
-inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
-  return _internal_opset_import(index);
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::_internal_add_opset_import() {
-  return opset_import_.Add();
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::add_opset_import() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
-  return _internal_add_opset_import();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-FunctionProto::opset_import() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
-  return opset_import_;
-}
-
-// optional string domain = 10;
-inline bool FunctionProto::_internal_has_domain() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool FunctionProto::has_domain() const {
-  return _internal_has_domain();
-}
-inline void FunctionProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& FunctionProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
-  return _internal_domain();
-}
-inline void FunctionProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& FunctionProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void FunctionProto::_internal_set_domain(const std::string& value) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_domain(std::string&& value) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.domain)
-}
-inline void FunctionProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.domain)
-}
-inline void FunctionProto::set_domain(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000004u;
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::_internal_mutable_domain() {
-  _has_bits_[0] |= 0x00000004u;
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
-  if (!_internal_has_domain()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000004u;
-  return domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000004u;
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    _has_bits_[0] |= 0x00000004u;
-  } else {
-    _has_bits_[0] &= ~0x00000004u;
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.domain)
-}
-
-// optional string overload = 13;
-inline bool FunctionProto::_internal_has_overload() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool FunctionProto::has_overload() const {
-  return _internal_has_overload();
-}
-inline void FunctionProto::clear_overload() {
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& FunctionProto::overload() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload)
-  return _internal_overload();
-}
-inline void FunctionProto::set_overload(const std::string& value) {
-  _internal_set_overload(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::mutable_overload() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload)
-  return _internal_mutable_overload();
-}
-inline const std::string& FunctionProto::_internal_overload() const {
-  return overload_.Get();
-}
-inline void FunctionProto::_internal_set_overload(const std::string& value) {
-  _has_bits_[0] |= 0x00000008u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_overload(std::string&& value) {
-  _has_bits_[0] |= 0x00000008u;
-  overload_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.overload)
-}
-inline void FunctionProto::set_overload(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000008u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.overload)
-}
-inline void FunctionProto::set_overload(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000008u;
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::_internal_mutable_overload() {
-  _has_bits_[0] |= 0x00000008u;
-  return overload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_overload() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload)
-  if (!_internal_has_overload()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000008u;
-  return overload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_overload(std::string* overload) {
-  if (overload != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::unsafe_arena_release_overload() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.overload)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  _has_bits_[0] &= ~0x00000008u;
-  return overload_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_overload(
-    std::string* overload) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (overload != nullptr) {
-    _has_bits_[0] |= 0x00000008u;
-  } else {
-    _has_bits_[0] &= ~0x00000008u;
-  }
-  overload_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      overload, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.overload)
-}
-
-// repeated .onnx.ValueInfoProto value_info = 12;
-inline int FunctionProto::_internal_value_info_size() const {
-  return value_info_.size();
-}
-inline int FunctionProto::value_info_size() const {
-  return _internal_value_info_size();
-}
-inline void FunctionProto::clear_value_info() {
-  value_info_.Clear();
-}
-inline ::onnx::ValueInfoProto* FunctionProto::mutable_value_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info)
-  return value_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-FunctionProto::mutable_value_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info)
-  return &value_info_;
-}
-inline const ::onnx::ValueInfoProto& FunctionProto::_internal_value_info(int index) const {
-  return value_info_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& FunctionProto::value_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info)
-  return _internal_value_info(index);
-}
-inline ::onnx::ValueInfoProto* FunctionProto::_internal_add_value_info() {
-  return value_info_.Add();
-}
-inline ::onnx::ValueInfoProto* FunctionProto::add_value_info() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info)
-  return _internal_add_value_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-FunctionProto::value_info() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info)
-  return value_info_;
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 14;
-inline int FunctionProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int FunctionProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void FunctionProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-FunctionProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& FunctionProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-FunctionProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props)
-  return metadata_props_;
-}
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic pop
-#endif  // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace onnx
-
-PROTOBUF_NAMESPACE_OPEN
-
-template <> struct is_proto_enum< ::onnx::AttributeProto_AttributeType> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::TensorProto_DataType> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::TensorProto_DataLocation> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::Version> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::OperatorStatus> : ::std::true_type {};
-
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-
-#include <google/protobuf/port_undef.inc>
-#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.cc b/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.cc
deleted file mode 100644
index 32d06b8..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.cc
+++ /dev/null
@@ -1,10119 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: onnx.proto3
-
-#include "onnx.proto3.pb.h"
-
-#include <algorithm>
-
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/wire_format_lite.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_AttributeProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeviceConfigurationProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_FunctionProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IntIntListEntryProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NodeDeviceConfigurationProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_OperatorSetIdProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ShardedDimProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ShardingSpecProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleShardedDimProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SparseTensorProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringStringEntryProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorAnnotation_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TensorProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorProto_Segment_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorShapeProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorShapeProto_Dimension_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TrainingInfoProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TypeProto_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_SparseTensor_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_Tensor_onnx_2eproto3;
-extern PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ValueInfoProto_onnx_2eproto3;
-namespace onnx {
-class AttributeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AttributeProto> _instance;
-} _AttributeProto_default_instance_;
-class ValueInfoProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ValueInfoProto> _instance;
-} _ValueInfoProto_default_instance_;
-class NodeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NodeProto> _instance;
-} _NodeProto_default_instance_;
-class IntIntListEntryProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<IntIntListEntryProto> _instance;
-} _IntIntListEntryProto_default_instance_;
-class NodeDeviceConfigurationProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NodeDeviceConfigurationProto> _instance;
-} _NodeDeviceConfigurationProto_default_instance_;
-class ShardingSpecProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ShardingSpecProto> _instance;
-} _ShardingSpecProto_default_instance_;
-class ShardedDimProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ShardedDimProto> _instance;
-} _ShardedDimProto_default_instance_;
-class SimpleShardedDimProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SimpleShardedDimProto> _instance;
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-} _SimpleShardedDimProto_default_instance_;
-class TrainingInfoProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TrainingInfoProto> _instance;
-} _TrainingInfoProto_default_instance_;
-class ModelProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ModelProto> _instance;
-} _ModelProto_default_instance_;
-class DeviceConfigurationProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DeviceConfigurationProto> _instance;
-} _DeviceConfigurationProto_default_instance_;
-class StringStringEntryProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StringStringEntryProto> _instance;
-} _StringStringEntryProto_default_instance_;
-class TensorAnnotationDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorAnnotation> _instance;
-} _TensorAnnotation_default_instance_;
-class GraphProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GraphProto> _instance;
-} _GraphProto_default_instance_;
-class TensorProto_SegmentDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorProto_Segment> _instance;
-} _TensorProto_Segment_default_instance_;
-class TensorProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorProto> _instance;
-} _TensorProto_default_instance_;
-class SparseTensorProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SparseTensorProto> _instance;
-} _SparseTensorProto_default_instance_;
-class TensorShapeProto_DimensionDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorShapeProto_Dimension> _instance;
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-} _TensorShapeProto_Dimension_default_instance_;
-class TensorShapeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TensorShapeProto> _instance;
-} _TensorShapeProto_default_instance_;
-class TypeProto_TensorDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Tensor> _instance;
-} _TypeProto_Tensor_default_instance_;
-class TypeProto_SequenceDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Sequence> _instance;
-} _TypeProto_Sequence_default_instance_;
-class TypeProto_MapDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Map> _instance;
-} _TypeProto_Map_default_instance_;
-class TypeProto_OptionalDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_Optional> _instance;
-} _TypeProto_Optional_default_instance_;
-class TypeProto_SparseTensorDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto_SparseTensor> _instance;
-} _TypeProto_SparseTensor_default_instance_;
-class TypeProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TypeProto> _instance;
-  const ::onnx::TypeProto_Tensor* tensor_type_;
-  const ::onnx::TypeProto_Sequence* sequence_type_;
-  const ::onnx::TypeProto_Map* map_type_;
-  const ::onnx::TypeProto_Optional* optional_type_;
-  const ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
-} _TypeProto_default_instance_;
-class OperatorSetIdProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<OperatorSetIdProto> _instance;
-} _OperatorSetIdProto_default_instance_;
-class FunctionProtoDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FunctionProto> _instance;
-} _FunctionProto_default_instance_;
-}  // namespace onnx
-static void InitDefaultsscc_info_AttributeProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_AttributeProto_default_instance_;
-    new (ptr) ::onnx::AttributeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_NodeProto_default_instance_;
-    new (ptr) ::onnx::NodeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_GraphProto_default_instance_;
-    new (ptr) ::onnx::GraphProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::AttributeProto::InitAsDefaultInstance();
-  ::onnx::NodeProto::InitAsDefaultInstance();
-  ::onnx::GraphProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_AttributeProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 7, 0, InitDefaultsscc_info_AttributeProto_onnx_2eproto3}, {
-      &scc_info_TensorProto_onnx_2eproto3.base,
-      &scc_info_SparseTensorProto_onnx_2eproto3.base,
-      &scc_info_TypeProto_onnx_2eproto3.base,
-      &scc_info_ValueInfoProto_onnx_2eproto3.base,
-      &scc_info_TensorAnnotation_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,
-      &scc_info_NodeDeviceConfigurationProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_DeviceConfigurationProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_DeviceConfigurationProto_default_instance_;
-    new (ptr) ::onnx::DeviceConfigurationProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::DeviceConfigurationProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeviceConfigurationProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_DeviceConfigurationProto_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_FunctionProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_FunctionProto_default_instance_;
-    new (ptr) ::onnx::FunctionProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::FunctionProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_FunctionProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_FunctionProto_onnx_2eproto3}, {
-      &scc_info_AttributeProto_onnx_2eproto3.base,
-      &scc_info_OperatorSetIdProto_onnx_2eproto3.base,
-      &scc_info_ValueInfoProto_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_IntIntListEntryProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_IntIntListEntryProto_default_instance_;
-    new (ptr) ::onnx::IntIntListEntryProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::IntIntListEntryProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IntIntListEntryProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_IntIntListEntryProto_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_ModelProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ModelProto_default_instance_;
-    new (ptr) ::onnx::ModelProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ModelProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<6> scc_info_ModelProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 6, 0, InitDefaultsscc_info_ModelProto_onnx_2eproto3}, {
-      &scc_info_OperatorSetIdProto_onnx_2eproto3.base,
-      &scc_info_AttributeProto_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,
-      &scc_info_TrainingInfoProto_onnx_2eproto3.base,
-      &scc_info_FunctionProto_onnx_2eproto3.base,
-      &scc_info_DeviceConfigurationProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_NodeDeviceConfigurationProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_NodeDeviceConfigurationProto_default_instance_;
-    new (ptr) ::onnx::NodeDeviceConfigurationProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::NodeDeviceConfigurationProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NodeDeviceConfigurationProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_NodeDeviceConfigurationProto_onnx_2eproto3}, {
-      &scc_info_ShardingSpecProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_OperatorSetIdProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_OperatorSetIdProto_default_instance_;
-    new (ptr) ::onnx::OperatorSetIdProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::OperatorSetIdProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_OperatorSetIdProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_OperatorSetIdProto_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_ShardedDimProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ShardedDimProto_default_instance_;
-    new (ptr) ::onnx::ShardedDimProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ShardedDimProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ShardedDimProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ShardedDimProto_onnx_2eproto3}, {
-      &scc_info_SimpleShardedDimProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_ShardingSpecProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ShardingSpecProto_default_instance_;
-    new (ptr) ::onnx::ShardingSpecProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ShardingSpecProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ShardingSpecProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ShardingSpecProto_onnx_2eproto3}, {
-      &scc_info_IntIntListEntryProto_onnx_2eproto3.base,
-      &scc_info_ShardedDimProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_SimpleShardedDimProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_SimpleShardedDimProto_default_instance_;
-    new (ptr) ::onnx::SimpleShardedDimProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::SimpleShardedDimProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleShardedDimProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SimpleShardedDimProto_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_SparseTensorProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_SparseTensorProto_default_instance_;
-    new (ptr) ::onnx::SparseTensorProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::SparseTensorProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SparseTensorProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_SparseTensorProto_onnx_2eproto3}, {
-      &scc_info_TensorProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_StringStringEntryProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_StringStringEntryProto_default_instance_;
-    new (ptr) ::onnx::StringStringEntryProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::StringStringEntryProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringStringEntryProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StringStringEntryProto_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_TensorAnnotation_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorAnnotation_default_instance_;
-    new (ptr) ::onnx::TensorAnnotation();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorAnnotation::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorAnnotation_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TensorAnnotation_onnx_2eproto3}, {
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TensorProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorProto_default_instance_;
-    new (ptr) ::onnx::TensorProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TensorProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TensorProto_onnx_2eproto3}, {
-      &scc_info_TensorProto_Segment_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TensorProto_Segment_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorProto_Segment_default_instance_;
-    new (ptr) ::onnx::TensorProto_Segment();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorProto_Segment::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorProto_Segment_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TensorProto_Segment_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_TensorShapeProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorShapeProto_default_instance_;
-    new (ptr) ::onnx::TensorShapeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorShapeProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TensorShapeProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TensorShapeProto_onnx_2eproto3}, {
-      &scc_info_TensorShapeProto_Dimension_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TensorShapeProto_Dimension_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TensorShapeProto_Dimension_default_instance_;
-    new (ptr) ::onnx::TensorShapeProto_Dimension();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TensorShapeProto_Dimension::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TensorShapeProto_Dimension_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TensorShapeProto_Dimension_onnx_2eproto3}, {}};
-
-static void InitDefaultsscc_info_TrainingInfoProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TrainingInfoProto_default_instance_;
-    new (ptr) ::onnx::TrainingInfoProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TrainingInfoProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TrainingInfoProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TrainingInfoProto_onnx_2eproto3}, {
-      &scc_info_AttributeProto_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TypeProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_Sequence_default_instance_;
-    new (ptr) ::onnx::TypeProto_Sequence();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_Map_default_instance_;
-    new (ptr) ::onnx::TypeProto_Map();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_Optional_default_instance_;
-    new (ptr) ::onnx::TypeProto_Optional();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  {
-    void* ptr = &::onnx::_TypeProto_default_instance_;
-    new (ptr) ::onnx::TypeProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_Sequence::InitAsDefaultInstance();
-  ::onnx::TypeProto_Map::InitAsDefaultInstance();
-  ::onnx::TypeProto_Optional::InitAsDefaultInstance();
-  ::onnx::TypeProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TypeProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_TypeProto_onnx_2eproto3}, {
-      &scc_info_TypeProto_Tensor_onnx_2eproto3.base,
-      &scc_info_TypeProto_SparseTensor_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TypeProto_SparseTensor_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_SparseTensor_default_instance_;
-    new (ptr) ::onnx::TypeProto_SparseTensor();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_SparseTensor::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_SparseTensor_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TypeProto_SparseTensor_onnx_2eproto3}, {
-      &scc_info_TensorShapeProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_TypeProto_Tensor_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_TypeProto_Tensor_default_instance_;
-    new (ptr) ::onnx::TypeProto_Tensor();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::TypeProto_Tensor::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeProto_Tensor_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TypeProto_Tensor_onnx_2eproto3}, {
-      &scc_info_TensorShapeProto_onnx_2eproto3.base,}};
-
-static void InitDefaultsscc_info_ValueInfoProto_onnx_2eproto3() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::onnx::_ValueInfoProto_default_instance_;
-    new (ptr) ::onnx::ValueInfoProto();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::onnx::ValueInfoProto::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ValueInfoProto_onnx_2eproto3 =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ValueInfoProto_onnx_2eproto3}, {
-      &scc_info_TypeProto_onnx_2eproto3.base,
-      &scc_info_StringStringEntryProto_onnx_2eproto3.base,}};
-
-namespace onnx {
-bool AttributeProto_AttributeType_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-    case 13:
-    case 14:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AttributeProto_AttributeType_strings[15] = {};
-
-static const char AttributeProto_AttributeType_names[] =
-  "FLOAT"
-  "FLOATS"
-  "GRAPH"
-  "GRAPHS"
-  "INT"
-  "INTS"
-  "SPARSE_TENSOR"
-  "SPARSE_TENSORS"
-  "STRING"
-  "STRINGS"
-  "TENSOR"
-  "TENSORS"
-  "TYPE_PROTO"
-  "TYPE_PROTOS"
-  "UNDEFINED";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AttributeProto_AttributeType_entries[] = {
-  { {AttributeProto_AttributeType_names + 0, 5}, 1 },
-  { {AttributeProto_AttributeType_names + 5, 6}, 6 },
-  { {AttributeProto_AttributeType_names + 11, 5}, 5 },
-  { {AttributeProto_AttributeType_names + 16, 6}, 10 },
-  { {AttributeProto_AttributeType_names + 22, 3}, 2 },
-  { {AttributeProto_AttributeType_names + 25, 4}, 7 },
-  { {AttributeProto_AttributeType_names + 29, 13}, 11 },
-  { {AttributeProto_AttributeType_names + 42, 14}, 12 },
-  { {AttributeProto_AttributeType_names + 56, 6}, 3 },
-  { {AttributeProto_AttributeType_names + 62, 7}, 8 },
-  { {AttributeProto_AttributeType_names + 69, 6}, 4 },
-  { {AttributeProto_AttributeType_names + 75, 7}, 9 },
-  { {AttributeProto_AttributeType_names + 82, 10}, 13 },
-  { {AttributeProto_AttributeType_names + 92, 11}, 14 },
-  { {AttributeProto_AttributeType_names + 103, 9}, 0 },
-};
-
-static const int AttributeProto_AttributeType_entries_by_number[] = {
-  14, // 0 -> UNDEFINED
-  0, // 1 -> FLOAT
-  4, // 2 -> INT
-  8, // 3 -> STRING
-  10, // 4 -> TENSOR
-  2, // 5 -> GRAPH
-  1, // 6 -> FLOATS
-  5, // 7 -> INTS
-  9, // 8 -> STRINGS
-  11, // 9 -> TENSORS
-  3, // 10 -> GRAPHS
-  6, // 11 -> SPARSE_TENSOR
-  7, // 12 -> SPARSE_TENSORS
-  12, // 13 -> TYPE_PROTO
-  13, // 14 -> TYPE_PROTOS
-};
-
-const std::string& AttributeProto_AttributeType_Name(
-    AttributeProto_AttributeType value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          AttributeProto_AttributeType_entries,
-          AttributeProto_AttributeType_entries_by_number,
-          15, AttributeProto_AttributeType_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      AttributeProto_AttributeType_entries,
-      AttributeProto_AttributeType_entries_by_number,
-      15, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     AttributeProto_AttributeType_strings[idx].get();
-}
-bool AttributeProto_AttributeType_Parse(
-    const std::string& name, AttributeProto_AttributeType* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      AttributeProto_AttributeType_entries, 15, name, &int_value);
-  if (success) {
-    *value = static_cast<AttributeProto_AttributeType>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr AttributeProto_AttributeType AttributeProto::UNDEFINED;
-constexpr AttributeProto_AttributeType AttributeProto::FLOAT;
-constexpr AttributeProto_AttributeType AttributeProto::INT;
-constexpr AttributeProto_AttributeType AttributeProto::STRING;
-constexpr AttributeProto_AttributeType AttributeProto::TENSOR;
-constexpr AttributeProto_AttributeType AttributeProto::GRAPH;
-constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSOR;
-constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTO;
-constexpr AttributeProto_AttributeType AttributeProto::FLOATS;
-constexpr AttributeProto_AttributeType AttributeProto::INTS;
-constexpr AttributeProto_AttributeType AttributeProto::STRINGS;
-constexpr AttributeProto_AttributeType AttributeProto::TENSORS;
-constexpr AttributeProto_AttributeType AttributeProto::GRAPHS;
-constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSORS;
-constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTOS;
-constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MIN;
-constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MAX;
-constexpr int AttributeProto::AttributeType_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool TensorProto_DataType_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-    case 13:
-    case 14:
-    case 15:
-    case 16:
-    case 17:
-    case 18:
-    case 19:
-    case 20:
-    case 21:
-    case 22:
-    case 23:
-    case 24:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TensorProto_DataType_strings[25] = {};
-
-static const char TensorProto_DataType_names[] =
-  "BFLOAT16"
-  "BOOL"
-  "COMPLEX128"
-  "COMPLEX64"
-  "DOUBLE"
-  "FLOAT"
-  "FLOAT16"
-  "FLOAT4E2M1"
-  "FLOAT8E4M3FN"
-  "FLOAT8E4M3FNUZ"
-  "FLOAT8E5M2"
-  "FLOAT8E5M2FNUZ"
-  "FLOAT8E8M0"
-  "INT16"
-  "INT32"
-  "INT4"
-  "INT64"
-  "INT8"
-  "STRING"
-  "UINT16"
-  "UINT32"
-  "UINT4"
-  "UINT64"
-  "UINT8"
-  "UNDEFINED";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TensorProto_DataType_entries[] = {
-  { {TensorProto_DataType_names + 0, 8}, 16 },
-  { {TensorProto_DataType_names + 8, 4}, 9 },
-  { {TensorProto_DataType_names + 12, 10}, 15 },
-  { {TensorProto_DataType_names + 22, 9}, 14 },
-  { {TensorProto_DataType_names + 31, 6}, 11 },
-  { {TensorProto_DataType_names + 37, 5}, 1 },
-  { {TensorProto_DataType_names + 42, 7}, 10 },
-  { {TensorProto_DataType_names + 49, 10}, 23 },
-  { {TensorProto_DataType_names + 59, 12}, 17 },
-  { {TensorProto_DataType_names + 71, 14}, 18 },
-  { {TensorProto_DataType_names + 85, 10}, 19 },
-  { {TensorProto_DataType_names + 95, 14}, 20 },
-  { {TensorProto_DataType_names + 109, 10}, 24 },
-  { {TensorProto_DataType_names + 119, 5}, 5 },
-  { {TensorProto_DataType_names + 124, 5}, 6 },
-  { {TensorProto_DataType_names + 129, 4}, 22 },
-  { {TensorProto_DataType_names + 133, 5}, 7 },
-  { {TensorProto_DataType_names + 138, 4}, 3 },
-  { {TensorProto_DataType_names + 142, 6}, 8 },
-  { {TensorProto_DataType_names + 148, 6}, 4 },
-  { {TensorProto_DataType_names + 154, 6}, 12 },
-  { {TensorProto_DataType_names + 160, 5}, 21 },
-  { {TensorProto_DataType_names + 165, 6}, 13 },
-  { {TensorProto_DataType_names + 171, 5}, 2 },
-  { {TensorProto_DataType_names + 176, 9}, 0 },
-};
-
-static const int TensorProto_DataType_entries_by_number[] = {
-  24, // 0 -> UNDEFINED
-  5, // 1 -> FLOAT
-  23, // 2 -> UINT8
-  17, // 3 -> INT8
-  19, // 4 -> UINT16
-  13, // 5 -> INT16
-  14, // 6 -> INT32
-  16, // 7 -> INT64
-  18, // 8 -> STRING
-  1, // 9 -> BOOL
-  6, // 10 -> FLOAT16
-  4, // 11 -> DOUBLE
-  20, // 12 -> UINT32
-  22, // 13 -> UINT64
-  3, // 14 -> COMPLEX64
-  2, // 15 -> COMPLEX128
-  0, // 16 -> BFLOAT16
-  8, // 17 -> FLOAT8E4M3FN
-  9, // 18 -> FLOAT8E4M3FNUZ
-  10, // 19 -> FLOAT8E5M2
-  11, // 20 -> FLOAT8E5M2FNUZ
-  21, // 21 -> UINT4
-  15, // 22 -> INT4
-  7, // 23 -> FLOAT4E2M1
-  12, // 24 -> FLOAT8E8M0
-};
-
-const std::string& TensorProto_DataType_Name(
-    TensorProto_DataType value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          TensorProto_DataType_entries,
-          TensorProto_DataType_entries_by_number,
-          25, TensorProto_DataType_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      TensorProto_DataType_entries,
-      TensorProto_DataType_entries_by_number,
-      25, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     TensorProto_DataType_strings[idx].get();
-}
-bool TensorProto_DataType_Parse(
-    const std::string& name, TensorProto_DataType* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      TensorProto_DataType_entries, 25, name, &int_value);
-  if (success) {
-    *value = static_cast<TensorProto_DataType>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr TensorProto_DataType TensorProto::UNDEFINED;
-constexpr TensorProto_DataType TensorProto::FLOAT;
-constexpr TensorProto_DataType TensorProto::UINT8;
-constexpr TensorProto_DataType TensorProto::INT8;
-constexpr TensorProto_DataType TensorProto::UINT16;
-constexpr TensorProto_DataType TensorProto::INT16;
-constexpr TensorProto_DataType TensorProto::INT32;
-constexpr TensorProto_DataType TensorProto::INT64;
-constexpr TensorProto_DataType TensorProto::STRING;
-constexpr TensorProto_DataType TensorProto::BOOL;
-constexpr TensorProto_DataType TensorProto::FLOAT16;
-constexpr TensorProto_DataType TensorProto::DOUBLE;
-constexpr TensorProto_DataType TensorProto::UINT32;
-constexpr TensorProto_DataType TensorProto::UINT64;
-constexpr TensorProto_DataType TensorProto::COMPLEX64;
-constexpr TensorProto_DataType TensorProto::COMPLEX128;
-constexpr TensorProto_DataType TensorProto::BFLOAT16;
-constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FN;
-constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FNUZ;
-constexpr TensorProto_DataType TensorProto::FLOAT8E5M2;
-constexpr TensorProto_DataType TensorProto::FLOAT8E5M2FNUZ;
-constexpr TensorProto_DataType TensorProto::UINT4;
-constexpr TensorProto_DataType TensorProto::INT4;
-constexpr TensorProto_DataType TensorProto::FLOAT4E2M1;
-constexpr TensorProto_DataType TensorProto::FLOAT8E8M0;
-constexpr TensorProto_DataType TensorProto::DataType_MIN;
-constexpr TensorProto_DataType TensorProto::DataType_MAX;
-constexpr int TensorProto::DataType_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool TensorProto_DataLocation_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TensorProto_DataLocation_strings[2] = {};
-
-static const char TensorProto_DataLocation_names[] =
-  "DEFAULT"
-  "EXTERNAL";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TensorProto_DataLocation_entries[] = {
-  { {TensorProto_DataLocation_names + 0, 7}, 0 },
-  { {TensorProto_DataLocation_names + 7, 8}, 1 },
-};
-
-static const int TensorProto_DataLocation_entries_by_number[] = {
-  0, // 0 -> DEFAULT
-  1, // 1 -> EXTERNAL
-};
-
-const std::string& TensorProto_DataLocation_Name(
-    TensorProto_DataLocation value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          TensorProto_DataLocation_entries,
-          TensorProto_DataLocation_entries_by_number,
-          2, TensorProto_DataLocation_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      TensorProto_DataLocation_entries,
-      TensorProto_DataLocation_entries_by_number,
-      2, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     TensorProto_DataLocation_strings[idx].get();
-}
-bool TensorProto_DataLocation_Parse(
-    const std::string& name, TensorProto_DataLocation* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      TensorProto_DataLocation_entries, 2, name, &int_value);
-  if (success) {
-    *value = static_cast<TensorProto_DataLocation>(int_value);
-  }
-  return success;
-}
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr TensorProto_DataLocation TensorProto::DEFAULT;
-constexpr TensorProto_DataLocation TensorProto::EXTERNAL;
-constexpr TensorProto_DataLocation TensorProto::DataLocation_MIN;
-constexpr TensorProto_DataLocation TensorProto::DataLocation_MAX;
-constexpr int TensorProto::DataLocation_ARRAYSIZE;
-#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-bool Version_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Version_strings[13] = {};
-
-static const char Version_names[] =
-  "IR_VERSION"
-  "IR_VERSION_2017_10_10"
-  "IR_VERSION_2017_10_30"
-  "IR_VERSION_2017_11_3"
-  "IR_VERSION_2019_1_22"
-  "IR_VERSION_2019_3_18"
-  "IR_VERSION_2019_9_19"
-  "IR_VERSION_2020_5_8"
-  "IR_VERSION_2021_7_30"
-  "IR_VERSION_2023_5_5"
-  "IR_VERSION_2024_3_25"
-  "IR_VERSION_2025_05_12"
-  "_START_VERSION";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Version_entries[] = {
-  { {Version_names + 0, 10}, 12 },
-  { {Version_names + 10, 21}, 1 },
-  { {Version_names + 31, 21}, 2 },
-  { {Version_names + 52, 20}, 3 },
-  { {Version_names + 72, 20}, 4 },
-  { {Version_names + 92, 20}, 5 },
-  { {Version_names + 112, 20}, 6 },
-  { {Version_names + 132, 19}, 7 },
-  { {Version_names + 151, 20}, 8 },
-  { {Version_names + 171, 19}, 9 },
-  { {Version_names + 190, 20}, 10 },
-  { {Version_names + 210, 21}, 11 },
-  { {Version_names + 231, 14}, 0 },
-};
-
-static const int Version_entries_by_number[] = {
-  12, // 0 -> _START_VERSION
-  1, // 1 -> IR_VERSION_2017_10_10
-  2, // 2 -> IR_VERSION_2017_10_30
-  3, // 3 -> IR_VERSION_2017_11_3
-  4, // 4 -> IR_VERSION_2019_1_22
-  5, // 5 -> IR_VERSION_2019_3_18
-  6, // 6 -> IR_VERSION_2019_9_19
-  7, // 7 -> IR_VERSION_2020_5_8
-  8, // 8 -> IR_VERSION_2021_7_30
-  9, // 9 -> IR_VERSION_2023_5_5
-  10, // 10 -> IR_VERSION_2024_3_25
-  11, // 11 -> IR_VERSION_2025_05_12
-  0, // 12 -> IR_VERSION
-};
-
-const std::string& Version_Name(
-    Version value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          Version_entries,
-          Version_entries_by_number,
-          13, Version_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      Version_entries,
-      Version_entries_by_number,
-      13, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     Version_strings[idx].get();
-}
-bool Version_Parse(
-    const std::string& name, Version* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      Version_entries, 13, name, &int_value);
-  if (success) {
-    *value = static_cast<Version>(int_value);
-  }
-  return success;
-}
-bool OperatorStatus_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-      return true;
-    default:
-      return false;
-  }
-}
-
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OperatorStatus_strings[2] = {};
-
-static const char OperatorStatus_names[] =
-  "EXPERIMENTAL"
-  "STABLE";
-
-static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperatorStatus_entries[] = {
-  { {OperatorStatus_names + 0, 12}, 0 },
-  { {OperatorStatus_names + 12, 6}, 1 },
-};
-
-static const int OperatorStatus_entries_by_number[] = {
-  0, // 0 -> EXPERIMENTAL
-  1, // 1 -> STABLE
-};
-
-const std::string& OperatorStatus_Name(
-    OperatorStatus value) {
-  static const bool dummy =
-      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
-          OperatorStatus_entries,
-          OperatorStatus_entries_by_number,
-          2, OperatorStatus_strings);
-  (void) dummy;
-  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
-      OperatorStatus_entries,
-      OperatorStatus_entries_by_number,
-      2, value);
-  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
-                     OperatorStatus_strings[idx].get();
-}
-bool OperatorStatus_Parse(
-    const std::string& name, OperatorStatus* value) {
-  int int_value;
-  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      OperatorStatus_entries, 2, name, &int_value);
-  if (success) {
-    *value = static_cast<OperatorStatus>(int_value);
-  }
-  return success;
-}
-
-// ===================================================================
-
-void AttributeProto::InitAsDefaultInstance() {
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->t_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->g_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->sparse_tensor_ = const_cast< ::onnx::SparseTensorProto*>(
-      ::onnx::SparseTensorProto::internal_default_instance());
-  ::onnx::_AttributeProto_default_instance_._instance.get_mutable()->tp_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class AttributeProto::_Internal {
- public:
-  static const ::onnx::TensorProto& t(const AttributeProto* msg);
-  static const ::onnx::GraphProto& g(const AttributeProto* msg);
-  static const ::onnx::SparseTensorProto& sparse_tensor(const AttributeProto* msg);
-  static const ::onnx::TypeProto& tp(const AttributeProto* msg);
-};
-
-const ::onnx::TensorProto&
-AttributeProto::_Internal::t(const AttributeProto* msg) {
-  return *msg->t_;
-}
-const ::onnx::GraphProto&
-AttributeProto::_Internal::g(const AttributeProto* msg) {
-  return *msg->g_;
-}
-const ::onnx::SparseTensorProto&
-AttributeProto::_Internal::sparse_tensor(const AttributeProto* msg) {
-  return *msg->sparse_tensor_;
-}
-const ::onnx::TypeProto&
-AttributeProto::_Internal::tp(const AttributeProto* msg) {
-  return *msg->tp_;
-}
-AttributeProto::AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  floats_(arena),
-  ints_(arena),
-  strings_(arena),
-  tensors_(arena),
-  graphs_(arena),
-  type_protos_(arena),
-  sparse_tensors_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.AttributeProto)
-}
-AttributeProto::AttributeProto(const AttributeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      floats_(from.floats_),
-      ints_(from.ints_),
-      strings_(from.strings_),
-      tensors_(from.tensors_),
-      graphs_(from.graphs_),
-      type_protos_(from.type_protos_),
-      sparse_tensors_(from.sparse_tensors_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  s_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_s().empty()) {
-    s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_s(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  ref_attr_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_ref_attr_name().empty()) {
-    ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ref_attr_name(),
-      GetArena());
-  }
-  if (from._internal_has_t()) {
-    t_ = new ::onnx::TensorProto(*from.t_);
-  } else {
-    t_ = nullptr;
-  }
-  if (from._internal_has_g()) {
-    g_ = new ::onnx::GraphProto(*from.g_);
-  } else {
-    g_ = nullptr;
-  }
-  if (from._internal_has_tp()) {
-    tp_ = new ::onnx::TypeProto(*from.tp_);
-  } else {
-    tp_ = nullptr;
-  }
-  if (from._internal_has_sparse_tensor()) {
-    sparse_tensor_ = new ::onnx::SparseTensorProto(*from.sparse_tensor_);
-  } else {
-    sparse_tensor_ = nullptr;
-  }
-  ::memcpy(&i_, &from.i_,
-    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
-    reinterpret_cast<char*>(&i_)) + sizeof(type_));
-  // @@protoc_insertion_point(copy_constructor:onnx.AttributeProto)
-}
-
-void AttributeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  s_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ref_attr_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&t_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&type_) -
-      reinterpret_cast<char*>(&t_)) + sizeof(type_));
-}
-
-AttributeProto::~AttributeProto() {
-  // @@protoc_insertion_point(destructor:onnx.AttributeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void AttributeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  s_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ref_attr_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete t_;
-  if (this != internal_default_instance()) delete g_;
-  if (this != internal_default_instance()) delete tp_;
-  if (this != internal_default_instance()) delete sparse_tensor_;
-}
-
-void AttributeProto::ArenaDtor(void* object) {
-  AttributeProto* _this = reinterpret_cast< AttributeProto* >(object);
-  (void)_this;
-}
-void AttributeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void AttributeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const AttributeProto& AttributeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void AttributeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.AttributeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  floats_.Clear();
-  ints_.Clear();
-  strings_.Clear();
-  tensors_.Clear();
-  graphs_.Clear();
-  type_protos_.Clear();
-  sparse_tensors_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  s_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ref_attr_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  if (GetArena() == nullptr && t_ != nullptr) {
-    delete t_;
-  }
-  t_ = nullptr;
-  if (GetArena() == nullptr && g_ != nullptr) {
-    delete g_;
-  }
-  g_ = nullptr;
-  if (GetArena() == nullptr && tp_ != nullptr) {
-    delete tp_;
-  }
-  tp_ = nullptr;
-  if (GetArena() == nullptr && sparse_tensor_ != nullptr) {
-    delete sparse_tensor_;
-  }
-  sparse_tensor_ = nullptr;
-  ::memset(&i_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&type_) -
-      reinterpret_cast<char*>(&i_)) + sizeof(type_));
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* AttributeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // float f = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
-          f_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
-          ptr += sizeof(float);
-        } else goto handle_unusual;
-        continue;
-      // int64 i = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          i_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // bytes s = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_s();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorProto t = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ctx->ParseMessage(_internal_mutable_t(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.GraphProto g = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr = ctx->ParseMessage(_internal_mutable_g(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated float floats = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_floats(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61) {
-          _internal_add_floats(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
-          ptr += sizeof(float);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 ints = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_ints(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64) {
-          _internal_add_ints(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated bytes strings = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_strings();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorProto tensors = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_tensors(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.GraphProto graphs = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_graphs(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto tp = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr = ctx->ParseMessage(_internal_mutable_tp(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TypeProto type_protos = 15;
-      case 15:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_type_protos(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // .onnx.AttributeProto.AttributeType type = 20;
-      case 20:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
-          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-          _internal_set_type(static_cast<::onnx::AttributeProto_AttributeType>(val));
-        } else goto handle_unusual;
-        continue;
-      // string ref_attr_name = 21;
-      case 21:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
-          auto str = _internal_mutable_ref_attr_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.SparseTensorProto sparse_tensor = 22;
-      case 22:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-      case 23:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_sparse_tensors(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<186>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* AttributeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.AttributeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.AttributeProto.name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // float f = 2;
-  if (!(this->f() <= 0 && this->f() >= 0)) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_f(), target);
-  }
-
-  // int64 i = 3;
-  if (this->i() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_i(), target);
-  }
-
-  // bytes s = 4;
-  if (this->s().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
-        4, this->_internal_s(), target);
-  }
-
-  // .onnx.TensorProto t = 5;
-  if (this->has_t()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        5, _Internal::t(this), target, stream);
-  }
-
-  // .onnx.GraphProto g = 6;
-  if (this->has_g()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        6, _Internal::g(this), target, stream);
-  }
-
-  // repeated float floats = 7;
-  if (this->_internal_floats_size() > 0) {
-    target = stream->WriteFixedPacked(7, _internal_floats(), target);
-  }
-
-  // repeated int64 ints = 8;
-  {
-    int byte_size = _ints_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          8, _internal_ints(), byte_size, target);
-    }
-  }
-
-  // repeated bytes strings = 9;
-  for (int i = 0, n = this->_internal_strings_size(); i < n; i++) {
-    const auto& s = this->_internal_strings(i);
-    target = stream->WriteBytes(9, s, target);
-  }
-
-  // repeated .onnx.TensorProto tensors = 10;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_tensors_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(10, this->_internal_tensors(i), target, stream);
-  }
-
-  // repeated .onnx.GraphProto graphs = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_graphs_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_graphs(i), target, stream);
-  }
-
-  // string doc_string = 13;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.AttributeProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        13, this->_internal_doc_string(), target);
-  }
-
-  // .onnx.TypeProto tp = 14;
-  if (this->has_tp()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        14, _Internal::tp(this), target, stream);
-  }
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_type_protos_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(15, this->_internal_type_protos(i), target, stream);
-  }
-
-  // .onnx.AttributeProto.AttributeType type = 20;
-  if (this->type() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
-      20, this->_internal_type(), target);
-  }
-
-  // string ref_attr_name = 21;
-  if (this->ref_attr_name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_ref_attr_name().data(), static_cast<int>(this->_internal_ref_attr_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.AttributeProto.ref_attr_name");
-    target = stream->WriteStringMaybeAliased(
-        21, this->_internal_ref_attr_name(), target);
-  }
-
-  // .onnx.SparseTensorProto sparse_tensor = 22;
-  if (this->has_sparse_tensor()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        22, _Internal::sparse_tensor(this), target, stream);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sparse_tensors_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(23, this->_internal_sparse_tensors(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.AttributeProto)
-  return target;
-}
-
-size_t AttributeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.AttributeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated float floats = 7;
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_floats_size());
-    size_t data_size = 4UL * count;
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _floats_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated int64 ints = 8;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->ints_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _ints_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated bytes strings = 9;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(strings_.size());
-  for (int i = 0, n = strings_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      strings_.Get(i));
-  }
-
-  // repeated .onnx.TensorProto tensors = 10;
-  total_size += 1UL * this->_internal_tensors_size();
-  for (const auto& msg : this->tensors_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.GraphProto graphs = 11;
-  total_size += 1UL * this->_internal_graphs_size();
-  for (const auto& msg : this->graphs_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  total_size += 1UL * this->_internal_type_protos_size();
-  for (const auto& msg : this->type_protos_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  total_size += 2UL * this->_internal_sparse_tensors_size();
-  for (const auto& msg : this->sparse_tensors_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // bytes s = 4;
-  if (this->s().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_s());
-  }
-
-  // string doc_string = 13;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // string ref_attr_name = 21;
-  if (this->ref_attr_name().size() > 0) {
-    total_size += 2 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_ref_attr_name());
-  }
-
-  // .onnx.TensorProto t = 5;
-  if (this->has_t()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *t_);
-  }
-
-  // .onnx.GraphProto g = 6;
-  if (this->has_g()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *g_);
-  }
-
-  // .onnx.TypeProto tp = 14;
-  if (this->has_tp()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *tp_);
-  }
-
-  // .onnx.SparseTensorProto sparse_tensor = 22;
-  if (this->has_sparse_tensor()) {
-    total_size += 2 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *sparse_tensor_);
-  }
-
-  // int64 i = 3;
-  if (this->i() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_i());
-  }
-
-  // float f = 2;
-  if (!(this->f() <= 0 && this->f() >= 0)) {
-    total_size += 1 + 4;
-  }
-
-  // .onnx.AttributeProto.AttributeType type = 20;
-  if (this->type() != 0) {
-    total_size += 2 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void AttributeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AttributeProto*>(
-      &from));
-}
-
-void AttributeProto::MergeFrom(const AttributeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.AttributeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  floats_.MergeFrom(from.floats_);
-  ints_.MergeFrom(from.ints_);
-  strings_.MergeFrom(from.strings_);
-  tensors_.MergeFrom(from.tensors_);
-  graphs_.MergeFrom(from.graphs_);
-  type_protos_.MergeFrom(from.type_protos_);
-  sparse_tensors_.MergeFrom(from.sparse_tensors_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.s().size() > 0) {
-    _internal_set_s(from._internal_s());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.ref_attr_name().size() > 0) {
-    _internal_set_ref_attr_name(from._internal_ref_attr_name());
-  }
-  if (from.has_t()) {
-    _internal_mutable_t()->::onnx::TensorProto::MergeFrom(from._internal_t());
-  }
-  if (from.has_g()) {
-    _internal_mutable_g()->::onnx::GraphProto::MergeFrom(from._internal_g());
-  }
-  if (from.has_tp()) {
-    _internal_mutable_tp()->::onnx::TypeProto::MergeFrom(from._internal_tp());
-  }
-  if (from.has_sparse_tensor()) {
-    _internal_mutable_sparse_tensor()->::onnx::SparseTensorProto::MergeFrom(from._internal_sparse_tensor());
-  }
-  if (from.i() != 0) {
-    _internal_set_i(from._internal_i());
-  }
-  if (!(from.f() <= 0 && from.f() >= 0)) {
-    _internal_set_f(from._internal_f());
-  }
-  if (from.type() != 0) {
-    _internal_set_type(from._internal_type());
-  }
-}
-
-void AttributeProto::CopyFrom(const AttributeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.AttributeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AttributeProto::IsInitialized() const {
-  return true;
-}
-
-void AttributeProto::InternalSwap(AttributeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  floats_.InternalSwap(&other->floats_);
-  ints_.InternalSwap(&other->ints_);
-  strings_.InternalSwap(&other->strings_);
-  tensors_.InternalSwap(&other->tensors_);
-  graphs_.InternalSwap(&other->graphs_);
-  type_protos_.InternalSwap(&other->type_protos_);
-  sparse_tensors_.InternalSwap(&other->sparse_tensors_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  s_.Swap(&other->s_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ref_attr_name_.Swap(&other->ref_attr_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(AttributeProto, type_)
-      + sizeof(AttributeProto::type_)
-      - PROTOBUF_FIELD_OFFSET(AttributeProto, t_)>(
-          reinterpret_cast<char*>(&t_),
-          reinterpret_cast<char*>(&other->t_));
-}
-
-std::string AttributeProto::GetTypeName() const {
-  return "onnx.AttributeProto";
-}
-
-
-// ===================================================================
-
-void ValueInfoProto::InitAsDefaultInstance() {
-  ::onnx::_ValueInfoProto_default_instance_._instance.get_mutable()->type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class ValueInfoProto::_Internal {
- public:
-  static const ::onnx::TypeProto& type(const ValueInfoProto* msg);
-};
-
-const ::onnx::TypeProto&
-ValueInfoProto::_Internal::type(const ValueInfoProto* msg) {
-  return *msg->type_;
-}
-ValueInfoProto::ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ValueInfoProto)
-}
-ValueInfoProto::ValueInfoProto(const ValueInfoProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_type()) {
-    type_ = new ::onnx::TypeProto(*from.type_);
-  } else {
-    type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.ValueInfoProto)
-}
-
-void ValueInfoProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ValueInfoProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  type_ = nullptr;
-}
-
-ValueInfoProto::~ValueInfoProto() {
-  // @@protoc_insertion_point(destructor:onnx.ValueInfoProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ValueInfoProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete type_;
-}
-
-void ValueInfoProto::ArenaDtor(void* object) {
-  ValueInfoProto* _this = reinterpret_cast< ValueInfoProto* >(object);
-  (void)_this;
-}
-void ValueInfoProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ValueInfoProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ValueInfoProto& ValueInfoProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ValueInfoProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void ValueInfoProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ValueInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  metadata_props_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  if (GetArena() == nullptr && type_ != nullptr) {
-    delete type_;
-  }
-  type_ = nullptr;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ValueInfoProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ValueInfoProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ValueInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ValueInfoProto.name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // .onnx.TypeProto type = 2;
-  if (this->has_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::type(this), target, stream);
-  }
-
-  // string doc_string = 3;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ValueInfoProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ValueInfoProto)
-  return target;
-}
-
-size_t ValueInfoProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ValueInfoProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // string doc_string = 3;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // .onnx.TypeProto type = 2;
-  if (this->has_type()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *type_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ValueInfoProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ValueInfoProto*>(
-      &from));
-}
-
-void ValueInfoProto::MergeFrom(const ValueInfoProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ValueInfoProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  metadata_props_.MergeFrom(from.metadata_props_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.has_type()) {
-    _internal_mutable_type()->::onnx::TypeProto::MergeFrom(from._internal_type());
-  }
-}
-
-void ValueInfoProto::CopyFrom(const ValueInfoProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ValueInfoProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ValueInfoProto::IsInitialized() const {
-  return true;
-}
-
-void ValueInfoProto::InternalSwap(ValueInfoProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(type_, other->type_);
-}
-
-std::string ValueInfoProto::GetTypeName() const {
-  return "onnx.ValueInfoProto";
-}
-
-
-// ===================================================================
-
-void NodeProto::InitAsDefaultInstance() {
-}
-class NodeProto::_Internal {
- public:
-};
-
-NodeProto::NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  input_(arena),
-  output_(arena),
-  attribute_(arena),
-  metadata_props_(arena),
-  device_configurations_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.NodeProto)
-}
-NodeProto::NodeProto(const NodeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      input_(from.input_),
-      output_(from.output_),
-      attribute_(from.attribute_),
-      metadata_props_(from.metadata_props_),
-      device_configurations_(from.device_configurations_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  op_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_op_type().empty()) {
-    op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_op_type(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_domain().empty()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_overload().empty()) {
-    overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_overload(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.NodeProto)
-}
-
-void NodeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  op_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-NodeProto::~NodeProto() {
-  // @@protoc_insertion_point(destructor:onnx.NodeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void NodeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  op_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void NodeProto::ArenaDtor(void* object) {
-  NodeProto* _this = reinterpret_cast< NodeProto* >(object);
-  (void)_this;
-}
-void NodeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void NodeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const NodeProto& NodeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void NodeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.NodeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  input_.Clear();
-  output_.Clear();
-  attribute_.Clear();
-  metadata_props_.Clear();
-  device_configurations_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  op_type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* NodeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated string input = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_input();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string output = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_output();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string name = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string op_type = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_op_type();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.AttributeProto attribute = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_attribute(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string domain = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string overload = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_overload();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_device_configurations(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* NodeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.NodeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated string input = 1;
-  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
-    const auto& s = this->_internal_input(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.input");
-    target = stream->WriteString(1, s, target);
-  }
-
-  // repeated string output = 2;
-  for (int i = 0, n = this->_internal_output_size(); i < n; i++) {
-    const auto& s = this->_internal_output(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.output");
-    target = stream->WriteString(2, s, target);
-  }
-
-  // string name = 3;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.name");
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_name(), target);
-  }
-
-  // string op_type = 4;
-  if (this->op_type().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_op_type().data(), static_cast<int>(this->_internal_op_type().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.op_type");
-    target = stream->WriteStringMaybeAliased(
-        4, this->_internal_op_type(), target);
-  }
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_attribute_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(5, this->_internal_attribute(i), target, stream);
-  }
-
-  // string doc_string = 6;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_doc_string(), target);
-  }
-
-  // string domain = 7;
-  if (this->domain().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_domain().data(), static_cast<int>(this->_internal_domain().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.domain");
-    target = stream->WriteStringMaybeAliased(
-        7, this->_internal_domain(), target);
-  }
-
-  // string overload = 8;
-  if (this->overload().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_overload().data(), static_cast<int>(this->_internal_overload().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeProto.overload");
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_overload(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(9, this->_internal_metadata_props(i), target, stream);
-  }
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_device_configurations_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(10, this->_internal_device_configurations(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.NodeProto)
-  return target;
-}
-
-size_t NodeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.NodeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string input = 1;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
-  for (int i = 0, n = input_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      input_.Get(i));
-  }
-
-  // repeated string output = 2;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size());
-  for (int i = 0, n = output_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      output_.Get(i));
-  }
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  total_size += 1UL * this->_internal_attribute_size();
-  for (const auto& msg : this->attribute_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  total_size += 1UL * this->_internal_device_configurations_size();
-  for (const auto& msg : this->device_configurations_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 3;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // string op_type = 4;
-  if (this->op_type().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_op_type());
-  }
-
-  // string doc_string = 6;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // string domain = 7;
-  if (this->domain().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_domain());
-  }
-
-  // string overload = 8;
-  if (this->overload().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_overload());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void NodeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const NodeProto*>(
-      &from));
-}
-
-void NodeProto::MergeFrom(const NodeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.NodeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  attribute_.MergeFrom(from.attribute_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  device_configurations_.MergeFrom(from.device_configurations_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.op_type().size() > 0) {
-    _internal_set_op_type(from._internal_op_type());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.domain().size() > 0) {
-    _internal_set_domain(from._internal_domain());
-  }
-  if (from.overload().size() > 0) {
-    _internal_set_overload(from._internal_overload());
-  }
-}
-
-void NodeProto::CopyFrom(const NodeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.NodeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool NodeProto::IsInitialized() const {
-  return true;
-}
-
-void NodeProto::InternalSwap(NodeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  attribute_.InternalSwap(&other->attribute_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  device_configurations_.InternalSwap(&other->device_configurations_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  op_type_.Swap(&other->op_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.Swap(&other->overload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string NodeProto::GetTypeName() const {
-  return "onnx.NodeProto";
-}
-
-
-// ===================================================================
-
-void IntIntListEntryProto::InitAsDefaultInstance() {
-}
-class IntIntListEntryProto::_Internal {
- public:
-};
-
-IntIntListEntryProto::IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  value_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.IntIntListEntryProto)
-}
-IntIntListEntryProto::IntIntListEntryProto(const IntIntListEntryProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      value_(from.value_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  key_ = from.key_;
-  // @@protoc_insertion_point(copy_constructor:onnx.IntIntListEntryProto)
-}
-
-void IntIntListEntryProto::SharedCtor() {
-  key_ = PROTOBUF_LONGLONG(0);
-}
-
-IntIntListEntryProto::~IntIntListEntryProto() {
-  // @@protoc_insertion_point(destructor:onnx.IntIntListEntryProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void IntIntListEntryProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void IntIntListEntryProto::ArenaDtor(void* object) {
-  IntIntListEntryProto* _this = reinterpret_cast< IntIntListEntryProto* >(object);
-  (void)_this;
-}
-void IntIntListEntryProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void IntIntListEntryProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const IntIntListEntryProto& IntIntListEntryProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IntIntListEntryProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void IntIntListEntryProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.IntIntListEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  value_.Clear();
-  key_ = PROTOBUF_LONGLONG(0);
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* IntIntListEntryProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 key = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          key_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 value = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_value(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
-          _internal_add_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* IntIntListEntryProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.IntIntListEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 key = 1;
-  if (this->key() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_key(), target);
-  }
-
-  // repeated int64 value = 2;
-  {
-    int byte_size = _value_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          2, _internal_value(), byte_size, target);
-    }
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.IntIntListEntryProto)
-  return target;
-}
-
-size_t IntIntListEntryProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.IntIntListEntryProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 value = 2;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->value_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _value_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // int64 key = 1;
-  if (this->key() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_key());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void IntIntListEntryProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const IntIntListEntryProto*>(
-      &from));
-}
-
-void IntIntListEntryProto::MergeFrom(const IntIntListEntryProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.IntIntListEntryProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  value_.MergeFrom(from.value_);
-  if (from.key() != 0) {
-    _internal_set_key(from._internal_key());
-  }
-}
-
-void IntIntListEntryProto::CopyFrom(const IntIntListEntryProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.IntIntListEntryProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool IntIntListEntryProto::IsInitialized() const {
-  return true;
-}
-
-void IntIntListEntryProto::InternalSwap(IntIntListEntryProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  value_.InternalSwap(&other->value_);
-  swap(key_, other->key_);
-}
-
-std::string IntIntListEntryProto::GetTypeName() const {
-  return "onnx.IntIntListEntryProto";
-}
-
-
-// ===================================================================
-
-void NodeDeviceConfigurationProto::InitAsDefaultInstance() {
-}
-class NodeDeviceConfigurationProto::_Internal {
- public:
-};
-
-NodeDeviceConfigurationProto::NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  sharding_spec_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.NodeDeviceConfigurationProto)
-}
-NodeDeviceConfigurationProto::NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      sharding_spec_(from.sharding_spec_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  configuration_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_configuration_id().empty()) {
-    configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_configuration_id(),
-      GetArena());
-  }
-  pipeline_stage_ = from.pipeline_stage_;
-  // @@protoc_insertion_point(copy_constructor:onnx.NodeDeviceConfigurationProto)
-}
-
-void NodeDeviceConfigurationProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NodeDeviceConfigurationProto_onnx_2eproto3.base);
-  configuration_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  pipeline_stage_ = 0;
-}
-
-NodeDeviceConfigurationProto::~NodeDeviceConfigurationProto() {
-  // @@protoc_insertion_point(destructor:onnx.NodeDeviceConfigurationProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void NodeDeviceConfigurationProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  configuration_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void NodeDeviceConfigurationProto::ArenaDtor(void* object) {
-  NodeDeviceConfigurationProto* _this = reinterpret_cast< NodeDeviceConfigurationProto* >(object);
-  (void)_this;
-}
-void NodeDeviceConfigurationProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void NodeDeviceConfigurationProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const NodeDeviceConfigurationProto& NodeDeviceConfigurationProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NodeDeviceConfigurationProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void NodeDeviceConfigurationProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.NodeDeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  sharding_spec_.Clear();
-  configuration_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  pipeline_stage_ = 0;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* NodeDeviceConfigurationProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string configuration_id = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_configuration_id();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sharding_spec(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // int32 pipeline_stage = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          pipeline_stage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* NodeDeviceConfigurationProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.NodeDeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string configuration_id = 1;
-  if (this->configuration_id().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_configuration_id().data(), static_cast<int>(this->_internal_configuration_id().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.NodeDeviceConfigurationProto.configuration_id");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_configuration_id(), target);
-  }
-
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sharding_spec_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_sharding_spec(i), target, stream);
-  }
-
-  // int32 pipeline_stage = 3;
-  if (this->pipeline_stage() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_pipeline_stage(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.NodeDeviceConfigurationProto)
-  return target;
-}
-
-size_t NodeDeviceConfigurationProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.NodeDeviceConfigurationProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  total_size += 1UL * this->_internal_sharding_spec_size();
-  for (const auto& msg : this->sharding_spec_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string configuration_id = 1;
-  if (this->configuration_id().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_configuration_id());
-  }
-
-  // int32 pipeline_stage = 3;
-  if (this->pipeline_stage() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_pipeline_stage());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void NodeDeviceConfigurationProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const NodeDeviceConfigurationProto*>(
-      &from));
-}
-
-void NodeDeviceConfigurationProto::MergeFrom(const NodeDeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.NodeDeviceConfigurationProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  sharding_spec_.MergeFrom(from.sharding_spec_);
-  if (from.configuration_id().size() > 0) {
-    _internal_set_configuration_id(from._internal_configuration_id());
-  }
-  if (from.pipeline_stage() != 0) {
-    _internal_set_pipeline_stage(from._internal_pipeline_stage());
-  }
-}
-
-void NodeDeviceConfigurationProto::CopyFrom(const NodeDeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.NodeDeviceConfigurationProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool NodeDeviceConfigurationProto::IsInitialized() const {
-  return true;
-}
-
-void NodeDeviceConfigurationProto::InternalSwap(NodeDeviceConfigurationProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  sharding_spec_.InternalSwap(&other->sharding_spec_);
-  configuration_id_.Swap(&other->configuration_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(pipeline_stage_, other->pipeline_stage_);
-}
-
-std::string NodeDeviceConfigurationProto::GetTypeName() const {
-  return "onnx.NodeDeviceConfigurationProto";
-}
-
-
-// ===================================================================
-
-void ShardingSpecProto::InitAsDefaultInstance() {
-}
-class ShardingSpecProto::_Internal {
- public:
-};
-
-ShardingSpecProto::ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  device_(arena),
-  index_to_device_group_map_(arena),
-  sharded_dim_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ShardingSpecProto)
-}
-ShardingSpecProto::ShardingSpecProto(const ShardingSpecProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      device_(from.device_),
-      index_to_device_group_map_(from.index_to_device_group_map_),
-      sharded_dim_(from.sharded_dim_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_tensor_name().empty()) {
-    tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_tensor_name(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.ShardingSpecProto)
-}
-
-void ShardingSpecProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ShardingSpecProto_onnx_2eproto3.base);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-ShardingSpecProto::~ShardingSpecProto() {
-  // @@protoc_insertion_point(destructor:onnx.ShardingSpecProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ShardingSpecProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  tensor_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void ShardingSpecProto::ArenaDtor(void* object) {
-  ShardingSpecProto* _this = reinterpret_cast< ShardingSpecProto* >(object);
-  (void)_this;
-}
-void ShardingSpecProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ShardingSpecProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ShardingSpecProto& ShardingSpecProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ShardingSpecProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void ShardingSpecProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ShardingSpecProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  device_.Clear();
-  index_to_device_group_map_.Clear();
-  sharded_dim_.Clear();
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ShardingSpecProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string tensor_name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_tensor_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 device = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_device(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
-          _internal_add_device(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_index_to_device_group_map(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ShardedDimProto sharded_dim = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sharded_dim(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ShardingSpecProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ShardingSpecProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string tensor_name = 1;
-  if (this->tensor_name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_tensor_name().data(), static_cast<int>(this->_internal_tensor_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ShardingSpecProto.tensor_name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_tensor_name(), target);
-  }
-
-  // repeated int64 device = 2;
-  {
-    int byte_size = _device_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          2, _internal_device(), byte_size, target);
-    }
-  }
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_index_to_device_group_map_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, this->_internal_index_to_device_group_map(i), target, stream);
-  }
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sharded_dim_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_sharded_dim(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ShardingSpecProto)
-  return target;
-}
-
-size_t ShardingSpecProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ShardingSpecProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 device = 2;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->device_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _device_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  total_size += 1UL * this->_internal_index_to_device_group_map_size();
-  for (const auto& msg : this->index_to_device_group_map_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  total_size += 1UL * this->_internal_sharded_dim_size();
-  for (const auto& msg : this->sharded_dim_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string tensor_name = 1;
-  if (this->tensor_name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_tensor_name());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ShardingSpecProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ShardingSpecProto*>(
-      &from));
-}
-
-void ShardingSpecProto::MergeFrom(const ShardingSpecProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ShardingSpecProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  device_.MergeFrom(from.device_);
-  index_to_device_group_map_.MergeFrom(from.index_to_device_group_map_);
-  sharded_dim_.MergeFrom(from.sharded_dim_);
-  if (from.tensor_name().size() > 0) {
-    _internal_set_tensor_name(from._internal_tensor_name());
-  }
-}
-
-void ShardingSpecProto::CopyFrom(const ShardingSpecProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ShardingSpecProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ShardingSpecProto::IsInitialized() const {
-  return true;
-}
-
-void ShardingSpecProto::InternalSwap(ShardingSpecProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  device_.InternalSwap(&other->device_);
-  index_to_device_group_map_.InternalSwap(&other->index_to_device_group_map_);
-  sharded_dim_.InternalSwap(&other->sharded_dim_);
-  tensor_name_.Swap(&other->tensor_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string ShardingSpecProto::GetTypeName() const {
-  return "onnx.ShardingSpecProto";
-}
-
-
-// ===================================================================
-
-void ShardedDimProto::InitAsDefaultInstance() {
-}
-class ShardedDimProto::_Internal {
- public:
-};
-
-ShardedDimProto::ShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  simple_sharding_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ShardedDimProto)
-}
-ShardedDimProto::ShardedDimProto(const ShardedDimProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      simple_sharding_(from.simple_sharding_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  axis_ = from.axis_;
-  // @@protoc_insertion_point(copy_constructor:onnx.ShardedDimProto)
-}
-
-void ShardedDimProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ShardedDimProto_onnx_2eproto3.base);
-  axis_ = PROTOBUF_LONGLONG(0);
-}
-
-ShardedDimProto::~ShardedDimProto() {
-  // @@protoc_insertion_point(destructor:onnx.ShardedDimProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ShardedDimProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void ShardedDimProto::ArenaDtor(void* object) {
-  ShardedDimProto* _this = reinterpret_cast< ShardedDimProto* >(object);
-  (void)_this;
-}
-void ShardedDimProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ShardedDimProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ShardedDimProto& ShardedDimProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ShardedDimProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void ShardedDimProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  simple_sharding_.Clear();
-  axis_ = PROTOBUF_LONGLONG(0);
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ShardedDimProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 axis = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          axis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_simple_sharding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ShardedDimProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 axis = 1;
-  if (this->axis() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_axis(), target);
-  }
-
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_simple_sharding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_simple_sharding(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ShardedDimProto)
-  return target;
-}
-
-size_t ShardedDimProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ShardedDimProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  total_size += 1UL * this->_internal_simple_sharding_size();
-  for (const auto& msg : this->simple_sharding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // int64 axis = 1;
-  if (this->axis() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_axis());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ShardedDimProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ShardedDimProto*>(
-      &from));
-}
-
-void ShardedDimProto::MergeFrom(const ShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ShardedDimProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  simple_sharding_.MergeFrom(from.simple_sharding_);
-  if (from.axis() != 0) {
-    _internal_set_axis(from._internal_axis());
-  }
-}
-
-void ShardedDimProto::CopyFrom(const ShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ShardedDimProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ShardedDimProto::IsInitialized() const {
-  return true;
-}
-
-void ShardedDimProto::InternalSwap(ShardedDimProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  simple_sharding_.InternalSwap(&other->simple_sharding_);
-  swap(axis_, other->axis_);
-}
-
-std::string ShardedDimProto::GetTypeName() const {
-  return "onnx.ShardedDimProto";
-}
-
-
-// ===================================================================
-
-void SimpleShardedDimProto::InitAsDefaultInstance() {
-}
-class SimpleShardedDimProto::_Internal {
- public:
-};
-
-SimpleShardedDimProto::SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.SimpleShardedDimProto)
-}
-SimpleShardedDimProto::SimpleShardedDimProto(const SimpleShardedDimProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  num_shards_ = from.num_shards_;
-  clear_has_dim();
-  switch (from.dim_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.SimpleShardedDimProto)
-}
-
-void SimpleShardedDimProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SimpleShardedDimProto_onnx_2eproto3.base);
-  num_shards_ = PROTOBUF_LONGLONG(0);
-  clear_has_dim();
-}
-
-SimpleShardedDimProto::~SimpleShardedDimProto() {
-  // @@protoc_insertion_point(destructor:onnx.SimpleShardedDimProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void SimpleShardedDimProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (has_dim()) {
-    clear_dim();
-  }
-}
-
-void SimpleShardedDimProto::ArenaDtor(void* object) {
-  SimpleShardedDimProto* _this = reinterpret_cast< SimpleShardedDimProto* >(object);
-  (void)_this;
-}
-void SimpleShardedDimProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void SimpleShardedDimProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const SimpleShardedDimProto& SimpleShardedDimProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SimpleShardedDimProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void SimpleShardedDimProto::clear_dim() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.SimpleShardedDimProto)
-  switch (dim_case()) {
-    case kDimValue: {
-      // No need to clear
-      break;
-    }
-    case kDimParam: {
-      dim_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = DIM_NOT_SET;
-}
-
-
-void SimpleShardedDimProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.SimpleShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  num_shards_ = PROTOBUF_LONGLONG(0);
-  clear_dim();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* SimpleShardedDimProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 dim_value = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string dim_param = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_dim_param();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int64 num_shards = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
-          num_shards_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* SimpleShardedDimProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.SimpleShardedDimProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 dim_value = 1;
-  if (_internal_has_dim_value()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_dim_value(), target);
-  }
-
-  // string dim_param = 2;
-  if (_internal_has_dim_param()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_dim_param().data(), static_cast<int>(this->_internal_dim_param().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.SimpleShardedDimProto.dim_param");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_dim_param(), target);
-  }
-
-  // int64 num_shards = 3;
-  if (this->num_shards() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_num_shards(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.SimpleShardedDimProto)
-  return target;
-}
-
-size_t SimpleShardedDimProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.SimpleShardedDimProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // int64 num_shards = 3;
-  if (this->num_shards() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_num_shards());
-  }
-
-  switch (dim_case()) {
-    // int64 dim_value = 1;
-    case kDimValue: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_dim_value());
-      break;
-    }
-    // string dim_param = 2;
-    case kDimParam: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void SimpleShardedDimProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SimpleShardedDimProto*>(
-      &from));
-}
-
-void SimpleShardedDimProto::MergeFrom(const SimpleShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.SimpleShardedDimProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.num_shards() != 0) {
-    _internal_set_num_shards(from._internal_num_shards());
-  }
-  switch (from.dim_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case DIM_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void SimpleShardedDimProto::CopyFrom(const SimpleShardedDimProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.SimpleShardedDimProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SimpleShardedDimProto::IsInitialized() const {
-  return true;
-}
-
-void SimpleShardedDimProto::InternalSwap(SimpleShardedDimProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(num_shards_, other->num_shards_);
-  swap(dim_, other->dim_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string SimpleShardedDimProto::GetTypeName() const {
-  return "onnx.SimpleShardedDimProto";
-}
-
-
-// ===================================================================
-
-void TrainingInfoProto::InitAsDefaultInstance() {
-  ::onnx::_TrainingInfoProto_default_instance_._instance.get_mutable()->initialization_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-  ::onnx::_TrainingInfoProto_default_instance_._instance.get_mutable()->algorithm_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-}
-class TrainingInfoProto::_Internal {
- public:
-  static const ::onnx::GraphProto& initialization(const TrainingInfoProto* msg);
-  static const ::onnx::GraphProto& algorithm(const TrainingInfoProto* msg);
-};
-
-const ::onnx::GraphProto&
-TrainingInfoProto::_Internal::initialization(const TrainingInfoProto* msg) {
-  return *msg->initialization_;
-}
-const ::onnx::GraphProto&
-TrainingInfoProto::_Internal::algorithm(const TrainingInfoProto* msg) {
-  return *msg->algorithm_;
-}
-TrainingInfoProto::TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  initialization_binding_(arena),
-  update_binding_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TrainingInfoProto)
-}
-TrainingInfoProto::TrainingInfoProto(const TrainingInfoProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      initialization_binding_(from.initialization_binding_),
-      update_binding_(from.update_binding_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_initialization()) {
-    initialization_ = new ::onnx::GraphProto(*from.initialization_);
-  } else {
-    initialization_ = nullptr;
-  }
-  if (from._internal_has_algorithm()) {
-    algorithm_ = new ::onnx::GraphProto(*from.algorithm_);
-  } else {
-    algorithm_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TrainingInfoProto)
-}
-
-void TrainingInfoProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainingInfoProto_onnx_2eproto3.base);
-  ::memset(&initialization_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&algorithm_) -
-      reinterpret_cast<char*>(&initialization_)) + sizeof(algorithm_));
-}
-
-TrainingInfoProto::~TrainingInfoProto() {
-  // @@protoc_insertion_point(destructor:onnx.TrainingInfoProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TrainingInfoProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete initialization_;
-  if (this != internal_default_instance()) delete algorithm_;
-}
-
-void TrainingInfoProto::ArenaDtor(void* object) {
-  TrainingInfoProto* _this = reinterpret_cast< TrainingInfoProto* >(object);
-  (void)_this;
-}
-void TrainingInfoProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TrainingInfoProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TrainingInfoProto& TrainingInfoProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TrainingInfoProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TrainingInfoProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TrainingInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  initialization_binding_.Clear();
-  update_binding_.Clear();
-  if (GetArena() == nullptr && initialization_ != nullptr) {
-    delete initialization_;
-  }
-  initialization_ = nullptr;
-  if (GetArena() == nullptr && algorithm_ != nullptr) {
-    delete algorithm_;
-  }
-  algorithm_ = nullptr;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TrainingInfoProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.GraphProto initialization = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_initialization(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.GraphProto algorithm = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_algorithm(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_initialization_binding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto update_binding = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_update_binding(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TrainingInfoProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TrainingInfoProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .onnx.GraphProto initialization = 1;
-  if (this->has_initialization()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::initialization(this), target, stream);
-  }
-
-  // .onnx.GraphProto algorithm = 2;
-  if (this->has_algorithm()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::algorithm(this), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_initialization_binding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, this->_internal_initialization_binding(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_update_binding_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(4, this->_internal_update_binding(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TrainingInfoProto)
-  return target;
-}
-
-size_t TrainingInfoProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TrainingInfoProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  total_size += 1UL * this->_internal_initialization_binding_size();
-  for (const auto& msg : this->initialization_binding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  total_size += 1UL * this->_internal_update_binding_size();
-  for (const auto& msg : this->update_binding_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // .onnx.GraphProto initialization = 1;
-  if (this->has_initialization()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *initialization_);
-  }
-
-  // .onnx.GraphProto algorithm = 2;
-  if (this->has_algorithm()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *algorithm_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TrainingInfoProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TrainingInfoProto*>(
-      &from));
-}
-
-void TrainingInfoProto::MergeFrom(const TrainingInfoProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TrainingInfoProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  initialization_binding_.MergeFrom(from.initialization_binding_);
-  update_binding_.MergeFrom(from.update_binding_);
-  if (from.has_initialization()) {
-    _internal_mutable_initialization()->::onnx::GraphProto::MergeFrom(from._internal_initialization());
-  }
-  if (from.has_algorithm()) {
-    _internal_mutable_algorithm()->::onnx::GraphProto::MergeFrom(from._internal_algorithm());
-  }
-}
-
-void TrainingInfoProto::CopyFrom(const TrainingInfoProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TrainingInfoProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TrainingInfoProto::IsInitialized() const {
-  return true;
-}
-
-void TrainingInfoProto::InternalSwap(TrainingInfoProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  initialization_binding_.InternalSwap(&other->initialization_binding_);
-  update_binding_.InternalSwap(&other->update_binding_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TrainingInfoProto, algorithm_)
-      + sizeof(TrainingInfoProto::algorithm_)
-      - PROTOBUF_FIELD_OFFSET(TrainingInfoProto, initialization_)>(
-          reinterpret_cast<char*>(&initialization_),
-          reinterpret_cast<char*>(&other->initialization_));
-}
-
-std::string TrainingInfoProto::GetTypeName() const {
-  return "onnx.TrainingInfoProto";
-}
-
-
-// ===================================================================
-
-void ModelProto::InitAsDefaultInstance() {
-  ::onnx::_ModelProto_default_instance_._instance.get_mutable()->graph_ = const_cast< ::onnx::GraphProto*>(
-      ::onnx::GraphProto::internal_default_instance());
-}
-class ModelProto::_Internal {
- public:
-  static const ::onnx::GraphProto& graph(const ModelProto* msg);
-};
-
-const ::onnx::GraphProto&
-ModelProto::_Internal::graph(const ModelProto* msg) {
-  return *msg->graph_;
-}
-ModelProto::ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  opset_import_(arena),
-  metadata_props_(arena),
-  training_info_(arena),
-  functions_(arena),
-  configuration_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.ModelProto)
-}
-ModelProto::ModelProto(const ModelProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      opset_import_(from.opset_import_),
-      metadata_props_(from.metadata_props_),
-      training_info_(from.training_info_),
-      functions_(from.functions_),
-      configuration_(from.configuration_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  producer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_producer_name().empty()) {
-    producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_producer_name(),
-      GetArena());
-  }
-  producer_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_producer_version().empty()) {
-    producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_producer_version(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_domain().empty()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_graph()) {
-    graph_ = new ::onnx::GraphProto(*from.graph_);
-  } else {
-    graph_ = nullptr;
-  }
-  ::memcpy(&ir_version_, &from.ir_version_,
-    static_cast<size_t>(reinterpret_cast<char*>(&model_version_) -
-    reinterpret_cast<char*>(&ir_version_)) + sizeof(model_version_));
-  // @@protoc_insertion_point(copy_constructor:onnx.ModelProto)
-}
-
-void ModelProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_onnx_2eproto3.base);
-  producer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  producer_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&graph_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&model_version_) -
-      reinterpret_cast<char*>(&graph_)) + sizeof(model_version_));
-}
-
-ModelProto::~ModelProto() {
-  // @@protoc_insertion_point(destructor:onnx.ModelProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void ModelProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  producer_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  producer_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete graph_;
-}
-
-void ModelProto::ArenaDtor(void* object) {
-  ModelProto* _this = reinterpret_cast< ModelProto* >(object);
-  (void)_this;
-}
-void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void ModelProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const ModelProto& ModelProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ModelProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void ModelProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.ModelProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  opset_import_.Clear();
-  metadata_props_.Clear();
-  training_info_.Clear();
-  functions_.Clear();
-  configuration_.Clear();
-  producer_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  producer_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  if (GetArena() == nullptr && graph_ != nullptr) {
-    delete graph_;
-  }
-  graph_ = nullptr;
-  ::memset(&ir_version_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&model_version_) -
-      reinterpret_cast<char*>(&ir_version_)) + sizeof(model_version_));
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* ModelProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 ir_version = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          ir_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string producer_name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_producer_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string producer_version = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_producer_version();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string domain = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int64 model_version = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
-          model_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.GraphProto graph = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr = ctx->ParseMessage(_internal_mutable_graph(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.OperatorSetIdProto opset_import = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TrainingInfoProto training_info = 20;
-      case 20:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_training_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.FunctionProto functions = 25;
-      case 25:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_functions(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<202>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.DeviceConfigurationProto configuration = 26;
-      case 26:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_configuration(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<210>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* ModelProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.ModelProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 ir_version = 1;
-  if (this->ir_version() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_ir_version(), target);
-  }
-
-  // string producer_name = 2;
-  if (this->producer_name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_producer_name().data(), static_cast<int>(this->_internal_producer_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ModelProto.producer_name");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_producer_name(), target);
-  }
-
-  // string producer_version = 3;
-  if (this->producer_version().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_producer_version().data(), static_cast<int>(this->_internal_producer_version().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ModelProto.producer_version");
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_producer_version(), target);
-  }
-
-  // string domain = 4;
-  if (this->domain().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_domain().data(), static_cast<int>(this->_internal_domain().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ModelProto.domain");
-    target = stream->WriteStringMaybeAliased(
-        4, this->_internal_domain(), target);
-  }
-
-  // int64 model_version = 5;
-  if (this->model_version() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_model_version(), target);
-  }
-
-  // string doc_string = 6;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.ModelProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_doc_string(), target);
-  }
-
-  // .onnx.GraphProto graph = 7;
-  if (this->has_graph()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        7, _Internal::graph(this), target, stream);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_opset_import_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(8, this->_internal_opset_import(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_metadata_props(i), target, stream);
-  }
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_training_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(20, this->_internal_training_info(i), target, stream);
-  }
-
-  // repeated .onnx.FunctionProto functions = 25;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_functions_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(25, this->_internal_functions(i), target, stream);
-  }
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_configuration_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(26, this->_internal_configuration(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.ModelProto)
-  return target;
-}
-
-size_t ModelProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.ModelProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  total_size += 1UL * this->_internal_opset_import_size();
-  for (const auto& msg : this->opset_import_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  total_size += 2UL * this->_internal_training_info_size();
-  for (const auto& msg : this->training_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.FunctionProto functions = 25;
-  total_size += 2UL * this->_internal_functions_size();
-  for (const auto& msg : this->functions_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  total_size += 2UL * this->_internal_configuration_size();
-  for (const auto& msg : this->configuration_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string producer_name = 2;
-  if (this->producer_name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_producer_name());
-  }
-
-  // string producer_version = 3;
-  if (this->producer_version().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_producer_version());
-  }
-
-  // string domain = 4;
-  if (this->domain().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_domain());
-  }
-
-  // string doc_string = 6;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // .onnx.GraphProto graph = 7;
-  if (this->has_graph()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *graph_);
-  }
-
-  // int64 ir_version = 1;
-  if (this->ir_version() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_ir_version());
-  }
-
-  // int64 model_version = 5;
-  if (this->model_version() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_model_version());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void ModelProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ModelProto*>(
-      &from));
-}
-
-void ModelProto::MergeFrom(const ModelProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.ModelProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  opset_import_.MergeFrom(from.opset_import_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  training_info_.MergeFrom(from.training_info_);
-  functions_.MergeFrom(from.functions_);
-  configuration_.MergeFrom(from.configuration_);
-  if (from.producer_name().size() > 0) {
-    _internal_set_producer_name(from._internal_producer_name());
-  }
-  if (from.producer_version().size() > 0) {
-    _internal_set_producer_version(from._internal_producer_version());
-  }
-  if (from.domain().size() > 0) {
-    _internal_set_domain(from._internal_domain());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.has_graph()) {
-    _internal_mutable_graph()->::onnx::GraphProto::MergeFrom(from._internal_graph());
-  }
-  if (from.ir_version() != 0) {
-    _internal_set_ir_version(from._internal_ir_version());
-  }
-  if (from.model_version() != 0) {
-    _internal_set_model_version(from._internal_model_version());
-  }
-}
-
-void ModelProto::CopyFrom(const ModelProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.ModelProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ModelProto::IsInitialized() const {
-  return true;
-}
-
-void ModelProto::InternalSwap(ModelProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  opset_import_.InternalSwap(&other->opset_import_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  training_info_.InternalSwap(&other->training_info_);
-  functions_.InternalSwap(&other->functions_);
-  configuration_.InternalSwap(&other->configuration_);
-  producer_name_.Swap(&other->producer_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  producer_version_.Swap(&other->producer_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(ModelProto, model_version_)
-      + sizeof(ModelProto::model_version_)
-      - PROTOBUF_FIELD_OFFSET(ModelProto, graph_)>(
-          reinterpret_cast<char*>(&graph_),
-          reinterpret_cast<char*>(&other->graph_));
-}
-
-std::string ModelProto::GetTypeName() const {
-  return "onnx.ModelProto";
-}
-
-
-// ===================================================================
-
-void DeviceConfigurationProto::InitAsDefaultInstance() {
-}
-class DeviceConfigurationProto::_Internal {
- public:
-};
-
-DeviceConfigurationProto::DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  device_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.DeviceConfigurationProto)
-}
-DeviceConfigurationProto::DeviceConfigurationProto(const DeviceConfigurationProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      device_(from.device_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  num_devices_ = from.num_devices_;
-  // @@protoc_insertion_point(copy_constructor:onnx.DeviceConfigurationProto)
-}
-
-void DeviceConfigurationProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeviceConfigurationProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  num_devices_ = 0;
-}
-
-DeviceConfigurationProto::~DeviceConfigurationProto() {
-  // @@protoc_insertion_point(destructor:onnx.DeviceConfigurationProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void DeviceConfigurationProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void DeviceConfigurationProto::ArenaDtor(void* object) {
-  DeviceConfigurationProto* _this = reinterpret_cast< DeviceConfigurationProto* >(object);
-  (void)_this;
-}
-void DeviceConfigurationProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void DeviceConfigurationProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const DeviceConfigurationProto& DeviceConfigurationProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DeviceConfigurationProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void DeviceConfigurationProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.DeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  device_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  num_devices_ = 0;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* DeviceConfigurationProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int32 num_devices = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          num_devices_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated string device = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_device();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* DeviceConfigurationProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.DeviceConfigurationProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.DeviceConfigurationProto.name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // int32 num_devices = 2;
-  if (this->num_devices() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_num_devices(), target);
-  }
-
-  // repeated string device = 3;
-  for (int i = 0, n = this->_internal_device_size(); i < n; i++) {
-    const auto& s = this->_internal_device(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.DeviceConfigurationProto.device");
-    target = stream->WriteString(3, s, target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.DeviceConfigurationProto)
-  return target;
-}
-
-size_t DeviceConfigurationProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.DeviceConfigurationProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string device = 3;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(device_.size());
-  for (int i = 0, n = device_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      device_.Get(i));
-  }
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // int32 num_devices = 2;
-  if (this->num_devices() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_num_devices());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void DeviceConfigurationProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DeviceConfigurationProto*>(
-      &from));
-}
-
-void DeviceConfigurationProto::MergeFrom(const DeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.DeviceConfigurationProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  device_.MergeFrom(from.device_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.num_devices() != 0) {
-    _internal_set_num_devices(from._internal_num_devices());
-  }
-}
-
-void DeviceConfigurationProto::CopyFrom(const DeviceConfigurationProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.DeviceConfigurationProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool DeviceConfigurationProto::IsInitialized() const {
-  return true;
-}
-
-void DeviceConfigurationProto::InternalSwap(DeviceConfigurationProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  device_.InternalSwap(&other->device_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(num_devices_, other->num_devices_);
-}
-
-std::string DeviceConfigurationProto::GetTypeName() const {
-  return "onnx.DeviceConfigurationProto";
-}
-
-
-// ===================================================================
-
-void StringStringEntryProto::InitAsDefaultInstance() {
-}
-class StringStringEntryProto::_Internal {
- public:
-};
-
-StringStringEntryProto::StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.StringStringEntryProto)
-}
-StringStringEntryProto::StringStringEntryProto(const StringStringEntryProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_key().empty()) {
-    key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_key(),
-      GetArena());
-  }
-  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_value().empty()) {
-    value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_value(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.StringStringEntryProto)
-}
-
-void StringStringEntryProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringStringEntryProto_onnx_2eproto3.base);
-  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-StringStringEntryProto::~StringStringEntryProto() {
-  // @@protoc_insertion_point(destructor:onnx.StringStringEntryProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void StringStringEntryProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void StringStringEntryProto::ArenaDtor(void* object) {
-  StringStringEntryProto* _this = reinterpret_cast< StringStringEntryProto* >(object);
-  (void)_this;
-}
-void StringStringEntryProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void StringStringEntryProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const StringStringEntryProto& StringStringEntryProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StringStringEntryProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void StringStringEntryProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.StringStringEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  value_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* StringStringEntryProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string key = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_key();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string value = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_value();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* StringStringEntryProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.StringStringEntryProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string key = 1;
-  if (this->key().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.StringStringEntryProto.key");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_key(), target);
-  }
-
-  // string value = 2;
-  if (this->value().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.StringStringEntryProto.value");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_value(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.StringStringEntryProto)
-  return target;
-}
-
-size_t StringStringEntryProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.StringStringEntryProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string key = 1;
-  if (this->key().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_key());
-  }
-
-  // string value = 2;
-  if (this->value().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_value());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void StringStringEntryProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const StringStringEntryProto*>(
-      &from));
-}
-
-void StringStringEntryProto::MergeFrom(const StringStringEntryProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.StringStringEntryProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.key().size() > 0) {
-    _internal_set_key(from._internal_key());
-  }
-  if (from.value().size() > 0) {
-    _internal_set_value(from._internal_value());
-  }
-}
-
-void StringStringEntryProto::CopyFrom(const StringStringEntryProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.StringStringEntryProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool StringStringEntryProto::IsInitialized() const {
-  return true;
-}
-
-void StringStringEntryProto::InternalSwap(StringStringEntryProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string StringStringEntryProto::GetTypeName() const {
-  return "onnx.StringStringEntryProto";
-}
-
-
-// ===================================================================
-
-void TensorAnnotation::InitAsDefaultInstance() {
-}
-class TensorAnnotation::_Internal {
- public:
-};
-
-TensorAnnotation::TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  quant_parameter_tensor_names_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorAnnotation)
-}
-TensorAnnotation::TensorAnnotation(const TensorAnnotation& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      quant_parameter_tensor_names_(from.quant_parameter_tensor_names_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_tensor_name().empty()) {
-    tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_tensor_name(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorAnnotation)
-}
-
-void TensorAnnotation::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorAnnotation_onnx_2eproto3.base);
-  tensor_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-TensorAnnotation::~TensorAnnotation() {
-  // @@protoc_insertion_point(destructor:onnx.TensorAnnotation)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorAnnotation::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  tensor_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void TensorAnnotation::ArenaDtor(void* object) {
-  TensorAnnotation* _this = reinterpret_cast< TensorAnnotation* >(object);
-  (void)_this;
-}
-void TensorAnnotation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorAnnotation::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorAnnotation& TensorAnnotation::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorAnnotation_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TensorAnnotation::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorAnnotation)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  quant_parameter_tensor_names_.Clear();
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorAnnotation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string tensor_name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_tensor_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_quant_parameter_tensor_names(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorAnnotation::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorAnnotation)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string tensor_name = 1;
-  if (this->tensor_name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_tensor_name().data(), static_cast<int>(this->_internal_tensor_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TensorAnnotation.tensor_name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_tensor_name(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_quant_parameter_tensor_names_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, this->_internal_quant_parameter_tensor_names(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorAnnotation)
-  return target;
-}
-
-size_t TensorAnnotation::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorAnnotation)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  total_size += 1UL * this->_internal_quant_parameter_tensor_names_size();
-  for (const auto& msg : this->quant_parameter_tensor_names_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string tensor_name = 1;
-  if (this->tensor_name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_tensor_name());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorAnnotation::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorAnnotation*>(
-      &from));
-}
-
-void TensorAnnotation::MergeFrom(const TensorAnnotation& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorAnnotation)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  quant_parameter_tensor_names_.MergeFrom(from.quant_parameter_tensor_names_);
-  if (from.tensor_name().size() > 0) {
-    _internal_set_tensor_name(from._internal_tensor_name());
-  }
-}
-
-void TensorAnnotation::CopyFrom(const TensorAnnotation& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorAnnotation)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorAnnotation::IsInitialized() const {
-  return true;
-}
-
-void TensorAnnotation::InternalSwap(TensorAnnotation* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  quant_parameter_tensor_names_.InternalSwap(&other->quant_parameter_tensor_names_);
-  tensor_name_.Swap(&other->tensor_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string TensorAnnotation::GetTypeName() const {
-  return "onnx.TensorAnnotation";
-}
-
-
-// ===================================================================
-
-void GraphProto::InitAsDefaultInstance() {
-}
-class GraphProto::_Internal {
- public:
-};
-
-GraphProto::GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  node_(arena),
-  initializer_(arena),
-  input_(arena),
-  output_(arena),
-  value_info_(arena),
-  quantization_annotation_(arena),
-  sparse_initializer_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.GraphProto)
-}
-GraphProto::GraphProto(const GraphProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      node_(from.node_),
-      initializer_(from.initializer_),
-      input_(from.input_),
-      output_(from.output_),
-      value_info_(from.value_info_),
-      quantization_annotation_(from.quantization_annotation_),
-      sparse_initializer_(from.sparse_initializer_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.GraphProto)
-}
-
-void GraphProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttributeProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-GraphProto::~GraphProto() {
-  // @@protoc_insertion_point(destructor:onnx.GraphProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void GraphProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GraphProto::ArenaDtor(void* object) {
-  GraphProto* _this = reinterpret_cast< GraphProto* >(object);
-  (void)_this;
-}
-void GraphProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GraphProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const GraphProto& GraphProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttributeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void GraphProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.GraphProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  node_.Clear();
-  initializer_.Clear();
-  input_.Clear();
-  output_.Clear();
-  value_info_.Clear();
-  quantization_annotation_.Clear();
-  sparse_initializer_.Clear();
-  metadata_props_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* GraphProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated .onnx.NodeProto node = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_node(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorProto initializer = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_initializer(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto input = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_input(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto output = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_output(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto value_info = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_value_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_quantization_annotation(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-      case 15:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_sparse_initializer(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 16;
-      case 16:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* GraphProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.GraphProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated .onnx.NodeProto node = 1;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_node_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, this->_internal_node(i), target, stream);
-  }
-
-  // string name = 2;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.GraphProto.name");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_name(), target);
-  }
-
-  // repeated .onnx.TensorProto initializer = 5;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_initializer_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(5, this->_internal_initializer(i), target, stream);
-  }
-
-  // string doc_string = 10;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.GraphProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        10, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_input_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_input(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_output_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(12, this->_internal_output(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_value_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(13, this->_internal_value_info(i), target, stream);
-  }
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_quantization_annotation_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_quantization_annotation(i), target, stream);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_sparse_initializer_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(15, this->_internal_sparse_initializer(i), target, stream);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(16, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.GraphProto)
-  return target;
-}
-
-size_t GraphProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.GraphProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.NodeProto node = 1;
-  total_size += 1UL * this->_internal_node_size();
-  for (const auto& msg : this->node_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TensorProto initializer = 5;
-  total_size += 1UL * this->_internal_initializer_size();
-  for (const auto& msg : this->initializer_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  total_size += 1UL * this->_internal_input_size();
-  for (const auto& msg : this->input_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  total_size += 1UL * this->_internal_output_size();
-  for (const auto& msg : this->output_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  total_size += 1UL * this->_internal_value_info_size();
-  for (const auto& msg : this->value_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  total_size += 1UL * this->_internal_quantization_annotation_size();
-  for (const auto& msg : this->quantization_annotation_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  total_size += 1UL * this->_internal_sparse_initializer_size();
-  for (const auto& msg : this->sparse_initializer_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  total_size += 2UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 2;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // string doc_string = 10;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void GraphProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const GraphProto*>(
-      &from));
-}
-
-void GraphProto::MergeFrom(const GraphProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.GraphProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  node_.MergeFrom(from.node_);
-  initializer_.MergeFrom(from.initializer_);
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  value_info_.MergeFrom(from.value_info_);
-  quantization_annotation_.MergeFrom(from.quantization_annotation_);
-  sparse_initializer_.MergeFrom(from.sparse_initializer_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-}
-
-void GraphProto::CopyFrom(const GraphProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.GraphProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GraphProto::IsInitialized() const {
-  return true;
-}
-
-void GraphProto::InternalSwap(GraphProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  node_.InternalSwap(&other->node_);
-  initializer_.InternalSwap(&other->initializer_);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  value_info_.InternalSwap(&other->value_info_);
-  quantization_annotation_.InternalSwap(&other->quantization_annotation_);
-  sparse_initializer_.InternalSwap(&other->sparse_initializer_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string GraphProto::GetTypeName() const {
-  return "onnx.GraphProto";
-}
-
-
-// ===================================================================
-
-void TensorProto_Segment::InitAsDefaultInstance() {
-}
-class TensorProto_Segment::_Internal {
- public:
-};
-
-TensorProto_Segment::TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorProto.Segment)
-}
-TensorProto_Segment::TensorProto_Segment(const TensorProto_Segment& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::memcpy(&begin_, &from.begin_,
-    static_cast<size_t>(reinterpret_cast<char*>(&end_) -
-    reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorProto.Segment)
-}
-
-void TensorProto_Segment::SharedCtor() {
-  ::memset(&begin_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&end_) -
-      reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-}
-
-TensorProto_Segment::~TensorProto_Segment() {
-  // @@protoc_insertion_point(destructor:onnx.TensorProto.Segment)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorProto_Segment::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void TensorProto_Segment::ArenaDtor(void* object) {
-  TensorProto_Segment* _this = reinterpret_cast< TensorProto_Segment* >(object);
-  (void)_this;
-}
-void TensorProto_Segment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorProto_Segment::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorProto_Segment& TensorProto_Segment::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorProto_Segment_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TensorProto_Segment::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorProto.Segment)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  ::memset(&begin_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&end_) -
-      reinterpret_cast<char*>(&begin_)) + sizeof(end_));
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorProto_Segment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 begin = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int64 end = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorProto_Segment::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto.Segment)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 begin = 1;
-  if (this->begin() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_begin(), target);
-  }
-
-  // int64 end = 2;
-  if (this->end() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_end(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto.Segment)
-  return target;
-}
-
-size_t TensorProto_Segment::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto.Segment)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // int64 begin = 1;
-  if (this->begin() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_begin());
-  }
-
-  // int64 end = 2;
-  if (this->end() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_end());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorProto_Segment::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorProto_Segment*>(
-      &from));
-}
-
-void TensorProto_Segment::MergeFrom(const TensorProto_Segment& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto.Segment)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.begin() != 0) {
-    _internal_set_begin(from._internal_begin());
-  }
-  if (from.end() != 0) {
-    _internal_set_end(from._internal_end());
-  }
-}
-
-void TensorProto_Segment::CopyFrom(const TensorProto_Segment& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto.Segment)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorProto_Segment::IsInitialized() const {
-  return true;
-}
-
-void TensorProto_Segment::InternalSwap(TensorProto_Segment* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TensorProto_Segment, end_)
-      + sizeof(TensorProto_Segment::end_)
-      - PROTOBUF_FIELD_OFFSET(TensorProto_Segment, begin_)>(
-          reinterpret_cast<char*>(&begin_),
-          reinterpret_cast<char*>(&other->begin_));
-}
-
-std::string TensorProto_Segment::GetTypeName() const {
-  return "onnx.TensorProto.Segment";
-}
-
-
-// ===================================================================
-
-void TensorProto::InitAsDefaultInstance() {
-  ::onnx::_TensorProto_default_instance_._instance.get_mutable()->segment_ = const_cast< ::onnx::TensorProto_Segment*>(
-      ::onnx::TensorProto_Segment::internal_default_instance());
-}
-class TensorProto::_Internal {
- public:
-  static const ::onnx::TensorProto_Segment& segment(const TensorProto* msg);
-};
-
-const ::onnx::TensorProto_Segment&
-TensorProto::_Internal::segment(const TensorProto* msg) {
-  return *msg->segment_;
-}
-TensorProto::TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dims_(arena),
-  float_data_(arena),
-  int32_data_(arena),
-  string_data_(arena),
-  int64_data_(arena),
-  double_data_(arena),
-  uint64_data_(arena),
-  external_data_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorProto)
-}
-TensorProto::TensorProto(const TensorProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      dims_(from.dims_),
-      float_data_(from.float_data_),
-      int32_data_(from.int32_data_),
-      string_data_(from.string_data_),
-      int64_data_(from.int64_data_),
-      double_data_(from.double_data_),
-      uint64_data_(from.uint64_data_),
-      external_data_(from.external_data_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_raw_data().empty()) {
-    raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_raw_data(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  if (from._internal_has_segment()) {
-    segment_ = new ::onnx::TensorProto_Segment(*from.segment_);
-  } else {
-    segment_ = nullptr;
-  }
-  ::memcpy(&data_type_, &from.data_type_,
-    static_cast<size_t>(reinterpret_cast<char*>(&data_location_) -
-    reinterpret_cast<char*>(&data_type_)) + sizeof(data_location_));
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorProto)
-}
-
-void TensorProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&segment_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&data_location_) -
-      reinterpret_cast<char*>(&segment_)) + sizeof(data_location_));
-}
-
-TensorProto::~TensorProto() {
-  // @@protoc_insertion_point(destructor:onnx.TensorProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  raw_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete segment_;
-}
-
-void TensorProto::ArenaDtor(void* object) {
-  TensorProto* _this = reinterpret_cast< TensorProto* >(object);
-  (void)_this;
-}
-void TensorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorProto& TensorProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TensorProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dims_.Clear();
-  float_data_.Clear();
-  int32_data_.Clear();
-  string_data_.Clear();
-  int64_data_.Clear();
-  double_data_.Clear();
-  uint64_data_.Clear();
-  external_data_.Clear();
-  metadata_props_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  raw_data_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  if (GetArena() == nullptr && segment_ != nullptr) {
-    delete segment_;
-  }
-  segment_ = nullptr;
-  ::memset(&data_type_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&data_location_) -
-      reinterpret_cast<char*>(&data_type_)) + sizeof(data_location_));
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated int64 dims = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dims(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) {
-          _internal_add_dims(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int32 data_type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          data_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorProto.Segment segment = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr = ctx->ParseMessage(_internal_mutable_segment(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated float float_data = 4 [packed = true];
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_float_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) {
-          _internal_add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
-          ptr += sizeof(float);
-        } else goto handle_unusual;
-        continue;
-      // repeated int32 int32_data = 5 [packed = true];
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_int32_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40) {
-          _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated bytes string_data = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_string_data();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 int64_data = 7 [packed = true];
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_int64_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56) {
-          _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string name = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // bytes raw_data = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          auto str = _internal_mutable_raw_data();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated double double_data = 10 [packed = true];
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 81) {
-          _internal_add_double_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
-          ptr += sizeof(double);
-        } else goto handle_unusual;
-        continue;
-      // repeated uint64 uint64_data = 11 [packed = true];
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_uint64_data(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88) {
-          _internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto external_data = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_external_data(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorProto.DataLocation data_location = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
-          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-          _internal_set_data_location(static_cast<::onnx::TensorProto_DataLocation>(val));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 16;
-      case 16:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
-          ptr -= 2;
-          do {
-            ptr += 2;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 1;
-  {
-    int byte_size = _dims_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          1, _internal_dims(), byte_size, target);
-    }
-  }
-
-  // int32 data_type = 2;
-  if (this->data_type() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_data_type(), target);
-  }
-
-  // .onnx.TensorProto.Segment segment = 3;
-  if (this->has_segment()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        3, _Internal::segment(this), target, stream);
-  }
-
-  // repeated float float_data = 4 [packed = true];
-  if (this->_internal_float_data_size() > 0) {
-    target = stream->WriteFixedPacked(4, _internal_float_data(), target);
-  }
-
-  // repeated int32 int32_data = 5 [packed = true];
-  {
-    int byte_size = _int32_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt32Packed(
-          5, _internal_int32_data(), byte_size, target);
-    }
-  }
-
-  // repeated bytes string_data = 6;
-  for (int i = 0, n = this->_internal_string_data_size(); i < n; i++) {
-    const auto& s = this->_internal_string_data(i);
-    target = stream->WriteBytes(6, s, target);
-  }
-
-  // repeated int64 int64_data = 7 [packed = true];
-  {
-    int byte_size = _int64_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          7, _internal_int64_data(), byte_size, target);
-    }
-  }
-
-  // string name = 8;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TensorProto.name");
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_name(), target);
-  }
-
-  // bytes raw_data = 9;
-  if (this->raw_data().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
-        9, this->_internal_raw_data(), target);
-  }
-
-  // repeated double double_data = 10 [packed = true];
-  if (this->_internal_double_data_size() > 0) {
-    target = stream->WriteFixedPacked(10, _internal_double_data(), target);
-  }
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  {
-    int byte_size = _uint64_data_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteUInt64Packed(
-          11, _internal_uint64_data(), byte_size, target);
-    }
-  }
-
-  // string doc_string = 12;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TensorProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        12, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_external_data_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(13, this->_internal_external_data(i), target, stream);
-  }
-
-  // .onnx.TensorProto.DataLocation data_location = 14;
-  if (this->data_location() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
-      14, this->_internal_data_location(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(16, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto)
-  return target;
-}
-
-size_t TensorProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 1;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->dims_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _dims_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated float float_data = 4 [packed = true];
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_float_data_size());
-    size_t data_size = 4UL * count;
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _float_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated int32 int32_data = 5 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int32Size(this->int32_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _int32_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated bytes string_data = 6;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_data_.size());
-  for (int i = 0, n = string_data_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      string_data_.Get(i));
-  }
-
-  // repeated int64 int64_data = 7 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->int64_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _int64_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated double double_data = 10 [packed = true];
-  {
-    unsigned int count = static_cast<unsigned int>(this->_internal_double_data_size());
-    size_t data_size = 8UL * count;
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _double_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      UInt64Size(this->uint64_data_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _uint64_data_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  total_size += 1UL * this->_internal_external_data_size();
-  for (const auto& msg : this->external_data_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  total_size += 2UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 8;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // bytes raw_data = 9;
-  if (this->raw_data().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_raw_data());
-  }
-
-  // string doc_string = 12;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // .onnx.TensorProto.Segment segment = 3;
-  if (this->has_segment()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *segment_);
-  }
-
-  // int32 data_type = 2;
-  if (this->data_type() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_data_type());
-  }
-
-  // .onnx.TensorProto.DataLocation data_location = 14;
-  if (this->data_location() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_data_location());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorProto*>(
-      &from));
-}
-
-void TensorProto::MergeFrom(const TensorProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dims_.MergeFrom(from.dims_);
-  float_data_.MergeFrom(from.float_data_);
-  int32_data_.MergeFrom(from.int32_data_);
-  string_data_.MergeFrom(from.string_data_);
-  int64_data_.MergeFrom(from.int64_data_);
-  double_data_.MergeFrom(from.double_data_);
-  uint64_data_.MergeFrom(from.uint64_data_);
-  external_data_.MergeFrom(from.external_data_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.raw_data().size() > 0) {
-    _internal_set_raw_data(from._internal_raw_data());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.has_segment()) {
-    _internal_mutable_segment()->::onnx::TensorProto_Segment::MergeFrom(from._internal_segment());
-  }
-  if (from.data_type() != 0) {
-    _internal_set_data_type(from._internal_data_type());
-  }
-  if (from.data_location() != 0) {
-    _internal_set_data_location(from._internal_data_location());
-  }
-}
-
-void TensorProto::CopyFrom(const TensorProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorProto::IsInitialized() const {
-  return true;
-}
-
-void TensorProto::InternalSwap(TensorProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  dims_.InternalSwap(&other->dims_);
-  float_data_.InternalSwap(&other->float_data_);
-  int32_data_.InternalSwap(&other->int32_data_);
-  string_data_.InternalSwap(&other->string_data_);
-  int64_data_.InternalSwap(&other->int64_data_);
-  double_data_.InternalSwap(&other->double_data_);
-  uint64_data_.InternalSwap(&other->uint64_data_);
-  external_data_.InternalSwap(&other->external_data_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  raw_data_.Swap(&other->raw_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TensorProto, data_location_)
-      + sizeof(TensorProto::data_location_)
-      - PROTOBUF_FIELD_OFFSET(TensorProto, segment_)>(
-          reinterpret_cast<char*>(&segment_),
-          reinterpret_cast<char*>(&other->segment_));
-}
-
-std::string TensorProto::GetTypeName() const {
-  return "onnx.TensorProto";
-}
-
-
-// ===================================================================
-
-void SparseTensorProto::InitAsDefaultInstance() {
-  ::onnx::_SparseTensorProto_default_instance_._instance.get_mutable()->values_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-  ::onnx::_SparseTensorProto_default_instance_._instance.get_mutable()->indices_ = const_cast< ::onnx::TensorProto*>(
-      ::onnx::TensorProto::internal_default_instance());
-}
-class SparseTensorProto::_Internal {
- public:
-  static const ::onnx::TensorProto& values(const SparseTensorProto* msg);
-  static const ::onnx::TensorProto& indices(const SparseTensorProto* msg);
-};
-
-const ::onnx::TensorProto&
-SparseTensorProto::_Internal::values(const SparseTensorProto* msg) {
-  return *msg->values_;
-}
-const ::onnx::TensorProto&
-SparseTensorProto::_Internal::indices(const SparseTensorProto* msg) {
-  return *msg->indices_;
-}
-SparseTensorProto::SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dims_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.SparseTensorProto)
-}
-SparseTensorProto::SparseTensorProto(const SparseTensorProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      dims_(from.dims_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_values()) {
-    values_ = new ::onnx::TensorProto(*from.values_);
-  } else {
-    values_ = nullptr;
-  }
-  if (from._internal_has_indices()) {
-    indices_ = new ::onnx::TensorProto(*from.indices_);
-  } else {
-    indices_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.SparseTensorProto)
-}
-
-void SparseTensorProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SparseTensorProto_onnx_2eproto3.base);
-  ::memset(&values_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&indices_) -
-      reinterpret_cast<char*>(&values_)) + sizeof(indices_));
-}
-
-SparseTensorProto::~SparseTensorProto() {
-  // @@protoc_insertion_point(destructor:onnx.SparseTensorProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void SparseTensorProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete values_;
-  if (this != internal_default_instance()) delete indices_;
-}
-
-void SparseTensorProto::ArenaDtor(void* object) {
-  SparseTensorProto* _this = reinterpret_cast< SparseTensorProto* >(object);
-  (void)_this;
-}
-void SparseTensorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void SparseTensorProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const SparseTensorProto& SparseTensorProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SparseTensorProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void SparseTensorProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.SparseTensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dims_.Clear();
-  if (GetArena() == nullptr && values_ != nullptr) {
-    delete values_;
-  }
-  values_ = nullptr;
-  if (GetArena() == nullptr && indices_ != nullptr) {
-    delete indices_;
-  }
-  indices_ = nullptr;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* SparseTensorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.TensorProto values = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_values(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorProto indices = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_indices(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated int64 dims = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_dims(), ptr, ctx);
-          CHK_(ptr);
-        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
-          _internal_add_dims(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* SparseTensorProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.SparseTensorProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .onnx.TensorProto values = 1;
-  if (this->has_values()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::values(this), target, stream);
-  }
-
-  // .onnx.TensorProto indices = 2;
-  if (this->has_indices()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::indices(this), target, stream);
-  }
-
-  // repeated int64 dims = 3;
-  {
-    int byte_size = _dims_cached_byte_size_.load(std::memory_order_relaxed);
-    if (byte_size > 0) {
-      target = stream->WriteInt64Packed(
-          3, _internal_dims(), byte_size, target);
-    }
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.SparseTensorProto)
-  return target;
-}
-
-size_t SparseTensorProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.SparseTensorProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated int64 dims = 3;
-  {
-    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      Int64Size(this->dims_);
-    if (data_size > 0) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
-    }
-    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
-    _dims_cached_byte_size_.store(cached_size,
-                                    std::memory_order_relaxed);
-    total_size += data_size;
-  }
-
-  // .onnx.TensorProto values = 1;
-  if (this->has_values()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *values_);
-  }
-
-  // .onnx.TensorProto indices = 2;
-  if (this->has_indices()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *indices_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void SparseTensorProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SparseTensorProto*>(
-      &from));
-}
-
-void SparseTensorProto::MergeFrom(const SparseTensorProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.SparseTensorProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dims_.MergeFrom(from.dims_);
-  if (from.has_values()) {
-    _internal_mutable_values()->::onnx::TensorProto::MergeFrom(from._internal_values());
-  }
-  if (from.has_indices()) {
-    _internal_mutable_indices()->::onnx::TensorProto::MergeFrom(from._internal_indices());
-  }
-}
-
-void SparseTensorProto::CopyFrom(const SparseTensorProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.SparseTensorProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SparseTensorProto::IsInitialized() const {
-  return true;
-}
-
-void SparseTensorProto::InternalSwap(SparseTensorProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  dims_.InternalSwap(&other->dims_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(SparseTensorProto, indices_)
-      + sizeof(SparseTensorProto::indices_)
-      - PROTOBUF_FIELD_OFFSET(SparseTensorProto, values_)>(
-          reinterpret_cast<char*>(&values_),
-          reinterpret_cast<char*>(&other->values_));
-}
-
-std::string SparseTensorProto::GetTypeName() const {
-  return "onnx.SparseTensorProto";
-}
-
-
-// ===================================================================
-
-void TensorShapeProto_Dimension::InitAsDefaultInstance() {
-}
-class TensorShapeProto_Dimension::_Internal {
- public:
-};
-
-TensorShapeProto_Dimension::TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto.Dimension)
-}
-TensorShapeProto_Dimension::TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_denotation().empty()) {
-    denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_denotation(),
-      GetArena());
-  }
-  clear_has_value();
-  switch (from.value_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto.Dimension)
-}
-
-void TensorShapeProto_Dimension::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorShapeProto_Dimension_onnx_2eproto3.base);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  clear_has_value();
-}
-
-TensorShapeProto_Dimension::~TensorShapeProto_Dimension() {
-  // @@protoc_insertion_point(destructor:onnx.TensorShapeProto.Dimension)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorShapeProto_Dimension::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  denotation_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (has_value()) {
-    clear_value();
-  }
-}
-
-void TensorShapeProto_Dimension::ArenaDtor(void* object) {
-  TensorShapeProto_Dimension* _this = reinterpret_cast< TensorShapeProto_Dimension* >(object);
-  (void)_this;
-}
-void TensorShapeProto_Dimension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorShapeProto_Dimension::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorShapeProto_Dimension& TensorShapeProto_Dimension::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorShapeProto_Dimension_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TensorShapeProto_Dimension::clear_value() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.TensorShapeProto.Dimension)
-  switch (value_case()) {
-    case kDimValue: {
-      // No need to clear
-      break;
-    }
-    case kDimParam: {
-      value_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-
-
-void TensorShapeProto_Dimension::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto.Dimension)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  clear_value();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorShapeProto_Dimension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int64 dim_value = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string dim_param = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_dim_param();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string denotation = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_denotation();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorShapeProto_Dimension::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto.Dimension)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int64 dim_value = 1;
-  if (_internal_has_dim_value()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_dim_value(), target);
-  }
-
-  // string dim_param = 2;
-  if (_internal_has_dim_param()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_dim_param().data(), static_cast<int>(this->_internal_dim_param().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TensorShapeProto.Dimension.dim_param");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_dim_param(), target);
-  }
-
-  // string denotation = 3;
-  if (this->denotation().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_denotation().data(), static_cast<int>(this->_internal_denotation().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TensorShapeProto.Dimension.denotation");
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_denotation(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto.Dimension)
-  return target;
-}
-
-size_t TensorShapeProto_Dimension::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto.Dimension)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string denotation = 3;
-  if (this->denotation().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_denotation());
-  }
-
-  switch (value_case()) {
-    // int64 dim_value = 1;
-    case kDimValue: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-          this->_internal_dim_value());
-      break;
-    }
-    // string dim_param = 2;
-    case kDimParam: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorShapeProto_Dimension::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorShapeProto_Dimension*>(
-      &from));
-}
-
-void TensorShapeProto_Dimension::MergeFrom(const TensorShapeProto_Dimension& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto.Dimension)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.denotation().size() > 0) {
-    _internal_set_denotation(from._internal_denotation());
-  }
-  switch (from.value_case()) {
-    case kDimValue: {
-      _internal_set_dim_value(from._internal_dim_value());
-      break;
-    }
-    case kDimParam: {
-      _internal_set_dim_param(from._internal_dim_param());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void TensorShapeProto_Dimension::CopyFrom(const TensorShapeProto_Dimension& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto.Dimension)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorShapeProto_Dimension::IsInitialized() const {
-  return true;
-}
-
-void TensorShapeProto_Dimension::InternalSwap(TensorShapeProto_Dimension* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  denotation_.Swap(&other->denotation_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(value_, other->value_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string TensorShapeProto_Dimension::GetTypeName() const {
-  return "onnx.TensorShapeProto.Dimension";
-}
-
-
-// ===================================================================
-
-void TensorShapeProto::InitAsDefaultInstance() {
-}
-class TensorShapeProto::_Internal {
- public:
-};
-
-TensorShapeProto::TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  dim_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto)
-}
-TensorShapeProto::TensorShapeProto(const TensorShapeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      dim_(from.dim_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto)
-}
-
-void TensorShapeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TensorShapeProto_onnx_2eproto3.base);
-}
-
-TensorShapeProto::~TensorShapeProto() {
-  // @@protoc_insertion_point(destructor:onnx.TensorShapeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TensorShapeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void TensorShapeProto::ArenaDtor(void* object) {
-  TensorShapeProto* _this = reinterpret_cast< TensorShapeProto* >(object);
-  (void)_this;
-}
-void TensorShapeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TensorShapeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TensorShapeProto& TensorShapeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TensorShapeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TensorShapeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  dim_.Clear();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TensorShapeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_dim(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TensorShapeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_dim_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, this->_internal_dim(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto)
-  return target;
-}
-
-size_t TensorShapeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  total_size += 1UL * this->_internal_dim_size();
-  for (const auto& msg : this->dim_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TensorShapeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TensorShapeProto*>(
-      &from));
-}
-
-void TensorShapeProto::MergeFrom(const TensorShapeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  dim_.MergeFrom(from.dim_);
-}
-
-void TensorShapeProto::CopyFrom(const TensorShapeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TensorShapeProto::IsInitialized() const {
-  return true;
-}
-
-void TensorShapeProto::InternalSwap(TensorShapeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  dim_.InternalSwap(&other->dim_);
-}
-
-std::string TensorShapeProto::GetTypeName() const {
-  return "onnx.TensorShapeProto";
-}
-
-
-// ===================================================================
-
-void TypeProto_Tensor::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Tensor_default_instance_._instance.get_mutable()->shape_ = const_cast< ::onnx::TensorShapeProto*>(
-      ::onnx::TensorShapeProto::internal_default_instance());
-}
-class TypeProto_Tensor::_Internal {
- public:
-  static const ::onnx::TensorShapeProto& shape(const TypeProto_Tensor* msg);
-};
-
-const ::onnx::TensorShapeProto&
-TypeProto_Tensor::_Internal::shape(const TypeProto_Tensor* msg) {
-  return *msg->shape_;
-}
-TypeProto_Tensor::TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Tensor)
-}
-TypeProto_Tensor::TypeProto_Tensor(const TypeProto_Tensor& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_shape()) {
-    shape_ = new ::onnx::TensorShapeProto(*from.shape_);
-  } else {
-    shape_ = nullptr;
-  }
-  elem_type_ = from.elem_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Tensor)
-}
-
-void TypeProto_Tensor::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_Tensor_onnx_2eproto3.base);
-  ::memset(&shape_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&elem_type_) -
-      reinterpret_cast<char*>(&shape_)) + sizeof(elem_type_));
-}
-
-TypeProto_Tensor::~TypeProto_Tensor() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Tensor)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Tensor::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete shape_;
-}
-
-void TypeProto_Tensor::ArenaDtor(void* object) {
-  TypeProto_Tensor* _this = reinterpret_cast< TypeProto_Tensor* >(object);
-  (void)_this;
-}
-void TypeProto_Tensor::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Tensor::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Tensor& TypeProto_Tensor::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_Tensor_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Tensor::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Tensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  if (GetArena() == nullptr && shape_ != nullptr) {
-    delete shape_;
-  }
-  shape_ = nullptr;
-  elem_type_ = 0;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Tensor::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int32 elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorShapeProto shape = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Tensor::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Tensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int32 elem_type = 1;
-  if (this->elem_type() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_elem_type(), target);
-  }
-
-  // .onnx.TensorShapeProto shape = 2;
-  if (this->has_shape()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::shape(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Tensor)
-  return target;
-}
-
-size_t TypeProto_Tensor::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Tensor)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // .onnx.TensorShapeProto shape = 2;
-  if (this->has_shape()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *shape_);
-  }
-
-  // int32 elem_type = 1;
-  if (this->elem_type() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_elem_type());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Tensor::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Tensor*>(
-      &from));
-}
-
-void TypeProto_Tensor::MergeFrom(const TypeProto_Tensor& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Tensor)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.has_shape()) {
-    _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom(from._internal_shape());
-  }
-  if (from.elem_type() != 0) {
-    _internal_set_elem_type(from._internal_elem_type());
-  }
-}
-
-void TypeProto_Tensor::CopyFrom(const TypeProto_Tensor& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Tensor)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Tensor::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Tensor::InternalSwap(TypeProto_Tensor* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, elem_type_)
-      + sizeof(TypeProto_Tensor::elem_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, shape_)>(
-          reinterpret_cast<char*>(&shape_),
-          reinterpret_cast<char*>(&other->shape_));
-}
-
-std::string TypeProto_Tensor::GetTypeName() const {
-  return "onnx.TypeProto.Tensor";
-}
-
-
-// ===================================================================
-
-void TypeProto_Sequence::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Sequence_default_instance_._instance.get_mutable()->elem_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Sequence::_Internal {
- public:
-  static const ::onnx::TypeProto& elem_type(const TypeProto_Sequence* msg);
-};
-
-const ::onnx::TypeProto&
-TypeProto_Sequence::_Internal::elem_type(const TypeProto_Sequence* msg) {
-  return *msg->elem_type_;
-}
-TypeProto_Sequence::TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Sequence)
-}
-TypeProto_Sequence::TypeProto_Sequence(const TypeProto_Sequence& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_elem_type()) {
-    elem_type_ = new ::onnx::TypeProto(*from.elem_type_);
-  } else {
-    elem_type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Sequence)
-}
-
-void TypeProto_Sequence::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto3.base);
-  elem_type_ = nullptr;
-}
-
-TypeProto_Sequence::~TypeProto_Sequence() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Sequence)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Sequence::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete elem_type_;
-}
-
-void TypeProto_Sequence::ArenaDtor(void* object) {
-  TypeProto_Sequence* _this = reinterpret_cast< TypeProto_Sequence* >(object);
-  (void)_this;
-}
-void TypeProto_Sequence::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Sequence::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Sequence& TypeProto_Sequence::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Sequence::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Sequence)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  if (GetArena() == nullptr && elem_type_ != nullptr) {
-    delete elem_type_;
-  }
-  elem_type_ = nullptr;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Sequence::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.TypeProto elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Sequence::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Sequence)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto elem_type = 1;
-  if (this->has_elem_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::elem_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Sequence)
-  return target;
-}
-
-size_t TypeProto_Sequence::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Sequence)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto elem_type = 1;
-  if (this->has_elem_type()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *elem_type_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Sequence::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Sequence*>(
-      &from));
-}
-
-void TypeProto_Sequence::MergeFrom(const TypeProto_Sequence& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Sequence)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.has_elem_type()) {
-    _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom(from._internal_elem_type());
-  }
-}
-
-void TypeProto_Sequence::CopyFrom(const TypeProto_Sequence& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Sequence)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Sequence::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Sequence::InternalSwap(TypeProto_Sequence* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(elem_type_, other->elem_type_);
-}
-
-std::string TypeProto_Sequence::GetTypeName() const {
-  return "onnx.TypeProto.Sequence";
-}
-
-
-// ===================================================================
-
-void TypeProto_Map::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Map_default_instance_._instance.get_mutable()->value_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Map::_Internal {
- public:
-  static const ::onnx::TypeProto& value_type(const TypeProto_Map* msg);
-};
-
-const ::onnx::TypeProto&
-TypeProto_Map::_Internal::value_type(const TypeProto_Map* msg) {
-  return *msg->value_type_;
-}
-TypeProto_Map::TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Map)
-}
-TypeProto_Map::TypeProto_Map(const TypeProto_Map& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_value_type()) {
-    value_type_ = new ::onnx::TypeProto(*from.value_type_);
-  } else {
-    value_type_ = nullptr;
-  }
-  key_type_ = from.key_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Map)
-}
-
-void TypeProto_Map::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto3.base);
-  ::memset(&value_type_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&key_type_) -
-      reinterpret_cast<char*>(&value_type_)) + sizeof(key_type_));
-}
-
-TypeProto_Map::~TypeProto_Map() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Map)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Map::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete value_type_;
-}
-
-void TypeProto_Map::ArenaDtor(void* object) {
-  TypeProto_Map* _this = reinterpret_cast< TypeProto_Map* >(object);
-  (void)_this;
-}
-void TypeProto_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Map::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Map& TypeProto_Map::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Map::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Map)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  if (GetArena() == nullptr && value_type_ != nullptr) {
-    delete value_type_;
-  }
-  value_type_ = nullptr;
-  key_type_ = 0;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int32 key_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          key_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto value_type = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_value_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Map::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Map)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int32 key_type = 1;
-  if (this->key_type() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_key_type(), target);
-  }
-
-  // .onnx.TypeProto value_type = 2;
-  if (this->has_value_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::value_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Map)
-  return target;
-}
-
-size_t TypeProto_Map::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Map)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto value_type = 2;
-  if (this->has_value_type()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *value_type_);
-  }
-
-  // int32 key_type = 1;
-  if (this->key_type() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_key_type());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Map::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Map*>(
-      &from));
-}
-
-void TypeProto_Map::MergeFrom(const TypeProto_Map& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Map)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.has_value_type()) {
-    _internal_mutable_value_type()->::onnx::TypeProto::MergeFrom(from._internal_value_type());
-  }
-  if (from.key_type() != 0) {
-    _internal_set_key_type(from._internal_key_type());
-  }
-}
-
-void TypeProto_Map::CopyFrom(const TypeProto_Map& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Map)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Map::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Map::InternalSwap(TypeProto_Map* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_Map, key_type_)
-      + sizeof(TypeProto_Map::key_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_Map, value_type_)>(
-          reinterpret_cast<char*>(&value_type_),
-          reinterpret_cast<char*>(&other->value_type_));
-}
-
-std::string TypeProto_Map::GetTypeName() const {
-  return "onnx.TypeProto.Map";
-}
-
-
-// ===================================================================
-
-void TypeProto_Optional::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_Optional_default_instance_._instance.get_mutable()->elem_type_ = const_cast< ::onnx::TypeProto*>(
-      ::onnx::TypeProto::internal_default_instance());
-}
-class TypeProto_Optional::_Internal {
- public:
-  static const ::onnx::TypeProto& elem_type(const TypeProto_Optional* msg);
-};
-
-const ::onnx::TypeProto&
-TypeProto_Optional::_Internal::elem_type(const TypeProto_Optional* msg) {
-  return *msg->elem_type_;
-}
-TypeProto_Optional::TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Optional)
-}
-TypeProto_Optional::TypeProto_Optional(const TypeProto_Optional& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_elem_type()) {
-    elem_type_ = new ::onnx::TypeProto(*from.elem_type_);
-  } else {
-    elem_type_ = nullptr;
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Optional)
-}
-
-void TypeProto_Optional::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto3.base);
-  elem_type_ = nullptr;
-}
-
-TypeProto_Optional::~TypeProto_Optional() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.Optional)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_Optional::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete elem_type_;
-}
-
-void TypeProto_Optional::ArenaDtor(void* object) {
-  TypeProto_Optional* _this = reinterpret_cast< TypeProto_Optional* >(object);
-  (void)_this;
-}
-void TypeProto_Optional::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_Optional::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_Optional& TypeProto_Optional::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_Optional::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Optional)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  if (GetArena() == nullptr && elem_type_ != nullptr) {
-    delete elem_type_;
-  }
-  elem_type_ = nullptr;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_Optional::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.TypeProto elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_Optional::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Optional)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto elem_type = 1;
-  if (this->has_elem_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::elem_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Optional)
-  return target;
-}
-
-size_t TypeProto_Optional::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Optional)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto elem_type = 1;
-  if (this->has_elem_type()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *elem_type_);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_Optional::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_Optional*>(
-      &from));
-}
-
-void TypeProto_Optional::MergeFrom(const TypeProto_Optional& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Optional)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.has_elem_type()) {
-    _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom(from._internal_elem_type());
-  }
-}
-
-void TypeProto_Optional::CopyFrom(const TypeProto_Optional& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Optional)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_Optional::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_Optional::InternalSwap(TypeProto_Optional* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  swap(elem_type_, other->elem_type_);
-}
-
-std::string TypeProto_Optional::GetTypeName() const {
-  return "onnx.TypeProto.Optional";
-}
-
-
-// ===================================================================
-
-void TypeProto_SparseTensor::InitAsDefaultInstance() {
-  ::onnx::_TypeProto_SparseTensor_default_instance_._instance.get_mutable()->shape_ = const_cast< ::onnx::TensorShapeProto*>(
-      ::onnx::TensorShapeProto::internal_default_instance());
-}
-class TypeProto_SparseTensor::_Internal {
- public:
-  static const ::onnx::TensorShapeProto& shape(const TypeProto_SparseTensor* msg);
-};
-
-const ::onnx::TensorShapeProto&
-TypeProto_SparseTensor::_Internal::shape(const TypeProto_SparseTensor* msg) {
-  return *msg->shape_;
-}
-TypeProto_SparseTensor::TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.SparseTensor)
-}
-TypeProto_SparseTensor::TypeProto_SparseTensor(const TypeProto_SparseTensor& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  if (from._internal_has_shape()) {
-    shape_ = new ::onnx::TensorShapeProto(*from.shape_);
-  } else {
-    shape_ = nullptr;
-  }
-  elem_type_ = from.elem_type_;
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.SparseTensor)
-}
-
-void TypeProto_SparseTensor::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_SparseTensor_onnx_2eproto3.base);
-  ::memset(&shape_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&elem_type_) -
-      reinterpret_cast<char*>(&shape_)) + sizeof(elem_type_));
-}
-
-TypeProto_SparseTensor::~TypeProto_SparseTensor() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto.SparseTensor)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto_SparseTensor::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  if (this != internal_default_instance()) delete shape_;
-}
-
-void TypeProto_SparseTensor::ArenaDtor(void* object) {
-  TypeProto_SparseTensor* _this = reinterpret_cast< TypeProto_SparseTensor* >(object);
-  (void)_this;
-}
-void TypeProto_SparseTensor::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto_SparseTensor::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto_SparseTensor& TypeProto_SparseTensor::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_SparseTensor_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto_SparseTensor::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto.SparseTensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  if (GetArena() == nullptr && shape_ != nullptr) {
-    delete shape_;
-  }
-  shape_ = nullptr;
-  elem_type_ = 0;
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto_SparseTensor::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // int32 elem_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
-          elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TensorShapeProto shape = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto_SparseTensor::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.SparseTensor)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // int32 elem_type = 1;
-  if (this->elem_type() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_elem_type(), target);
-  }
-
-  // .onnx.TensorShapeProto shape = 2;
-  if (this->has_shape()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::shape(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.SparseTensor)
-  return target;
-}
-
-size_t TypeProto_SparseTensor::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.SparseTensor)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // .onnx.TensorShapeProto shape = 2;
-  if (this->has_shape()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *shape_);
-  }
-
-  // int32 elem_type = 1;
-  if (this->elem_type() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
-        this->_internal_elem_type());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto_SparseTensor::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto_SparseTensor*>(
-      &from));
-}
-
-void TypeProto_SparseTensor::MergeFrom(const TypeProto_SparseTensor& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.SparseTensor)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.has_shape()) {
-    _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom(from._internal_shape());
-  }
-  if (from.elem_type() != 0) {
-    _internal_set_elem_type(from._internal_elem_type());
-  }
-}
-
-void TypeProto_SparseTensor::CopyFrom(const TypeProto_SparseTensor& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.SparseTensor)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto_SparseTensor::IsInitialized() const {
-  return true;
-}
-
-void TypeProto_SparseTensor::InternalSwap(TypeProto_SparseTensor* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, elem_type_)
-      + sizeof(TypeProto_SparseTensor::elem_type_)
-      - PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, shape_)>(
-          reinterpret_cast<char*>(&shape_),
-          reinterpret_cast<char*>(&other->shape_));
-}
-
-std::string TypeProto_SparseTensor::GetTypeName() const {
-  return "onnx.TypeProto.SparseTensor";
-}
-
-
-// ===================================================================
-
-void TypeProto::InitAsDefaultInstance() {
-}
-class TypeProto::_Internal {
- public:
-  static const ::onnx::TypeProto_Tensor& tensor_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Sequence& sequence_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Map& map_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_Optional& optional_type(const TypeProto* msg);
-  static const ::onnx::TypeProto_SparseTensor& sparse_tensor_type(const TypeProto* msg);
-};
-
-const ::onnx::TypeProto_Tensor&
-TypeProto::_Internal::tensor_type(const TypeProto* msg) {
-  return *msg->value_.tensor_type_;
-}
-const ::onnx::TypeProto_Sequence&
-TypeProto::_Internal::sequence_type(const TypeProto* msg) {
-  return *msg->value_.sequence_type_;
-}
-const ::onnx::TypeProto_Map&
-TypeProto::_Internal::map_type(const TypeProto* msg) {
-  return *msg->value_.map_type_;
-}
-const ::onnx::TypeProto_Optional&
-TypeProto::_Internal::optional_type(const TypeProto* msg) {
-  return *msg->value_.optional_type_;
-}
-const ::onnx::TypeProto_SparseTensor&
-TypeProto::_Internal::sparse_tensor_type(const TypeProto* msg) {
-  return *msg->value_.sparse_tensor_type_;
-}
-void TypeProto::set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (tensor_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tensor_type);
-    if (message_arena != submessage_arena) {
-      tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, tensor_type, submessage_arena);
-    }
-    set_has_tensor_type();
-    value_.tensor_type_ = tensor_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.tensor_type)
-}
-void TypeProto::set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (sequence_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sequence_type);
-    if (message_arena != submessage_arena) {
-      sequence_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sequence_type, submessage_arena);
-    }
-    set_has_sequence_type();
-    value_.sequence_type_ = sequence_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sequence_type)
-}
-void TypeProto::set_allocated_map_type(::onnx::TypeProto_Map* map_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (map_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_type);
-    if (message_arena != submessage_arena) {
-      map_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, map_type, submessage_arena);
-    }
-    set_has_map_type();
-    value_.map_type_ = map_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.map_type)
-}
-void TypeProto::set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (optional_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(optional_type);
-    if (message_arena != submessage_arena) {
-      optional_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, optional_type, submessage_arena);
-    }
-    set_has_optional_type();
-    value_.optional_type_ = optional_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.optional_type)
-}
-void TypeProto::set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  clear_value();
-  if (sparse_tensor_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sparse_tensor_type);
-    if (message_arena != submessage_arena) {
-      sparse_tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sparse_tensor_type, submessage_arena);
-    }
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = sparse_tensor_type;
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sparse_tensor_type)
-}
-TypeProto::TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.TypeProto)
-}
-TypeProto::TypeProto(const TypeProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_denotation().empty()) {
-    denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_denotation(),
-      GetArena());
-  }
-  clear_has_value();
-  switch (from.value_case()) {
-    case kTensorType: {
-      _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom(from._internal_tensor_type());
-      break;
-    }
-    case kSequenceType: {
-      _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom(from._internal_sequence_type());
-      break;
-    }
-    case kMapType: {
-      _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom(from._internal_map_type());
-      break;
-    }
-    case kOptionalType: {
-      _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom(from._internal_optional_type());
-      break;
-    }
-    case kSparseTensorType: {
-      _internal_mutable_sparse_tensor_type()->::onnx::TypeProto_SparseTensor::MergeFrom(from._internal_sparse_tensor_type());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.TypeProto)
-}
-
-void TypeProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeProto_onnx_2eproto3.base);
-  denotation_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  clear_has_value();
-}
-
-TypeProto::~TypeProto() {
-  // @@protoc_insertion_point(destructor:onnx.TypeProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void TypeProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  denotation_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (has_value()) {
-    clear_value();
-  }
-}
-
-void TypeProto::ArenaDtor(void* object) {
-  TypeProto* _this = reinterpret_cast< TypeProto* >(object);
-  (void)_this;
-}
-void TypeProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void TypeProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const TypeProto& TypeProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void TypeProto::clear_value() {
-// @@protoc_insertion_point(one_of_clear_start:onnx.TypeProto)
-  switch (value_case()) {
-    case kTensorType: {
-      if (GetArena() == nullptr) {
-        delete value_.tensor_type_;
-      }
-      break;
-    }
-    case kSequenceType: {
-      if (GetArena() == nullptr) {
-        delete value_.sequence_type_;
-      }
-      break;
-    }
-    case kMapType: {
-      if (GetArena() == nullptr) {
-        delete value_.map_type_;
-      }
-      break;
-    }
-    case kOptionalType: {
-      if (GetArena() == nullptr) {
-        delete value_.optional_type_;
-      }
-      break;
-    }
-    case kSparseTensorType: {
-      if (GetArena() == nullptr) {
-        delete value_.sparse_tensor_type_;
-      }
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-
-
-void TypeProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.TypeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  clear_value();
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* TypeProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // .onnx.TypeProto.Tensor tensor_type = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_tensor_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Sequence sequence_type = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sequence_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Map map_type = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr = ctx->ParseMessage(_internal_mutable_map_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // string denotation = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          auto str = _internal_mutable_denotation();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // .onnx.TypeProto.Optional optional_type = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr = ctx->ParseMessage(_internal_mutable_optional_type(), ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* TypeProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .onnx.TypeProto.Tensor tensor_type = 1;
-  if (_internal_has_tensor_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::tensor_type(this), target, stream);
-  }
-
-  // .onnx.TypeProto.Sequence sequence_type = 4;
-  if (_internal_has_sequence_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        4, _Internal::sequence_type(this), target, stream);
-  }
-
-  // .onnx.TypeProto.Map map_type = 5;
-  if (_internal_has_map_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        5, _Internal::map_type(this), target, stream);
-  }
-
-  // string denotation = 6;
-  if (this->denotation().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_denotation().data(), static_cast<int>(this->_internal_denotation().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.TypeProto.denotation");
-    target = stream->WriteStringMaybeAliased(
-        6, this->_internal_denotation(), target);
-  }
-
-  // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-  if (_internal_has_sparse_tensor_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        8, _Internal::sparse_tensor_type(this), target, stream);
-  }
-
-  // .onnx.TypeProto.Optional optional_type = 9;
-  if (_internal_has_optional_type()) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        9, _Internal::optional_type(this), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto)
-  return target;
-}
-
-size_t TypeProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string denotation = 6;
-  if (this->denotation().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_denotation());
-  }
-
-  switch (value_case()) {
-    // .onnx.TypeProto.Tensor tensor_type = 1;
-    case kTensorType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.tensor_type_);
-      break;
-    }
-    // .onnx.TypeProto.Sequence sequence_type = 4;
-    case kSequenceType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.sequence_type_);
-      break;
-    }
-    // .onnx.TypeProto.Map map_type = 5;
-    case kMapType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.map_type_);
-      break;
-    }
-    // .onnx.TypeProto.Optional optional_type = 9;
-    case kOptionalType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.optional_type_);
-      break;
-    }
-    // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-    case kSparseTensorType: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *value_.sparse_tensor_type_);
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void TypeProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TypeProto*>(
-      &from));
-}
-
-void TypeProto::MergeFrom(const TypeProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.denotation().size() > 0) {
-    _internal_set_denotation(from._internal_denotation());
-  }
-  switch (from.value_case()) {
-    case kTensorType: {
-      _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom(from._internal_tensor_type());
-      break;
-    }
-    case kSequenceType: {
-      _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom(from._internal_sequence_type());
-      break;
-    }
-    case kMapType: {
-      _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom(from._internal_map_type());
-      break;
-    }
-    case kOptionalType: {
-      _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom(from._internal_optional_type());
-      break;
-    }
-    case kSparseTensorType: {
-      _internal_mutable_sparse_tensor_type()->::onnx::TypeProto_SparseTensor::MergeFrom(from._internal_sparse_tensor_type());
-      break;
-    }
-    case VALUE_NOT_SET: {
-      break;
-    }
-  }
-}
-
-void TypeProto::CopyFrom(const TypeProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool TypeProto::IsInitialized() const {
-  return true;
-}
-
-void TypeProto::InternalSwap(TypeProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  denotation_.Swap(&other->denotation_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(value_, other->value_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
-}
-
-std::string TypeProto::GetTypeName() const {
-  return "onnx.TypeProto";
-}
-
-
-// ===================================================================
-
-void OperatorSetIdProto::InitAsDefaultInstance() {
-}
-class OperatorSetIdProto::_Internal {
- public:
-};
-
-OperatorSetIdProto::OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.OperatorSetIdProto)
-}
-OperatorSetIdProto::OperatorSetIdProto(const OperatorSetIdProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_domain().empty()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  version_ = from.version_;
-  // @@protoc_insertion_point(copy_constructor:onnx.OperatorSetIdProto)
-}
-
-void OperatorSetIdProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OperatorSetIdProto_onnx_2eproto3.base);
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  version_ = PROTOBUF_LONGLONG(0);
-}
-
-OperatorSetIdProto::~OperatorSetIdProto() {
-  // @@protoc_insertion_point(destructor:onnx.OperatorSetIdProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void OperatorSetIdProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void OperatorSetIdProto::ArenaDtor(void* object) {
-  OperatorSetIdProto* _this = reinterpret_cast< OperatorSetIdProto* >(object);
-  (void)_this;
-}
-void OperatorSetIdProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void OperatorSetIdProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const OperatorSetIdProto& OperatorSetIdProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_OperatorSetIdProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void OperatorSetIdProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.OperatorSetIdProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  version_ = PROTOBUF_LONGLONG(0);
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* OperatorSetIdProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string domain = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // int64 version = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
-          version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* OperatorSetIdProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.OperatorSetIdProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string domain = 1;
-  if (this->domain().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_domain().data(), static_cast<int>(this->_internal_domain().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.OperatorSetIdProto.domain");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_domain(), target);
-  }
-
-  // int64 version = 2;
-  if (this->version() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_version(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.OperatorSetIdProto)
-  return target;
-}
-
-size_t OperatorSetIdProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.OperatorSetIdProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string domain = 1;
-  if (this->domain().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_domain());
-  }
-
-  // int64 version = 2;
-  if (this->version() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
-        this->_internal_version());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void OperatorSetIdProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const OperatorSetIdProto*>(
-      &from));
-}
-
-void OperatorSetIdProto::MergeFrom(const OperatorSetIdProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.OperatorSetIdProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (from.domain().size() > 0) {
-    _internal_set_domain(from._internal_domain());
-  }
-  if (from.version() != 0) {
-    _internal_set_version(from._internal_version());
-  }
-}
-
-void OperatorSetIdProto::CopyFrom(const OperatorSetIdProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.OperatorSetIdProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool OperatorSetIdProto::IsInitialized() const {
-  return true;
-}
-
-void OperatorSetIdProto::InternalSwap(OperatorSetIdProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  swap(version_, other->version_);
-}
-
-std::string OperatorSetIdProto::GetTypeName() const {
-  return "onnx.OperatorSetIdProto";
-}
-
-
-// ===================================================================
-
-void FunctionProto::InitAsDefaultInstance() {
-}
-class FunctionProto::_Internal {
- public:
-};
-
-FunctionProto::FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
-  input_(arena),
-  output_(arena),
-  attribute_(arena),
-  node_(arena),
-  opset_import_(arena),
-  attribute_proto_(arena),
-  value_info_(arena),
-  metadata_props_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:onnx.FunctionProto)
-}
-FunctionProto::FunctionProto(const FunctionProto& from)
-  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
-      input_(from.input_),
-      output_(from.output_),
-      attribute_(from.attribute_),
-      node_(from.node_),
-      opset_import_(from.opset_import_),
-      attribute_proto_(from.attribute_proto_),
-      value_info_(from.value_info_),
-      metadata_props_(from.metadata_props_) {
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_name().empty()) {
-    name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
-  }
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_doc_string().empty()) {
-    doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_doc_string(),
-      GetArena());
-  }
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_domain().empty()) {
-    domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_domain(),
-      GetArena());
-  }
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_overload().empty()) {
-    overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_overload(),
-      GetArena());
-  }
-  // @@protoc_insertion_point(copy_constructor:onnx.FunctionProto)
-}
-
-void FunctionProto::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FunctionProto_onnx_2eproto3.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-FunctionProto::~FunctionProto() {
-  // @@protoc_insertion_point(destructor:onnx.FunctionProto)
-  SharedDtor();
-  _internal_metadata_.Delete<std::string>();
-}
-
-void FunctionProto::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  doc_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  domain_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  overload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void FunctionProto::ArenaDtor(void* object) {
-  FunctionProto* _this = reinterpret_cast< FunctionProto* >(object);
-  (void)_this;
-}
-void FunctionProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void FunctionProto::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const FunctionProto& FunctionProto::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FunctionProto_onnx_2eproto3.base);
-  return *internal_default_instance();
-}
-
-
-void FunctionProto::Clear() {
-// @@protoc_insertion_point(message_clear_start:onnx.FunctionProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  input_.Clear();
-  output_.Clear();
-  attribute_.Clear();
-  node_.Clear();
-  opset_import_.Clear();
-  attribute_proto_.Clear();
-  value_info_.Clear();
-  metadata_props_.Clear();
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  _internal_metadata_.Clear<std::string>();
-}
-
-const char* FunctionProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
-  while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
-    switch (tag >> 3) {
-      // string name = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated string input = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_input();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string output = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_output();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated string attribute = 6;
-      case 6:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_attribute();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.NodeProto node = 7;
-      case 7:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_node(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string doc_string = 8;
-      case 8:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
-          auto str = _internal_mutable_doc_string();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.OperatorSetIdProto opset_import = 9;
-      case 9:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string domain = 10;
-      case 10:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
-          auto str = _internal_mutable_domain();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.AttributeProto attribute_proto = 11;
-      case 11:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_attribute_proto(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.ValueInfoProto value_info = 12;
-      case 12:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_value_info(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
-        } else goto handle_unusual;
-        continue;
-      // string overload = 13;
-      case 13:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
-          auto str = _internal_mutable_overload();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // repeated .onnx.StringStringEntryProto metadata_props = 14;
-      case 14:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<std::string>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
-        continue;
-      }
-    }  // switch
-  }  // while
-success:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto success;
-#undef CHK_
-}
-
-::PROTOBUF_NAMESPACE_ID::uint8* FunctionProto::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:onnx.FunctionProto)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.name");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_name(), target);
-  }
-
-  // repeated string input = 4;
-  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
-    const auto& s = this->_internal_input(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.input");
-    target = stream->WriteString(4, s, target);
-  }
-
-  // repeated string output = 5;
-  for (int i = 0, n = this->_internal_output_size(); i < n; i++) {
-    const auto& s = this->_internal_output(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.output");
-    target = stream->WriteString(5, s, target);
-  }
-
-  // repeated string attribute = 6;
-  for (int i = 0, n = this->_internal_attribute_size(); i < n; i++) {
-    const auto& s = this->_internal_attribute(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.attribute");
-    target = stream->WriteString(6, s, target);
-  }
-
-  // repeated .onnx.NodeProto node = 7;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_node_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(7, this->_internal_node(i), target, stream);
-  }
-
-  // string doc_string = 8;
-  if (this->doc_string().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_doc_string().data(), static_cast<int>(this->_internal_doc_string().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.doc_string");
-    target = stream->WriteStringMaybeAliased(
-        8, this->_internal_doc_string(), target);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_opset_import_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(9, this->_internal_opset_import(i), target, stream);
-  }
-
-  // string domain = 10;
-  if (this->domain().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_domain().data(), static_cast<int>(this->_internal_domain().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.domain");
-    target = stream->WriteStringMaybeAliased(
-        10, this->_internal_domain(), target);
-  }
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_attribute_proto_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(11, this->_internal_attribute_proto(i), target, stream);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_value_info_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(12, this->_internal_value_info(i), target, stream);
-  }
-
-  // string overload = 13;
-  if (this->overload().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_overload().data(), static_cast<int>(this->_internal_overload().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "onnx.FunctionProto.overload");
-    target = stream->WriteStringMaybeAliased(
-        13, this->_internal_overload(), target);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  for (unsigned int i = 0,
-      n = static_cast<unsigned int>(this->_internal_metadata_props_size()); i < n; i++) {
-    target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(14, this->_internal_metadata_props(i), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
-        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:onnx.FunctionProto)
-  return target;
-}
-
-size_t FunctionProto::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:onnx.FunctionProto)
-  size_t total_size = 0;
-
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string input = 4;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
-  for (int i = 0, n = input_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      input_.Get(i));
-  }
-
-  // repeated string output = 5;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size());
-  for (int i = 0, n = output_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      output_.Get(i));
-  }
-
-  // repeated string attribute = 6;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(attribute_.size());
-  for (int i = 0, n = attribute_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      attribute_.Get(i));
-  }
-
-  // repeated .onnx.NodeProto node = 7;
-  total_size += 1UL * this->_internal_node_size();
-  for (const auto& msg : this->node_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  total_size += 1UL * this->_internal_opset_import_size();
-  for (const auto& msg : this->opset_import_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  total_size += 1UL * this->_internal_attribute_proto_size();
-  for (const auto& msg : this->attribute_proto_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  total_size += 1UL * this->_internal_value_info_size();
-  for (const auto& msg : this->value_info_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  total_size += 1UL * this->_internal_metadata_props_size();
-  for (const auto& msg : this->metadata_props_) {
-    total_size +=
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
-  }
-
-  // string name = 1;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // string doc_string = 8;
-  if (this->doc_string().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_doc_string());
-  }
-
-  // string domain = 10;
-  if (this->domain().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_domain());
-  }
-
-  // string overload = 13;
-  if (this->overload().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_overload());
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
-}
-
-void FunctionProto::CheckTypeAndMergeFrom(
-    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
-  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const FunctionProto*>(
-      &from));
-}
-
-void FunctionProto::MergeFrom(const FunctionProto& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:onnx.FunctionProto)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  input_.MergeFrom(from.input_);
-  output_.MergeFrom(from.output_);
-  attribute_.MergeFrom(from.attribute_);
-  node_.MergeFrom(from.node_);
-  opset_import_.MergeFrom(from.opset_import_);
-  attribute_proto_.MergeFrom(from.attribute_proto_);
-  value_info_.MergeFrom(from.value_info_);
-  metadata_props_.MergeFrom(from.metadata_props_);
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
-  }
-  if (from.doc_string().size() > 0) {
-    _internal_set_doc_string(from._internal_doc_string());
-  }
-  if (from.domain().size() > 0) {
-    _internal_set_domain(from._internal_domain());
-  }
-  if (from.overload().size() > 0) {
-    _internal_set_overload(from._internal_overload());
-  }
-}
-
-void FunctionProto::CopyFrom(const FunctionProto& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:onnx.FunctionProto)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool FunctionProto::IsInitialized() const {
-  return true;
-}
-
-void FunctionProto::InternalSwap(FunctionProto* other) {
-  using std::swap;
-  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
-  input_.InternalSwap(&other->input_);
-  output_.InternalSwap(&other->output_);
-  attribute_.InternalSwap(&other->attribute_);
-  node_.InternalSwap(&other->node_);
-  opset_import_.InternalSwap(&other->opset_import_);
-  attribute_proto_.InternalSwap(&other->attribute_proto_);
-  value_info_.InternalSwap(&other->value_info_);
-  metadata_props_.InternalSwap(&other->metadata_props_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  doc_string_.Swap(&other->doc_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  domain_.Swap(&other->domain_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  overload_.Swap(&other->overload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-std::string FunctionProto::GetTypeName() const {
-  return "onnx.FunctionProto";
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-}  // namespace onnx
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::onnx::AttributeProto* Arena::CreateMaybeMessage< ::onnx::AttributeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::AttributeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ValueInfoProto* Arena::CreateMaybeMessage< ::onnx::ValueInfoProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ValueInfoProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::NodeProto* Arena::CreateMaybeMessage< ::onnx::NodeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::NodeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::IntIntListEntryProto* Arena::CreateMaybeMessage< ::onnx::IntIntListEntryProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::IntIntListEntryProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::NodeDeviceConfigurationProto* Arena::CreateMaybeMessage< ::onnx::NodeDeviceConfigurationProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::NodeDeviceConfigurationProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ShardingSpecProto* Arena::CreateMaybeMessage< ::onnx::ShardingSpecProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ShardingSpecProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ShardedDimProto* Arena::CreateMaybeMessage< ::onnx::ShardedDimProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ShardedDimProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::SimpleShardedDimProto* Arena::CreateMaybeMessage< ::onnx::SimpleShardedDimProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::SimpleShardedDimProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TrainingInfoProto* Arena::CreateMaybeMessage< ::onnx::TrainingInfoProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TrainingInfoProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::ModelProto* Arena::CreateMaybeMessage< ::onnx::ModelProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::ModelProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::DeviceConfigurationProto* Arena::CreateMaybeMessage< ::onnx::DeviceConfigurationProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::DeviceConfigurationProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::StringStringEntryProto* Arena::CreateMaybeMessage< ::onnx::StringStringEntryProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::StringStringEntryProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorAnnotation* Arena::CreateMaybeMessage< ::onnx::TensorAnnotation >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorAnnotation >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::GraphProto* Arena::CreateMaybeMessage< ::onnx::GraphProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::GraphProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorProto_Segment* Arena::CreateMaybeMessage< ::onnx::TensorProto_Segment >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorProto_Segment >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorProto* Arena::CreateMaybeMessage< ::onnx::TensorProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::SparseTensorProto* Arena::CreateMaybeMessage< ::onnx::SparseTensorProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::SparseTensorProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage< ::onnx::TensorShapeProto_Dimension >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorShapeProto_Dimension >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TensorShapeProto* Arena::CreateMaybeMessage< ::onnx::TensorShapeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TensorShapeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Tensor* Arena::CreateMaybeMessage< ::onnx::TypeProto_Tensor >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Tensor >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Sequence* Arena::CreateMaybeMessage< ::onnx::TypeProto_Sequence >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Sequence >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Map* Arena::CreateMaybeMessage< ::onnx::TypeProto_Map >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Map >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_Optional* Arena::CreateMaybeMessage< ::onnx::TypeProto_Optional >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_Optional >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto_SparseTensor* Arena::CreateMaybeMessage< ::onnx::TypeProto_SparseTensor >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto_SparseTensor >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::TypeProto* Arena::CreateMaybeMessage< ::onnx::TypeProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::TypeProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::OperatorSetIdProto* Arena::CreateMaybeMessage< ::onnx::OperatorSetIdProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::OperatorSetIdProto >(arena);
-}
-template<> PROTOBUF_NOINLINE ::onnx::FunctionProto* Arena::CreateMaybeMessage< ::onnx::FunctionProto >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::onnx::FunctionProto >(arena);
-}
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-#include <google/protobuf/port_undef.inc>
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.h
deleted file mode 100644
index 022a34e..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/proto/onnx.proto3.pb.h
+++ /dev/null
@@ -1,14080 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: onnx.proto3
-
-#ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto3
-#define GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto3
-
-#include <limits>
-#include <string>
-
-#include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3012000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please update
-#error your headers.
-#endif
-#if 3012004 < PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/port_undef.inc>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/inlined_string_field.h>
-#include <google/protobuf/metadata_lite.h>
-#include <google/protobuf/message_lite.h>
-#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/generated_enum_util.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-#define PROTOBUF_INTERNAL_EXPORT_onnx_2eproto3
-PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
-}  // namespace internal
-PROTOBUF_NAMESPACE_CLOSE
-
-// Internal implementation detail -- do not use these members.
-struct TableStruct_onnx_2eproto3 {
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
-  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
-  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
-};
-namespace onnx {
-class AttributeProto;
-class AttributeProtoDefaultTypeInternal;
-extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
-class DeviceConfigurationProto;
-class DeviceConfigurationProtoDefaultTypeInternal;
-extern DeviceConfigurationProtoDefaultTypeInternal _DeviceConfigurationProto_default_instance_;
-class FunctionProto;
-class FunctionProtoDefaultTypeInternal;
-extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
-class GraphProto;
-class GraphProtoDefaultTypeInternal;
-extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
-class IntIntListEntryProto;
-class IntIntListEntryProtoDefaultTypeInternal;
-extern IntIntListEntryProtoDefaultTypeInternal _IntIntListEntryProto_default_instance_;
-class ModelProto;
-class ModelProtoDefaultTypeInternal;
-extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
-class NodeDeviceConfigurationProto;
-class NodeDeviceConfigurationProtoDefaultTypeInternal;
-extern NodeDeviceConfigurationProtoDefaultTypeInternal _NodeDeviceConfigurationProto_default_instance_;
-class NodeProto;
-class NodeProtoDefaultTypeInternal;
-extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
-class OperatorSetIdProto;
-class OperatorSetIdProtoDefaultTypeInternal;
-extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
-class ShardedDimProto;
-class ShardedDimProtoDefaultTypeInternal;
-extern ShardedDimProtoDefaultTypeInternal _ShardedDimProto_default_instance_;
-class ShardingSpecProto;
-class ShardingSpecProtoDefaultTypeInternal;
-extern ShardingSpecProtoDefaultTypeInternal _ShardingSpecProto_default_instance_;
-class SimpleShardedDimProto;
-class SimpleShardedDimProtoDefaultTypeInternal;
-extern SimpleShardedDimProtoDefaultTypeInternal _SimpleShardedDimProto_default_instance_;
-class SparseTensorProto;
-class SparseTensorProtoDefaultTypeInternal;
-extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
-class StringStringEntryProto;
-class StringStringEntryProtoDefaultTypeInternal;
-extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
-class TensorAnnotation;
-class TensorAnnotationDefaultTypeInternal;
-extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
-class TensorProto;
-class TensorProtoDefaultTypeInternal;
-extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
-class TensorProto_Segment;
-class TensorProto_SegmentDefaultTypeInternal;
-extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
-class TensorShapeProto;
-class TensorShapeProtoDefaultTypeInternal;
-extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
-class TensorShapeProto_Dimension;
-class TensorShapeProto_DimensionDefaultTypeInternal;
-extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
-class TrainingInfoProto;
-class TrainingInfoProtoDefaultTypeInternal;
-extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
-class TypeProto;
-class TypeProtoDefaultTypeInternal;
-extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
-class TypeProto_Map;
-class TypeProto_MapDefaultTypeInternal;
-extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
-class TypeProto_Optional;
-class TypeProto_OptionalDefaultTypeInternal;
-extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
-class TypeProto_Sequence;
-class TypeProto_SequenceDefaultTypeInternal;
-extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
-class TypeProto_SparseTensor;
-class TypeProto_SparseTensorDefaultTypeInternal;
-extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
-class TypeProto_Tensor;
-class TypeProto_TensorDefaultTypeInternal;
-extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
-class ValueInfoProto;
-class ValueInfoProtoDefaultTypeInternal;
-extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
-}  // namespace onnx
-PROTOBUF_NAMESPACE_OPEN
-template<> ::onnx::AttributeProto* Arena::CreateMaybeMessage<::onnx::AttributeProto>(Arena*);
-template<> ::onnx::DeviceConfigurationProto* Arena::CreateMaybeMessage<::onnx::DeviceConfigurationProto>(Arena*);
-template<> ::onnx::FunctionProto* Arena::CreateMaybeMessage<::onnx::FunctionProto>(Arena*);
-template<> ::onnx::GraphProto* Arena::CreateMaybeMessage<::onnx::GraphProto>(Arena*);
-template<> ::onnx::IntIntListEntryProto* Arena::CreateMaybeMessage<::onnx::IntIntListEntryProto>(Arena*);
-template<> ::onnx::ModelProto* Arena::CreateMaybeMessage<::onnx::ModelProto>(Arena*);
-template<> ::onnx::NodeDeviceConfigurationProto* Arena::CreateMaybeMessage<::onnx::NodeDeviceConfigurationProto>(Arena*);
-template<> ::onnx::NodeProto* Arena::CreateMaybeMessage<::onnx::NodeProto>(Arena*);
-template<> ::onnx::OperatorSetIdProto* Arena::CreateMaybeMessage<::onnx::OperatorSetIdProto>(Arena*);
-template<> ::onnx::ShardedDimProto* Arena::CreateMaybeMessage<::onnx::ShardedDimProto>(Arena*);
-template<> ::onnx::ShardingSpecProto* Arena::CreateMaybeMessage<::onnx::ShardingSpecProto>(Arena*);
-template<> ::onnx::SimpleShardedDimProto* Arena::CreateMaybeMessage<::onnx::SimpleShardedDimProto>(Arena*);
-template<> ::onnx::SparseTensorProto* Arena::CreateMaybeMessage<::onnx::SparseTensorProto>(Arena*);
-template<> ::onnx::StringStringEntryProto* Arena::CreateMaybeMessage<::onnx::StringStringEntryProto>(Arena*);
-template<> ::onnx::TensorAnnotation* Arena::CreateMaybeMessage<::onnx::TensorAnnotation>(Arena*);
-template<> ::onnx::TensorProto* Arena::CreateMaybeMessage<::onnx::TensorProto>(Arena*);
-template<> ::onnx::TensorProto_Segment* Arena::CreateMaybeMessage<::onnx::TensorProto_Segment>(Arena*);
-template<> ::onnx::TensorShapeProto* Arena::CreateMaybeMessage<::onnx::TensorShapeProto>(Arena*);
-template<> ::onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage<::onnx::TensorShapeProto_Dimension>(Arena*);
-template<> ::onnx::TrainingInfoProto* Arena::CreateMaybeMessage<::onnx::TrainingInfoProto>(Arena*);
-template<> ::onnx::TypeProto* Arena::CreateMaybeMessage<::onnx::TypeProto>(Arena*);
-template<> ::onnx::TypeProto_Map* Arena::CreateMaybeMessage<::onnx::TypeProto_Map>(Arena*);
-template<> ::onnx::TypeProto_Optional* Arena::CreateMaybeMessage<::onnx::TypeProto_Optional>(Arena*);
-template<> ::onnx::TypeProto_Sequence* Arena::CreateMaybeMessage<::onnx::TypeProto_Sequence>(Arena*);
-template<> ::onnx::TypeProto_SparseTensor* Arena::CreateMaybeMessage<::onnx::TypeProto_SparseTensor>(Arena*);
-template<> ::onnx::TypeProto_Tensor* Arena::CreateMaybeMessage<::onnx::TypeProto_Tensor>(Arena*);
-template<> ::onnx::ValueInfoProto* Arena::CreateMaybeMessage<::onnx::ValueInfoProto>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
-namespace onnx {
-
-enum AttributeProto_AttributeType : int {
-  AttributeProto_AttributeType_UNDEFINED = 0,
-  AttributeProto_AttributeType_FLOAT = 1,
-  AttributeProto_AttributeType_INT = 2,
-  AttributeProto_AttributeType_STRING = 3,
-  AttributeProto_AttributeType_TENSOR = 4,
-  AttributeProto_AttributeType_GRAPH = 5,
-  AttributeProto_AttributeType_SPARSE_TENSOR = 11,
-  AttributeProto_AttributeType_TYPE_PROTO = 13,
-  AttributeProto_AttributeType_FLOATS = 6,
-  AttributeProto_AttributeType_INTS = 7,
-  AttributeProto_AttributeType_STRINGS = 8,
-  AttributeProto_AttributeType_TENSORS = 9,
-  AttributeProto_AttributeType_GRAPHS = 10,
-  AttributeProto_AttributeType_SPARSE_TENSORS = 12,
-  AttributeProto_AttributeType_TYPE_PROTOS = 14,
-  AttributeProto_AttributeType_AttributeProto_AttributeType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
-  AttributeProto_AttributeType_AttributeProto_AttributeType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool AttributeProto_AttributeType_IsValid(int value);
-constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
-constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_TYPE_PROTOS;
-constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
-
-const std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value);
-template<typename T>
-inline const std::string& AttributeProto_AttributeType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function AttributeProto_AttributeType_Name.");
-  return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(enum_t_value));
-}
-bool AttributeProto_AttributeType_Parse(
-    const std::string& name, AttributeProto_AttributeType* value);
-enum TensorProto_DataType : int {
-  TensorProto_DataType_UNDEFINED = 0,
-  TensorProto_DataType_FLOAT = 1,
-  TensorProto_DataType_UINT8 = 2,
-  TensorProto_DataType_INT8 = 3,
-  TensorProto_DataType_UINT16 = 4,
-  TensorProto_DataType_INT16 = 5,
-  TensorProto_DataType_INT32 = 6,
-  TensorProto_DataType_INT64 = 7,
-  TensorProto_DataType_STRING = 8,
-  TensorProto_DataType_BOOL = 9,
-  TensorProto_DataType_FLOAT16 = 10,
-  TensorProto_DataType_DOUBLE = 11,
-  TensorProto_DataType_UINT32 = 12,
-  TensorProto_DataType_UINT64 = 13,
-  TensorProto_DataType_COMPLEX64 = 14,
-  TensorProto_DataType_COMPLEX128 = 15,
-  TensorProto_DataType_BFLOAT16 = 16,
-  TensorProto_DataType_FLOAT8E4M3FN = 17,
-  TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
-  TensorProto_DataType_FLOAT8E5M2 = 19,
-  TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
-  TensorProto_DataType_UINT4 = 21,
-  TensorProto_DataType_INT4 = 22,
-  TensorProto_DataType_FLOAT4E2M1 = 23,
-  TensorProto_DataType_FLOAT8E8M0 = 24,
-  TensorProto_DataType_TensorProto_DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
-  TensorProto_DataType_TensorProto_DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool TensorProto_DataType_IsValid(int value);
-constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
-constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_FLOAT8E8M0;
-constexpr int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
-
-const std::string& TensorProto_DataType_Name(TensorProto_DataType value);
-template<typename T>
-inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, TensorProto_DataType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function TensorProto_DataType_Name.");
-  return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(enum_t_value));
-}
-bool TensorProto_DataType_Parse(
-    const std::string& name, TensorProto_DataType* value);
-enum TensorProto_DataLocation : int {
-  TensorProto_DataLocation_DEFAULT = 0,
-  TensorProto_DataLocation_EXTERNAL = 1,
-  TensorProto_DataLocation_TensorProto_DataLocation_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
-  TensorProto_DataLocation_TensorProto_DataLocation_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool TensorProto_DataLocation_IsValid(int value);
-constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = TensorProto_DataLocation_DEFAULT;
-constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = TensorProto_DataLocation_EXTERNAL;
-constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_MAX + 1;
-
-const std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value);
-template<typename T>
-inline const std::string& TensorProto_DataLocation_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, TensorProto_DataLocation>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function TensorProto_DataLocation_Name.");
-  return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(enum_t_value));
-}
-bool TensorProto_DataLocation_Parse(
-    const std::string& name, TensorProto_DataLocation* value);
-enum Version : int {
-  _START_VERSION = 0,
-  IR_VERSION_2017_10_10 = 1,
-  IR_VERSION_2017_10_30 = 2,
-  IR_VERSION_2017_11_3 = 3,
-  IR_VERSION_2019_1_22 = 4,
-  IR_VERSION_2019_3_18 = 5,
-  IR_VERSION_2019_9_19 = 6,
-  IR_VERSION_2020_5_8 = 7,
-  IR_VERSION_2021_7_30 = 8,
-  IR_VERSION_2023_5_5 = 9,
-  IR_VERSION_2024_3_25 = 10,
-  IR_VERSION_2025_05_12 = 11,
-  IR_VERSION = 12,
-  Version_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
-  Version_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool Version_IsValid(int value);
-constexpr Version Version_MIN = _START_VERSION;
-constexpr Version Version_MAX = IR_VERSION;
-constexpr int Version_ARRAYSIZE = Version_MAX + 1;
-
-const std::string& Version_Name(Version value);
-template<typename T>
-inline const std::string& Version_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, Version>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Version_Name.");
-  return Version_Name(static_cast<Version>(enum_t_value));
-}
-bool Version_Parse(
-    const std::string& name, Version* value);
-enum OperatorStatus : int {
-  EXPERIMENTAL = 0,
-  STABLE = 1,
-  OperatorStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
-  OperatorStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool OperatorStatus_IsValid(int value);
-constexpr OperatorStatus OperatorStatus_MIN = EXPERIMENTAL;
-constexpr OperatorStatus OperatorStatus_MAX = STABLE;
-constexpr int OperatorStatus_ARRAYSIZE = OperatorStatus_MAX + 1;
-
-const std::string& OperatorStatus_Name(OperatorStatus value);
-template<typename T>
-inline const std::string& OperatorStatus_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, OperatorStatus>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function OperatorStatus_Name.");
-  return OperatorStatus_Name(static_cast<OperatorStatus>(enum_t_value));
-}
-bool OperatorStatus_Parse(
-    const std::string& name, OperatorStatus* value);
-// ===================================================================
-
-class AttributeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) */ {
- public:
-  inline AttributeProto() : AttributeProto(nullptr) {};
-  virtual ~AttributeProto();
-
-  AttributeProto(const AttributeProto& from);
-  AttributeProto(AttributeProto&& from) noexcept
-    : AttributeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline AttributeProto& operator=(const AttributeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline AttributeProto& operator=(AttributeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const AttributeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const AttributeProto* internal_default_instance() {
-    return reinterpret_cast<const AttributeProto*>(
-               &_AttributeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(AttributeProto& a, AttributeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(AttributeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(AttributeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline AttributeProto* New() const final {
-    return CreateMaybeMessage<AttributeProto>(nullptr);
-  }
-
-  AttributeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<AttributeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const AttributeProto& from);
-  void MergeFrom(const AttributeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(AttributeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.AttributeProto";
-  }
-  protected:
-  explicit AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef AttributeProto_AttributeType AttributeType;
-  static constexpr AttributeType UNDEFINED =
-    AttributeProto_AttributeType_UNDEFINED;
-  static constexpr AttributeType FLOAT =
-    AttributeProto_AttributeType_FLOAT;
-  static constexpr AttributeType INT =
-    AttributeProto_AttributeType_INT;
-  static constexpr AttributeType STRING =
-    AttributeProto_AttributeType_STRING;
-  static constexpr AttributeType TENSOR =
-    AttributeProto_AttributeType_TENSOR;
-  static constexpr AttributeType GRAPH =
-    AttributeProto_AttributeType_GRAPH;
-  static constexpr AttributeType SPARSE_TENSOR =
-    AttributeProto_AttributeType_SPARSE_TENSOR;
-  static constexpr AttributeType TYPE_PROTO =
-    AttributeProto_AttributeType_TYPE_PROTO;
-  static constexpr AttributeType FLOATS =
-    AttributeProto_AttributeType_FLOATS;
-  static constexpr AttributeType INTS =
-    AttributeProto_AttributeType_INTS;
-  static constexpr AttributeType STRINGS =
-    AttributeProto_AttributeType_STRINGS;
-  static constexpr AttributeType TENSORS =
-    AttributeProto_AttributeType_TENSORS;
-  static constexpr AttributeType GRAPHS =
-    AttributeProto_AttributeType_GRAPHS;
-  static constexpr AttributeType SPARSE_TENSORS =
-    AttributeProto_AttributeType_SPARSE_TENSORS;
-  static constexpr AttributeType TYPE_PROTOS =
-    AttributeProto_AttributeType_TYPE_PROTOS;
-  static inline bool AttributeType_IsValid(int value) {
-    return AttributeProto_AttributeType_IsValid(value);
-  }
-  static constexpr AttributeType AttributeType_MIN =
-    AttributeProto_AttributeType_AttributeType_MIN;
-  static constexpr AttributeType AttributeType_MAX =
-    AttributeProto_AttributeType_AttributeType_MAX;
-  static constexpr int AttributeType_ARRAYSIZE =
-    AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& AttributeType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, AttributeType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function AttributeType_Name.");
-    return AttributeProto_AttributeType_Name(enum_t_value);
-  }
-  static inline bool AttributeType_Parse(const std::string& name,
-      AttributeType* value) {
-    return AttributeProto_AttributeType_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFloatsFieldNumber = 7,
-    kIntsFieldNumber = 8,
-    kStringsFieldNumber = 9,
-    kTensorsFieldNumber = 10,
-    kGraphsFieldNumber = 11,
-    kTypeProtosFieldNumber = 15,
-    kSparseTensorsFieldNumber = 23,
-    kNameFieldNumber = 1,
-    kSFieldNumber = 4,
-    kDocStringFieldNumber = 13,
-    kRefAttrNameFieldNumber = 21,
-    kTFieldNumber = 5,
-    kGFieldNumber = 6,
-    kTpFieldNumber = 14,
-    kSparseTensorFieldNumber = 22,
-    kIFieldNumber = 3,
-    kFFieldNumber = 2,
-    kTypeFieldNumber = 20,
-  };
-  // repeated float floats = 7;
-  int floats_size() const;
-  private:
-  int _internal_floats_size() const;
-  public:
-  void clear_floats();
-  private:
-  float _internal_floats(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      _internal_floats() const;
-  void _internal_add_floats(float value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      _internal_mutable_floats();
-  public:
-  float floats(int index) const;
-  void set_floats(int index, float value);
-  void add_floats(float value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      floats() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      mutable_floats();
-
-  // repeated int64 ints = 8;
-  int ints_size() const;
-  private:
-  int _internal_ints_size() const;
-  public:
-  void clear_ints();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_ints(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_ints() const;
-  void _internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_ints();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 ints(int index) const;
-  void set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      ints() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_ints();
-
-  // repeated bytes strings = 9;
-  int strings_size() const;
-  private:
-  int _internal_strings_size() const;
-  public:
-  void clear_strings();
-  const std::string& strings(int index) const;
-  std::string* mutable_strings(int index);
-  void set_strings(int index, const std::string& value);
-  void set_strings(int index, std::string&& value);
-  void set_strings(int index, const char* value);
-  void set_strings(int index, const void* value, size_t size);
-  std::string* add_strings();
-  void add_strings(const std::string& value);
-  void add_strings(std::string&& value);
-  void add_strings(const char* value);
-  void add_strings(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
-  private:
-  const std::string& _internal_strings(int index) const;
-  std::string* _internal_add_strings();
-  public:
-
-  // repeated .onnx.TensorProto tensors = 10;
-  int tensors_size() const;
-  private:
-  int _internal_tensors_size() const;
-  public:
-  void clear_tensors();
-  ::onnx::TensorProto* mutable_tensors(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-      mutable_tensors();
-  private:
-  const ::onnx::TensorProto& _internal_tensors(int index) const;
-  ::onnx::TensorProto* _internal_add_tensors();
-  public:
-  const ::onnx::TensorProto& tensors(int index) const;
-  ::onnx::TensorProto* add_tensors();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-      tensors() const;
-
-  // repeated .onnx.GraphProto graphs = 11;
-  int graphs_size() const;
-  private:
-  int _internal_graphs_size() const;
-  public:
-  void clear_graphs();
-  ::onnx::GraphProto* mutable_graphs(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >*
-      mutable_graphs();
-  private:
-  const ::onnx::GraphProto& _internal_graphs(int index) const;
-  ::onnx::GraphProto* _internal_add_graphs();
-  public:
-  const ::onnx::GraphProto& graphs(int index) const;
-  ::onnx::GraphProto* add_graphs();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >&
-      graphs() const;
-
-  // repeated .onnx.TypeProto type_protos = 15;
-  int type_protos_size() const;
-  private:
-  int _internal_type_protos_size() const;
-  public:
-  void clear_type_protos();
-  ::onnx::TypeProto* mutable_type_protos(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >*
-      mutable_type_protos();
-  private:
-  const ::onnx::TypeProto& _internal_type_protos(int index) const;
-  ::onnx::TypeProto* _internal_add_type_protos();
-  public:
-  const ::onnx::TypeProto& type_protos(int index) const;
-  ::onnx::TypeProto* add_type_protos();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >&
-      type_protos() const;
-
-  // repeated .onnx.SparseTensorProto sparse_tensors = 23;
-  int sparse_tensors_size() const;
-  private:
-  int _internal_sparse_tensors_size() const;
-  public:
-  void clear_sparse_tensors();
-  ::onnx::SparseTensorProto* mutable_sparse_tensors(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-      mutable_sparse_tensors();
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_tensors(int index) const;
-  ::onnx::SparseTensorProto* _internal_add_sparse_tensors();
-  public:
-  const ::onnx::SparseTensorProto& sparse_tensors(int index) const;
-  ::onnx::SparseTensorProto* add_sparse_tensors();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-      sparse_tensors() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // bytes s = 4;
-  void clear_s();
-  const std::string& s() const;
-  void set_s(const std::string& value);
-  void set_s(std::string&& value);
-  void set_s(const char* value);
-  void set_s(const void* value, size_t size);
-  std::string* mutable_s();
-  std::string* release_s();
-  void set_allocated_s(std::string* s);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_s();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_s(
-      std::string* s);
-  private:
-  const std::string& _internal_s() const;
-  void _internal_set_s(const std::string& value);
-  std::string* _internal_mutable_s();
-  public:
-
-  // string doc_string = 13;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // string ref_attr_name = 21;
-  void clear_ref_attr_name();
-  const std::string& ref_attr_name() const;
-  void set_ref_attr_name(const std::string& value);
-  void set_ref_attr_name(std::string&& value);
-  void set_ref_attr_name(const char* value);
-  void set_ref_attr_name(const char* value, size_t size);
-  std::string* mutable_ref_attr_name();
-  std::string* release_ref_attr_name();
-  void set_allocated_ref_attr_name(std::string* ref_attr_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_ref_attr_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_ref_attr_name(
-      std::string* ref_attr_name);
-  private:
-  const std::string& _internal_ref_attr_name() const;
-  void _internal_set_ref_attr_name(const std::string& value);
-  std::string* _internal_mutable_ref_attr_name();
-  public:
-
-  // .onnx.TensorProto t = 5;
-  bool has_t() const;
-  private:
-  bool _internal_has_t() const;
-  public:
-  void clear_t();
-  const ::onnx::TensorProto& t() const;
-  ::onnx::TensorProto* release_t();
-  ::onnx::TensorProto* mutable_t();
-  void set_allocated_t(::onnx::TensorProto* t);
-  private:
-  const ::onnx::TensorProto& _internal_t() const;
-  ::onnx::TensorProto* _internal_mutable_t();
-  public:
-  void unsafe_arena_set_allocated_t(
-      ::onnx::TensorProto* t);
-  ::onnx::TensorProto* unsafe_arena_release_t();
-
-  // .onnx.GraphProto g = 6;
-  bool has_g() const;
-  private:
-  bool _internal_has_g() const;
-  public:
-  void clear_g();
-  const ::onnx::GraphProto& g() const;
-  ::onnx::GraphProto* release_g();
-  ::onnx::GraphProto* mutable_g();
-  void set_allocated_g(::onnx::GraphProto* g);
-  private:
-  const ::onnx::GraphProto& _internal_g() const;
-  ::onnx::GraphProto* _internal_mutable_g();
-  public:
-  void unsafe_arena_set_allocated_g(
-      ::onnx::GraphProto* g);
-  ::onnx::GraphProto* unsafe_arena_release_g();
-
-  // .onnx.TypeProto tp = 14;
-  bool has_tp() const;
-  private:
-  bool _internal_has_tp() const;
-  public:
-  void clear_tp();
-  const ::onnx::TypeProto& tp() const;
-  ::onnx::TypeProto* release_tp();
-  ::onnx::TypeProto* mutable_tp();
-  void set_allocated_tp(::onnx::TypeProto* tp);
-  private:
-  const ::onnx::TypeProto& _internal_tp() const;
-  ::onnx::TypeProto* _internal_mutable_tp();
-  public:
-  void unsafe_arena_set_allocated_tp(
-      ::onnx::TypeProto* tp);
-  ::onnx::TypeProto* unsafe_arena_release_tp();
-
-  // .onnx.SparseTensorProto sparse_tensor = 22;
-  bool has_sparse_tensor() const;
-  private:
-  bool _internal_has_sparse_tensor() const;
-  public:
-  void clear_sparse_tensor();
-  const ::onnx::SparseTensorProto& sparse_tensor() const;
-  ::onnx::SparseTensorProto* release_sparse_tensor();
-  ::onnx::SparseTensorProto* mutable_sparse_tensor();
-  void set_allocated_sparse_tensor(::onnx::SparseTensorProto* sparse_tensor);
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_tensor() const;
-  ::onnx::SparseTensorProto* _internal_mutable_sparse_tensor();
-  public:
-  void unsafe_arena_set_allocated_sparse_tensor(
-      ::onnx::SparseTensorProto* sparse_tensor);
-  ::onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor();
-
-  // int64 i = 3;
-  void clear_i();
-  ::PROTOBUF_NAMESPACE_ID::int64 i() const;
-  void set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_i() const;
-  void _internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // float f = 2;
-  void clear_f();
-  float f() const;
-  void set_f(float value);
-  private:
-  float _internal_f() const;
-  void _internal_set_f(float value);
-  public:
-
-  // .onnx.AttributeProto.AttributeType type = 20;
-  void clear_type();
-  ::onnx::AttributeProto_AttributeType type() const;
-  void set_type(::onnx::AttributeProto_AttributeType value);
-  private:
-  ::onnx::AttributeProto_AttributeType _internal_type() const;
-  void _internal_set_type(::onnx::AttributeProto_AttributeType value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.AttributeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
-  mutable std::atomic<int> _floats_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ints_;
-  mutable std::atomic<int> _ints_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto > tensors_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto > graphs_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto > type_protos_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensors_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ref_attr_name_;
-  ::onnx::TensorProto* t_;
-  ::onnx::GraphProto* g_;
-  ::onnx::TypeProto* tp_;
-  ::onnx::SparseTensorProto* sparse_tensor_;
-  ::PROTOBUF_NAMESPACE_ID::int64 i_;
-  float f_;
-  int type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class ValueInfoProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) */ {
- public:
-  inline ValueInfoProto() : ValueInfoProto(nullptr) {};
-  virtual ~ValueInfoProto();
-
-  ValueInfoProto(const ValueInfoProto& from);
-  ValueInfoProto(ValueInfoProto&& from) noexcept
-    : ValueInfoProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ValueInfoProto& operator=(const ValueInfoProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ValueInfoProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ValueInfoProto* internal_default_instance() {
-    return reinterpret_cast<const ValueInfoProto*>(
-               &_ValueInfoProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ValueInfoProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ValueInfoProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ValueInfoProto* New() const final {
-    return CreateMaybeMessage<ValueInfoProto>(nullptr);
-  }
-
-  ValueInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ValueInfoProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ValueInfoProto& from);
-  void MergeFrom(const ValueInfoProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ValueInfoProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ValueInfoProto";
-  }
-  protected:
-  explicit ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kMetadataPropsFieldNumber = 4,
-    kNameFieldNumber = 1,
-    kDocStringFieldNumber = 3,
-    kTypeFieldNumber = 2,
-  };
-  // repeated .onnx.StringStringEntryProto metadata_props = 4;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string doc_string = 3;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // .onnx.TypeProto type = 2;
-  bool has_type() const;
-  private:
-  bool _internal_has_type() const;
-  public:
-  void clear_type();
-  const ::onnx::TypeProto& type() const;
-  ::onnx::TypeProto* release_type();
-  ::onnx::TypeProto* mutable_type();
-  void set_allocated_type(::onnx::TypeProto* type);
-  private:
-  const ::onnx::TypeProto& _internal_type() const;
-  ::onnx::TypeProto* _internal_mutable_type();
-  public:
-  void unsafe_arena_set_allocated_type(
-      ::onnx::TypeProto* type);
-  ::onnx::TypeProto* unsafe_arena_release_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::TypeProto* type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class NodeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.NodeProto) */ {
- public:
-  inline NodeProto() : NodeProto(nullptr) {};
-  virtual ~NodeProto();
-
-  NodeProto(const NodeProto& from);
-  NodeProto(NodeProto&& from) noexcept
-    : NodeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline NodeProto& operator=(const NodeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline NodeProto& operator=(NodeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const NodeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const NodeProto* internal_default_instance() {
-    return reinterpret_cast<const NodeProto*>(
-               &_NodeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(NodeProto& a, NodeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(NodeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(NodeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline NodeProto* New() const final {
-    return CreateMaybeMessage<NodeProto>(nullptr);
-  }
-
-  NodeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NodeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const NodeProto& from);
-  void MergeFrom(const NodeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(NodeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.NodeProto";
-  }
-  protected:
-  explicit NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInputFieldNumber = 1,
-    kOutputFieldNumber = 2,
-    kAttributeFieldNumber = 5,
-    kMetadataPropsFieldNumber = 9,
-    kDeviceConfigurationsFieldNumber = 10,
-    kNameFieldNumber = 3,
-    kOpTypeFieldNumber = 4,
-    kDocStringFieldNumber = 6,
-    kDomainFieldNumber = 7,
-    kOverloadFieldNumber = 8,
-  };
-  // repeated string input = 1;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  const std::string& input(int index) const;
-  std::string* mutable_input(int index);
-  void set_input(int index, const std::string& value);
-  void set_input(int index, std::string&& value);
-  void set_input(int index, const char* value);
-  void set_input(int index, const char* value, size_t size);
-  std::string* add_input();
-  void add_input(const std::string& value);
-  void add_input(std::string&& value);
-  void add_input(const char* value);
-  void add_input(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
-  private:
-  const std::string& _internal_input(int index) const;
-  std::string* _internal_add_input();
-  public:
-
-  // repeated string output = 2;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  const std::string& output(int index) const;
-  std::string* mutable_output(int index);
-  void set_output(int index, const std::string& value);
-  void set_output(int index, std::string&& value);
-  void set_output(int index, const char* value);
-  void set_output(int index, const char* value, size_t size);
-  std::string* add_output();
-  void add_output(const std::string& value);
-  void add_output(std::string&& value);
-  void add_output(const char* value);
-  void add_output(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
-  private:
-  const std::string& _internal_output(int index) const;
-  std::string* _internal_add_output();
-  public:
-
-  // repeated .onnx.AttributeProto attribute = 5;
-  int attribute_size() const;
-  private:
-  int _internal_attribute_size() const;
-  public:
-  void clear_attribute();
-  ::onnx::AttributeProto* mutable_attribute(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-      mutable_attribute();
-  private:
-  const ::onnx::AttributeProto& _internal_attribute(int index) const;
-  ::onnx::AttributeProto* _internal_add_attribute();
-  public:
-  const ::onnx::AttributeProto& attribute(int index) const;
-  ::onnx::AttributeProto* add_attribute();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-      attribute() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 9;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-  int device_configurations_size() const;
-  private:
-  int _internal_device_configurations_size() const;
-  public:
-  void clear_device_configurations();
-  ::onnx::NodeDeviceConfigurationProto* mutable_device_configurations(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >*
-      mutable_device_configurations();
-  private:
-  const ::onnx::NodeDeviceConfigurationProto& _internal_device_configurations(int index) const;
-  ::onnx::NodeDeviceConfigurationProto* _internal_add_device_configurations();
-  public:
-  const ::onnx::NodeDeviceConfigurationProto& device_configurations(int index) const;
-  ::onnx::NodeDeviceConfigurationProto* add_device_configurations();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >&
-      device_configurations() const;
-
-  // string name = 3;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string op_type = 4;
-  void clear_op_type();
-  const std::string& op_type() const;
-  void set_op_type(const std::string& value);
-  void set_op_type(std::string&& value);
-  void set_op_type(const char* value);
-  void set_op_type(const char* value, size_t size);
-  std::string* mutable_op_type();
-  std::string* release_op_type();
-  void set_allocated_op_type(std::string* op_type);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_op_type();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_op_type(
-      std::string* op_type);
-  private:
-  const std::string& _internal_op_type() const;
-  void _internal_set_op_type(const std::string& value);
-  std::string* _internal_mutable_op_type();
-  public:
-
-  // string doc_string = 6;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // string domain = 7;
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // string overload = 8;
-  void clear_overload();
-  const std::string& overload() const;
-  void set_overload(const std::string& value);
-  void set_overload(std::string&& value);
-  void set_overload(const char* value);
-  void set_overload(const char* value, size_t size);
-  std::string* mutable_overload();
-  std::string* release_overload();
-  void set_allocated_overload(std::string* overload);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_overload();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_overload(
-      std::string* overload);
-  private:
-  const std::string& _internal_overload() const;
-  void _internal_set_overload(const std::string& value);
-  std::string* _internal_mutable_overload();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.NodeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto > attribute_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto > device_configurations_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class IntIntListEntryProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.IntIntListEntryProto) */ {
- public:
-  inline IntIntListEntryProto() : IntIntListEntryProto(nullptr) {};
-  virtual ~IntIntListEntryProto();
-
-  IntIntListEntryProto(const IntIntListEntryProto& from);
-  IntIntListEntryProto(IntIntListEntryProto&& from) noexcept
-    : IntIntListEntryProto() {
-    *this = ::std::move(from);
-  }
-
-  inline IntIntListEntryProto& operator=(const IntIntListEntryProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline IntIntListEntryProto& operator=(IntIntListEntryProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const IntIntListEntryProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const IntIntListEntryProto* internal_default_instance() {
-    return reinterpret_cast<const IntIntListEntryProto*>(
-               &_IntIntListEntryProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(IntIntListEntryProto& a, IntIntListEntryProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(IntIntListEntryProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(IntIntListEntryProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline IntIntListEntryProto* New() const final {
-    return CreateMaybeMessage<IntIntListEntryProto>(nullptr);
-  }
-
-  IntIntListEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<IntIntListEntryProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const IntIntListEntryProto& from);
-  void MergeFrom(const IntIntListEntryProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(IntIntListEntryProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.IntIntListEntryProto";
-  }
-  protected:
-  explicit IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 2,
-    kKeyFieldNumber = 1,
-  };
-  // repeated int64 value = 2;
-  int value_size() const;
-  private:
-  int _internal_value_size() const;
-  public:
-  void clear_value();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_value(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_value() const;
-  void _internal_add_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_value();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 value(int index) const;
-  void set_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      value() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_value();
-
-  // int64 key = 1;
-  void clear_key();
-  ::PROTOBUF_NAMESPACE_ID::int64 key() const;
-  void set_key(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_key() const;
-  void _internal_set_key(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.IntIntListEntryProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > value_;
-  mutable std::atomic<int> _value_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::int64 key_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class NodeDeviceConfigurationProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.NodeDeviceConfigurationProto) */ {
- public:
-  inline NodeDeviceConfigurationProto() : NodeDeviceConfigurationProto(nullptr) {};
-  virtual ~NodeDeviceConfigurationProto();
-
-  NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from);
-  NodeDeviceConfigurationProto(NodeDeviceConfigurationProto&& from) noexcept
-    : NodeDeviceConfigurationProto() {
-    *this = ::std::move(from);
-  }
-
-  inline NodeDeviceConfigurationProto& operator=(const NodeDeviceConfigurationProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline NodeDeviceConfigurationProto& operator=(NodeDeviceConfigurationProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const NodeDeviceConfigurationProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const NodeDeviceConfigurationProto* internal_default_instance() {
-    return reinterpret_cast<const NodeDeviceConfigurationProto*>(
-               &_NodeDeviceConfigurationProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(NodeDeviceConfigurationProto& a, NodeDeviceConfigurationProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(NodeDeviceConfigurationProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(NodeDeviceConfigurationProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline NodeDeviceConfigurationProto* New() const final {
-    return CreateMaybeMessage<NodeDeviceConfigurationProto>(nullptr);
-  }
-
-  NodeDeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NodeDeviceConfigurationProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const NodeDeviceConfigurationProto& from);
-  void MergeFrom(const NodeDeviceConfigurationProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(NodeDeviceConfigurationProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.NodeDeviceConfigurationProto";
-  }
-  protected:
-  explicit NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShardingSpecFieldNumber = 2,
-    kConfigurationIdFieldNumber = 1,
-    kPipelineStageFieldNumber = 3,
-  };
-  // repeated .onnx.ShardingSpecProto sharding_spec = 2;
-  int sharding_spec_size() const;
-  private:
-  int _internal_sharding_spec_size() const;
-  public:
-  void clear_sharding_spec();
-  ::onnx::ShardingSpecProto* mutable_sharding_spec(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >*
-      mutable_sharding_spec();
-  private:
-  const ::onnx::ShardingSpecProto& _internal_sharding_spec(int index) const;
-  ::onnx::ShardingSpecProto* _internal_add_sharding_spec();
-  public:
-  const ::onnx::ShardingSpecProto& sharding_spec(int index) const;
-  ::onnx::ShardingSpecProto* add_sharding_spec();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >&
-      sharding_spec() const;
-
-  // string configuration_id = 1;
-  void clear_configuration_id();
-  const std::string& configuration_id() const;
-  void set_configuration_id(const std::string& value);
-  void set_configuration_id(std::string&& value);
-  void set_configuration_id(const char* value);
-  void set_configuration_id(const char* value, size_t size);
-  std::string* mutable_configuration_id();
-  std::string* release_configuration_id();
-  void set_allocated_configuration_id(std::string* configuration_id);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_configuration_id();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_configuration_id(
-      std::string* configuration_id);
-  private:
-  const std::string& _internal_configuration_id() const;
-  void _internal_set_configuration_id(const std::string& value);
-  std::string* _internal_mutable_configuration_id();
-  public:
-
-  // int32 pipeline_stage = 3;
-  void clear_pipeline_stage();
-  ::PROTOBUF_NAMESPACE_ID::int32 pipeline_stage() const;
-  void set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pipeline_stage() const;
-  void _internal_set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.NodeDeviceConfigurationProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto > sharding_spec_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr configuration_id_;
-  ::PROTOBUF_NAMESPACE_ID::int32 pipeline_stage_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class ShardingSpecProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ShardingSpecProto) */ {
- public:
-  inline ShardingSpecProto() : ShardingSpecProto(nullptr) {};
-  virtual ~ShardingSpecProto();
-
-  ShardingSpecProto(const ShardingSpecProto& from);
-  ShardingSpecProto(ShardingSpecProto&& from) noexcept
-    : ShardingSpecProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ShardingSpecProto& operator=(const ShardingSpecProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ShardingSpecProto& operator=(ShardingSpecProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ShardingSpecProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ShardingSpecProto* internal_default_instance() {
-    return reinterpret_cast<const ShardingSpecProto*>(
-               &_ShardingSpecProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    5;
-
-  friend void swap(ShardingSpecProto& a, ShardingSpecProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ShardingSpecProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ShardingSpecProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ShardingSpecProto* New() const final {
-    return CreateMaybeMessage<ShardingSpecProto>(nullptr);
-  }
-
-  ShardingSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ShardingSpecProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ShardingSpecProto& from);
-  void MergeFrom(const ShardingSpecProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ShardingSpecProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ShardingSpecProto";
-  }
-  protected:
-  explicit ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDeviceFieldNumber = 2,
-    kIndexToDeviceGroupMapFieldNumber = 3,
-    kShardedDimFieldNumber = 4,
-    kTensorNameFieldNumber = 1,
-  };
-  // repeated int64 device = 2;
-  int device_size() const;
-  private:
-  int _internal_device_size() const;
-  public:
-  void clear_device();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_device(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_device() const;
-  void _internal_add_device(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_device();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 device(int index) const;
-  void set_device(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_device(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      device() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_device();
-
-  // repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-  int index_to_device_group_map_size() const;
-  private:
-  int _internal_index_to_device_group_map_size() const;
-  public:
-  void clear_index_to_device_group_map();
-  ::onnx::IntIntListEntryProto* mutable_index_to_device_group_map(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >*
-      mutable_index_to_device_group_map();
-  private:
-  const ::onnx::IntIntListEntryProto& _internal_index_to_device_group_map(int index) const;
-  ::onnx::IntIntListEntryProto* _internal_add_index_to_device_group_map();
-  public:
-  const ::onnx::IntIntListEntryProto& index_to_device_group_map(int index) const;
-  ::onnx::IntIntListEntryProto* add_index_to_device_group_map();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >&
-      index_to_device_group_map() const;
-
-  // repeated .onnx.ShardedDimProto sharded_dim = 4;
-  int sharded_dim_size() const;
-  private:
-  int _internal_sharded_dim_size() const;
-  public:
-  void clear_sharded_dim();
-  ::onnx::ShardedDimProto* mutable_sharded_dim(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >*
-      mutable_sharded_dim();
-  private:
-  const ::onnx::ShardedDimProto& _internal_sharded_dim(int index) const;
-  ::onnx::ShardedDimProto* _internal_add_sharded_dim();
-  public:
-  const ::onnx::ShardedDimProto& sharded_dim(int index) const;
-  ::onnx::ShardedDimProto* add_sharded_dim();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >&
-      sharded_dim() const;
-
-  // string tensor_name = 1;
-  void clear_tensor_name();
-  const std::string& tensor_name() const;
-  void set_tensor_name(const std::string& value);
-  void set_tensor_name(std::string&& value);
-  void set_tensor_name(const char* value);
-  void set_tensor_name(const char* value, size_t size);
-  std::string* mutable_tensor_name();
-  std::string* release_tensor_name();
-  void set_allocated_tensor_name(std::string* tensor_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_tensor_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_tensor_name(
-      std::string* tensor_name);
-  private:
-  const std::string& _internal_tensor_name() const;
-  void _internal_set_tensor_name(const std::string& value);
-  std::string* _internal_mutable_tensor_name();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ShardingSpecProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > device_;
-  mutable std::atomic<int> _device_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto > index_to_device_group_map_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto > sharded_dim_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class ShardedDimProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ShardedDimProto) */ {
- public:
-  inline ShardedDimProto() : ShardedDimProto(nullptr) {};
-  virtual ~ShardedDimProto();
-
-  ShardedDimProto(const ShardedDimProto& from);
-  ShardedDimProto(ShardedDimProto&& from) noexcept
-    : ShardedDimProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ShardedDimProto& operator=(const ShardedDimProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ShardedDimProto& operator=(ShardedDimProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ShardedDimProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ShardedDimProto* internal_default_instance() {
-    return reinterpret_cast<const ShardedDimProto*>(
-               &_ShardedDimProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    6;
-
-  friend void swap(ShardedDimProto& a, ShardedDimProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ShardedDimProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ShardedDimProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ShardedDimProto* New() const final {
-    return CreateMaybeMessage<ShardedDimProto>(nullptr);
-  }
-
-  ShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ShardedDimProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ShardedDimProto& from);
-  void MergeFrom(const ShardedDimProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ShardedDimProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ShardedDimProto";
-  }
-  protected:
-  explicit ShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kSimpleShardingFieldNumber = 2,
-    kAxisFieldNumber = 1,
-  };
-  // repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-  int simple_sharding_size() const;
-  private:
-  int _internal_simple_sharding_size() const;
-  public:
-  void clear_simple_sharding();
-  ::onnx::SimpleShardedDimProto* mutable_simple_sharding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >*
-      mutable_simple_sharding();
-  private:
-  const ::onnx::SimpleShardedDimProto& _internal_simple_sharding(int index) const;
-  ::onnx::SimpleShardedDimProto* _internal_add_simple_sharding();
-  public:
-  const ::onnx::SimpleShardedDimProto& simple_sharding(int index) const;
-  ::onnx::SimpleShardedDimProto* add_simple_sharding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >&
-      simple_sharding() const;
-
-  // int64 axis = 1;
-  void clear_axis();
-  ::PROTOBUF_NAMESPACE_ID::int64 axis() const;
-  void set_axis(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_axis() const;
-  void _internal_set_axis(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ShardedDimProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto > simple_sharding_;
-  ::PROTOBUF_NAMESPACE_ID::int64 axis_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class SimpleShardedDimProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.SimpleShardedDimProto) */ {
- public:
-  inline SimpleShardedDimProto() : SimpleShardedDimProto(nullptr) {};
-  virtual ~SimpleShardedDimProto();
-
-  SimpleShardedDimProto(const SimpleShardedDimProto& from);
-  SimpleShardedDimProto(SimpleShardedDimProto&& from) noexcept
-    : SimpleShardedDimProto() {
-    *this = ::std::move(from);
-  }
-
-  inline SimpleShardedDimProto& operator=(const SimpleShardedDimProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SimpleShardedDimProto& operator=(SimpleShardedDimProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const SimpleShardedDimProto& default_instance();
-
-  enum DimCase {
-    kDimValue = 1,
-    kDimParam = 2,
-    DIM_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const SimpleShardedDimProto* internal_default_instance() {
-    return reinterpret_cast<const SimpleShardedDimProto*>(
-               &_SimpleShardedDimProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    7;
-
-  friend void swap(SimpleShardedDimProto& a, SimpleShardedDimProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SimpleShardedDimProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SimpleShardedDimProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline SimpleShardedDimProto* New() const final {
-    return CreateMaybeMessage<SimpleShardedDimProto>(nullptr);
-  }
-
-  SimpleShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<SimpleShardedDimProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const SimpleShardedDimProto& from);
-  void MergeFrom(const SimpleShardedDimProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(SimpleShardedDimProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.SimpleShardedDimProto";
-  }
-  protected:
-  explicit SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNumShardsFieldNumber = 3,
-    kDimValueFieldNumber = 1,
-    kDimParamFieldNumber = 2,
-  };
-  // int64 num_shards = 3;
-  void clear_num_shards();
-  ::PROTOBUF_NAMESPACE_ID::int64 num_shards() const;
-  void set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_shards() const;
-  void _internal_set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // int64 dim_value = 1;
-  private:
-  bool _internal_has_dim_value() const;
-  public:
-  void clear_dim_value();
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value() const;
-  void set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dim_value() const;
-  void _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // string dim_param = 2;
-  private:
-  bool _internal_has_dim_param() const;
-  public:
-  void clear_dim_param();
-  const std::string& dim_param() const;
-  void set_dim_param(const std::string& value);
-  void set_dim_param(std::string&& value);
-  void set_dim_param(const char* value);
-  void set_dim_param(const char* value, size_t size);
-  std::string* mutable_dim_param();
-  std::string* release_dim_param();
-  void set_allocated_dim_param(std::string* dim_param);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_dim_param();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_dim_param(
-      std::string* dim_param);
-  private:
-  const std::string& _internal_dim_param() const;
-  void _internal_set_dim_param(const std::string& value);
-  std::string* _internal_mutable_dim_param();
-  public:
-
-  void clear_dim();
-  DimCase dim_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.SimpleShardedDimProto)
- private:
-  class _Internal;
-  void set_has_dim_value();
-  void set_has_dim_param();
-
-  inline bool has_dim() const;
-  inline void clear_has_dim();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::int64 num_shards_;
-  union DimUnion {
-    DimUnion() {}
-    ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-  } dim_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TrainingInfoProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) */ {
- public:
-  inline TrainingInfoProto() : TrainingInfoProto(nullptr) {};
-  virtual ~TrainingInfoProto();
-
-  TrainingInfoProto(const TrainingInfoProto& from);
-  TrainingInfoProto(TrainingInfoProto&& from) noexcept
-    : TrainingInfoProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TrainingInfoProto& operator=(TrainingInfoProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TrainingInfoProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TrainingInfoProto* internal_default_instance() {
-    return reinterpret_cast<const TrainingInfoProto*>(
-               &_TrainingInfoProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    8;
-
-  friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TrainingInfoProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TrainingInfoProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TrainingInfoProto* New() const final {
-    return CreateMaybeMessage<TrainingInfoProto>(nullptr);
-  }
-
-  TrainingInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TrainingInfoProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TrainingInfoProto& from);
-  void MergeFrom(const TrainingInfoProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TrainingInfoProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TrainingInfoProto";
-  }
-  protected:
-  explicit TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInitializationBindingFieldNumber = 3,
-    kUpdateBindingFieldNumber = 4,
-    kInitializationFieldNumber = 1,
-    kAlgorithmFieldNumber = 2,
-  };
-  // repeated .onnx.StringStringEntryProto initialization_binding = 3;
-  int initialization_binding_size() const;
-  private:
-  int _internal_initialization_binding_size() const;
-  public:
-  void clear_initialization_binding();
-  ::onnx::StringStringEntryProto* mutable_initialization_binding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_initialization_binding();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_initialization_binding(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_initialization_binding();
-  public:
-  const ::onnx::StringStringEntryProto& initialization_binding(int index) const;
-  ::onnx::StringStringEntryProto* add_initialization_binding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      initialization_binding() const;
-
-  // repeated .onnx.StringStringEntryProto update_binding = 4;
-  int update_binding_size() const;
-  private:
-  int _internal_update_binding_size() const;
-  public:
-  void clear_update_binding();
-  ::onnx::StringStringEntryProto* mutable_update_binding(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_update_binding();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_update_binding(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_update_binding();
-  public:
-  const ::onnx::StringStringEntryProto& update_binding(int index) const;
-  ::onnx::StringStringEntryProto* add_update_binding();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      update_binding() const;
-
-  // .onnx.GraphProto initialization = 1;
-  bool has_initialization() const;
-  private:
-  bool _internal_has_initialization() const;
-  public:
-  void clear_initialization();
-  const ::onnx::GraphProto& initialization() const;
-  ::onnx::GraphProto* release_initialization();
-  ::onnx::GraphProto* mutable_initialization();
-  void set_allocated_initialization(::onnx::GraphProto* initialization);
-  private:
-  const ::onnx::GraphProto& _internal_initialization() const;
-  ::onnx::GraphProto* _internal_mutable_initialization();
-  public:
-  void unsafe_arena_set_allocated_initialization(
-      ::onnx::GraphProto* initialization);
-  ::onnx::GraphProto* unsafe_arena_release_initialization();
-
-  // .onnx.GraphProto algorithm = 2;
-  bool has_algorithm() const;
-  private:
-  bool _internal_has_algorithm() const;
-  public:
-  void clear_algorithm();
-  const ::onnx::GraphProto& algorithm() const;
-  ::onnx::GraphProto* release_algorithm();
-  ::onnx::GraphProto* mutable_algorithm();
-  void set_allocated_algorithm(::onnx::GraphProto* algorithm);
-  private:
-  const ::onnx::GraphProto& _internal_algorithm() const;
-  ::onnx::GraphProto* _internal_mutable_algorithm();
-  public:
-  void unsafe_arena_set_allocated_algorithm(
-      ::onnx::GraphProto* algorithm);
-  ::onnx::GraphProto* unsafe_arena_release_algorithm();
-
-  // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > initialization_binding_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > update_binding_;
-  ::onnx::GraphProto* initialization_;
-  ::onnx::GraphProto* algorithm_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class ModelProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.ModelProto) */ {
- public:
-  inline ModelProto() : ModelProto(nullptr) {};
-  virtual ~ModelProto();
-
-  ModelProto(const ModelProto& from);
-  ModelProto(ModelProto&& from) noexcept
-    : ModelProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ModelProto& operator=(const ModelProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ModelProto& operator=(ModelProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ModelProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const ModelProto* internal_default_instance() {
-    return reinterpret_cast<const ModelProto*>(
-               &_ModelProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    9;
-
-  friend void swap(ModelProto& a, ModelProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ModelProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ModelProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline ModelProto* New() const final {
-    return CreateMaybeMessage<ModelProto>(nullptr);
-  }
-
-  ModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ModelProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const ModelProto& from);
-  void MergeFrom(const ModelProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(ModelProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.ModelProto";
-  }
-  protected:
-  explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOpsetImportFieldNumber = 8,
-    kMetadataPropsFieldNumber = 14,
-    kTrainingInfoFieldNumber = 20,
-    kFunctionsFieldNumber = 25,
-    kConfigurationFieldNumber = 26,
-    kProducerNameFieldNumber = 2,
-    kProducerVersionFieldNumber = 3,
-    kDomainFieldNumber = 4,
-    kDocStringFieldNumber = 6,
-    kGraphFieldNumber = 7,
-    kIrVersionFieldNumber = 1,
-    kModelVersionFieldNumber = 5,
-  };
-  // repeated .onnx.OperatorSetIdProto opset_import = 8;
-  int opset_import_size() const;
-  private:
-  int _internal_opset_import_size() const;
-  public:
-  void clear_opset_import();
-  ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-      mutable_opset_import();
-  private:
-  const ::onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* _internal_add_opset_import();
-  public:
-  const ::onnx::OperatorSetIdProto& opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* add_opset_import();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-      opset_import() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // repeated .onnx.TrainingInfoProto training_info = 20;
-  int training_info_size() const;
-  private:
-  int _internal_training_info_size() const;
-  public:
-  void clear_training_info();
-  ::onnx::TrainingInfoProto* mutable_training_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >*
-      mutable_training_info();
-  private:
-  const ::onnx::TrainingInfoProto& _internal_training_info(int index) const;
-  ::onnx::TrainingInfoProto* _internal_add_training_info();
-  public:
-  const ::onnx::TrainingInfoProto& training_info(int index) const;
-  ::onnx::TrainingInfoProto* add_training_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >&
-      training_info() const;
-
-  // repeated .onnx.FunctionProto functions = 25;
-  int functions_size() const;
-  private:
-  int _internal_functions_size() const;
-  public:
-  void clear_functions();
-  ::onnx::FunctionProto* mutable_functions(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >*
-      mutable_functions();
-  private:
-  const ::onnx::FunctionProto& _internal_functions(int index) const;
-  ::onnx::FunctionProto* _internal_add_functions();
-  public:
-  const ::onnx::FunctionProto& functions(int index) const;
-  ::onnx::FunctionProto* add_functions();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >&
-      functions() const;
-
-  // repeated .onnx.DeviceConfigurationProto configuration = 26;
-  int configuration_size() const;
-  private:
-  int _internal_configuration_size() const;
-  public:
-  void clear_configuration();
-  ::onnx::DeviceConfigurationProto* mutable_configuration(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >*
-      mutable_configuration();
-  private:
-  const ::onnx::DeviceConfigurationProto& _internal_configuration(int index) const;
-  ::onnx::DeviceConfigurationProto* _internal_add_configuration();
-  public:
-  const ::onnx::DeviceConfigurationProto& configuration(int index) const;
-  ::onnx::DeviceConfigurationProto* add_configuration();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >&
-      configuration() const;
-
-  // string producer_name = 2;
-  void clear_producer_name();
-  const std::string& producer_name() const;
-  void set_producer_name(const std::string& value);
-  void set_producer_name(std::string&& value);
-  void set_producer_name(const char* value);
-  void set_producer_name(const char* value, size_t size);
-  std::string* mutable_producer_name();
-  std::string* release_producer_name();
-  void set_allocated_producer_name(std::string* producer_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_producer_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_producer_name(
-      std::string* producer_name);
-  private:
-  const std::string& _internal_producer_name() const;
-  void _internal_set_producer_name(const std::string& value);
-  std::string* _internal_mutable_producer_name();
-  public:
-
-  // string producer_version = 3;
-  void clear_producer_version();
-  const std::string& producer_version() const;
-  void set_producer_version(const std::string& value);
-  void set_producer_version(std::string&& value);
-  void set_producer_version(const char* value);
-  void set_producer_version(const char* value, size_t size);
-  std::string* mutable_producer_version();
-  std::string* release_producer_version();
-  void set_allocated_producer_version(std::string* producer_version);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_producer_version();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_producer_version(
-      std::string* producer_version);
-  private:
-  const std::string& _internal_producer_version() const;
-  void _internal_set_producer_version(const std::string& value);
-  std::string* _internal_mutable_producer_version();
-  public:
-
-  // string domain = 4;
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // string doc_string = 6;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // .onnx.GraphProto graph = 7;
-  bool has_graph() const;
-  private:
-  bool _internal_has_graph() const;
-  public:
-  void clear_graph();
-  const ::onnx::GraphProto& graph() const;
-  ::onnx::GraphProto* release_graph();
-  ::onnx::GraphProto* mutable_graph();
-  void set_allocated_graph(::onnx::GraphProto* graph);
-  private:
-  const ::onnx::GraphProto& _internal_graph() const;
-  ::onnx::GraphProto* _internal_mutable_graph();
-  public:
-  void unsafe_arena_set_allocated_graph(
-      ::onnx::GraphProto* graph);
-  ::onnx::GraphProto* unsafe_arena_release_graph();
-
-  // int64 ir_version = 1;
-  void clear_ir_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 ir_version() const;
-  void set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_ir_version() const;
-  void _internal_set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // int64 model_version = 5;
-  void clear_model_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 model_version() const;
-  void set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_model_version() const;
-  void _internal_set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.ModelProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto > training_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto > functions_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto > configuration_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_version_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::GraphProto* graph_;
-  ::PROTOBUF_NAMESPACE_ID::int64 ir_version_;
-  ::PROTOBUF_NAMESPACE_ID::int64 model_version_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class DeviceConfigurationProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.DeviceConfigurationProto) */ {
- public:
-  inline DeviceConfigurationProto() : DeviceConfigurationProto(nullptr) {};
-  virtual ~DeviceConfigurationProto();
-
-  DeviceConfigurationProto(const DeviceConfigurationProto& from);
-  DeviceConfigurationProto(DeviceConfigurationProto&& from) noexcept
-    : DeviceConfigurationProto() {
-    *this = ::std::move(from);
-  }
-
-  inline DeviceConfigurationProto& operator=(const DeviceConfigurationProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DeviceConfigurationProto& operator=(DeviceConfigurationProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const DeviceConfigurationProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const DeviceConfigurationProto* internal_default_instance() {
-    return reinterpret_cast<const DeviceConfigurationProto*>(
-               &_DeviceConfigurationProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    10;
-
-  friend void swap(DeviceConfigurationProto& a, DeviceConfigurationProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DeviceConfigurationProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DeviceConfigurationProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline DeviceConfigurationProto* New() const final {
-    return CreateMaybeMessage<DeviceConfigurationProto>(nullptr);
-  }
-
-  DeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<DeviceConfigurationProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const DeviceConfigurationProto& from);
-  void MergeFrom(const DeviceConfigurationProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(DeviceConfigurationProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.DeviceConfigurationProto";
-  }
-  protected:
-  explicit DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDeviceFieldNumber = 3,
-    kNameFieldNumber = 1,
-    kNumDevicesFieldNumber = 2,
-  };
-  // repeated string device = 3;
-  int device_size() const;
-  private:
-  int _internal_device_size() const;
-  public:
-  void clear_device();
-  const std::string& device(int index) const;
-  std::string* mutable_device(int index);
-  void set_device(int index, const std::string& value);
-  void set_device(int index, std::string&& value);
-  void set_device(int index, const char* value);
-  void set_device(int index, const char* value, size_t size);
-  std::string* add_device();
-  void add_device(const std::string& value);
-  void add_device(std::string&& value);
-  void add_device(const char* value);
-  void add_device(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device();
-  private:
-  const std::string& _internal_device(int index) const;
-  std::string* _internal_add_device();
-  public:
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // int32 num_devices = 2;
-  void clear_num_devices();
-  ::PROTOBUF_NAMESPACE_ID::int32 num_devices() const;
-  void set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_devices() const;
-  void _internal_set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.DeviceConfigurationProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::int32 num_devices_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class StringStringEntryProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) */ {
- public:
-  inline StringStringEntryProto() : StringStringEntryProto(nullptr) {};
-  virtual ~StringStringEntryProto();
-
-  StringStringEntryProto(const StringStringEntryProto& from);
-  StringStringEntryProto(StringStringEntryProto&& from) noexcept
-    : StringStringEntryProto() {
-    *this = ::std::move(from);
-  }
-
-  inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const StringStringEntryProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const StringStringEntryProto* internal_default_instance() {
-    return reinterpret_cast<const StringStringEntryProto*>(
-               &_StringStringEntryProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    11;
-
-  friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(StringStringEntryProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(StringStringEntryProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline StringStringEntryProto* New() const final {
-    return CreateMaybeMessage<StringStringEntryProto>(nullptr);
-  }
-
-  StringStringEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<StringStringEntryProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const StringStringEntryProto& from);
-  void MergeFrom(const StringStringEntryProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(StringStringEntryProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.StringStringEntryProto";
-  }
-  protected:
-  explicit StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  // string key = 1;
-  void clear_key();
-  const std::string& key() const;
-  void set_key(const std::string& value);
-  void set_key(std::string&& value);
-  void set_key(const char* value);
-  void set_key(const char* value, size_t size);
-  std::string* mutable_key();
-  std::string* release_key();
-  void set_allocated_key(std::string* key);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_key();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_key(
-      std::string* key);
-  private:
-  const std::string& _internal_key() const;
-  void _internal_set_key(const std::string& value);
-  std::string* _internal_mutable_key();
-  public:
-
-  // string value = 2;
-  void clear_value();
-  const std::string& value() const;
-  void set_value(const std::string& value);
-  void set_value(std::string&& value);
-  void set_value(const char* value);
-  void set_value(const char* value, size_t size);
-  std::string* mutable_value();
-  std::string* release_value();
-  void set_allocated_value(std::string* value);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_value();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_value(
-      std::string* value);
-  private:
-  const std::string& _internal_value() const;
-  void _internal_set_value(const std::string& value);
-  std::string* _internal_mutable_value();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TensorAnnotation PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) */ {
- public:
-  inline TensorAnnotation() : TensorAnnotation(nullptr) {};
-  virtual ~TensorAnnotation();
-
-  TensorAnnotation(const TensorAnnotation& from);
-  TensorAnnotation(TensorAnnotation&& from) noexcept
-    : TensorAnnotation() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorAnnotation& operator=(const TensorAnnotation& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorAnnotation& operator=(TensorAnnotation&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TensorAnnotation& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorAnnotation* internal_default_instance() {
-    return reinterpret_cast<const TensorAnnotation*>(
-               &_TensorAnnotation_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    12;
-
-  friend void swap(TensorAnnotation& a, TensorAnnotation& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorAnnotation* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorAnnotation* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorAnnotation* New() const final {
-    return CreateMaybeMessage<TensorAnnotation>(nullptr);
-  }
-
-  TensorAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorAnnotation>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorAnnotation& from);
-  void MergeFrom(const TensorAnnotation& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorAnnotation* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorAnnotation";
-  }
-  protected:
-  explicit TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kQuantParameterTensorNamesFieldNumber = 2,
-    kTensorNameFieldNumber = 1,
-  };
-  // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-  int quant_parameter_tensor_names_size() const;
-  private:
-  int _internal_quant_parameter_tensor_names_size() const;
-  public:
-  void clear_quant_parameter_tensor_names();
-  ::onnx::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_quant_parameter_tensor_names();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_quant_parameter_tensor_names(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_quant_parameter_tensor_names();
-  public:
-  const ::onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
-  ::onnx::StringStringEntryProto* add_quant_parameter_tensor_names();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      quant_parameter_tensor_names() const;
-
-  // string tensor_name = 1;
-  void clear_tensor_name();
-  const std::string& tensor_name() const;
-  void set_tensor_name(const std::string& value);
-  void set_tensor_name(std::string&& value);
-  void set_tensor_name(const char* value);
-  void set_tensor_name(const char* value, size_t size);
-  std::string* mutable_tensor_name();
-  std::string* release_tensor_name();
-  void set_allocated_tensor_name(std::string* tensor_name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_tensor_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_tensor_name(
-      std::string* tensor_name);
-  private:
-  const std::string& _internal_tensor_name() const;
-  void _internal_set_tensor_name(const std::string& value);
-  std::string* _internal_mutable_tensor_name();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > quant_parameter_tensor_names_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class GraphProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.GraphProto) */ {
- public:
-  inline GraphProto() : GraphProto(nullptr) {};
-  virtual ~GraphProto();
-
-  GraphProto(const GraphProto& from);
-  GraphProto(GraphProto&& from) noexcept
-    : GraphProto() {
-    *this = ::std::move(from);
-  }
-
-  inline GraphProto& operator=(const GraphProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline GraphProto& operator=(GraphProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const GraphProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const GraphProto* internal_default_instance() {
-    return reinterpret_cast<const GraphProto*>(
-               &_GraphProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    13;
-
-  friend void swap(GraphProto& a, GraphProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(GraphProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(GraphProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline GraphProto* New() const final {
-    return CreateMaybeMessage<GraphProto>(nullptr);
-  }
-
-  GraphProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<GraphProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const GraphProto& from);
-  void MergeFrom(const GraphProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(GraphProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.GraphProto";
-  }
-  protected:
-  explicit GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNodeFieldNumber = 1,
-    kInitializerFieldNumber = 5,
-    kInputFieldNumber = 11,
-    kOutputFieldNumber = 12,
-    kValueInfoFieldNumber = 13,
-    kQuantizationAnnotationFieldNumber = 14,
-    kSparseInitializerFieldNumber = 15,
-    kMetadataPropsFieldNumber = 16,
-    kNameFieldNumber = 2,
-    kDocStringFieldNumber = 10,
-  };
-  // repeated .onnx.NodeProto node = 1;
-  int node_size() const;
-  private:
-  int _internal_node_size() const;
-  public:
-  void clear_node();
-  ::onnx::NodeProto* mutable_node(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-      mutable_node();
-  private:
-  const ::onnx::NodeProto& _internal_node(int index) const;
-  ::onnx::NodeProto* _internal_add_node();
-  public:
-  const ::onnx::NodeProto& node(int index) const;
-  ::onnx::NodeProto* add_node();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-      node() const;
-
-  // repeated .onnx.TensorProto initializer = 5;
-  int initializer_size() const;
-  private:
-  int _internal_initializer_size() const;
-  public:
-  void clear_initializer();
-  ::onnx::TensorProto* mutable_initializer(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-      mutable_initializer();
-  private:
-  const ::onnx::TensorProto& _internal_initializer(int index) const;
-  ::onnx::TensorProto* _internal_add_initializer();
-  public:
-  const ::onnx::TensorProto& initializer(int index) const;
-  ::onnx::TensorProto* add_initializer();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-      initializer() const;
-
-  // repeated .onnx.ValueInfoProto input = 11;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  ::onnx::ValueInfoProto* mutable_input(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_input();
-  private:
-  const ::onnx::ValueInfoProto& _internal_input(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_input();
-  public:
-  const ::onnx::ValueInfoProto& input(int index) const;
-  ::onnx::ValueInfoProto* add_input();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      input() const;
-
-  // repeated .onnx.ValueInfoProto output = 12;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  ::onnx::ValueInfoProto* mutable_output(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_output();
-  private:
-  const ::onnx::ValueInfoProto& _internal_output(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_output();
-  public:
-  const ::onnx::ValueInfoProto& output(int index) const;
-  ::onnx::ValueInfoProto* add_output();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      output() const;
-
-  // repeated .onnx.ValueInfoProto value_info = 13;
-  int value_info_size() const;
-  private:
-  int _internal_value_info_size() const;
-  public:
-  void clear_value_info();
-  ::onnx::ValueInfoProto* mutable_value_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_value_info();
-  private:
-  const ::onnx::ValueInfoProto& _internal_value_info(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_value_info();
-  public:
-  const ::onnx::ValueInfoProto& value_info(int index) const;
-  ::onnx::ValueInfoProto* add_value_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      value_info() const;
-
-  // repeated .onnx.TensorAnnotation quantization_annotation = 14;
-  int quantization_annotation_size() const;
-  private:
-  int _internal_quantization_annotation_size() const;
-  public:
-  void clear_quantization_annotation();
-  ::onnx::TensorAnnotation* mutable_quantization_annotation(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >*
-      mutable_quantization_annotation();
-  private:
-  const ::onnx::TensorAnnotation& _internal_quantization_annotation(int index) const;
-  ::onnx::TensorAnnotation* _internal_add_quantization_annotation();
-  public:
-  const ::onnx::TensorAnnotation& quantization_annotation(int index) const;
-  ::onnx::TensorAnnotation* add_quantization_annotation();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >&
-      quantization_annotation() const;
-
-  // repeated .onnx.SparseTensorProto sparse_initializer = 15;
-  int sparse_initializer_size() const;
-  private:
-  int _internal_sparse_initializer_size() const;
-  public:
-  void clear_sparse_initializer();
-  ::onnx::SparseTensorProto* mutable_sparse_initializer(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-      mutable_sparse_initializer();
-  private:
-  const ::onnx::SparseTensorProto& _internal_sparse_initializer(int index) const;
-  ::onnx::SparseTensorProto* _internal_add_sparse_initializer();
-  public:
-  const ::onnx::SparseTensorProto& sparse_initializer(int index) const;
-  ::onnx::SparseTensorProto* add_sparse_initializer();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-      sparse_initializer() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // string name = 2;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string doc_string = 10;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.GraphProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto > node_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto > initializer_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation > quantization_annotation_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_initializer_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TensorProto_Segment PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) */ {
- public:
-  inline TensorProto_Segment() : TensorProto_Segment(nullptr) {};
-  virtual ~TensorProto_Segment();
-
-  TensorProto_Segment(const TensorProto_Segment& from);
-  TensorProto_Segment(TensorProto_Segment&& from) noexcept
-    : TensorProto_Segment() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TensorProto_Segment& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorProto_Segment* internal_default_instance() {
-    return reinterpret_cast<const TensorProto_Segment*>(
-               &_TensorProto_Segment_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    14;
-
-  friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorProto_Segment* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorProto_Segment* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorProto_Segment* New() const final {
-    return CreateMaybeMessage<TensorProto_Segment>(nullptr);
-  }
-
-  TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorProto_Segment>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorProto_Segment& from);
-  void MergeFrom(const TensorProto_Segment& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorProto_Segment* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorProto.Segment";
-  }
-  protected:
-  explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kBeginFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-  // int64 begin = 1;
-  void clear_begin();
-  ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
-  void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_begin() const;
-  void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // int64 end = 2;
-  void clear_end();
-  ::PROTOBUF_NAMESPACE_ID::int64 end() const;
-  void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end() const;
-  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::int64 begin_;
-  ::PROTOBUF_NAMESPACE_ID::int64 end_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TensorProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto) */ {
- public:
-  inline TensorProto() : TensorProto(nullptr) {};
-  virtual ~TensorProto();
-
-  TensorProto(const TensorProto& from);
-  TensorProto(TensorProto&& from) noexcept
-    : TensorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorProto& operator=(const TensorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorProto& operator=(TensorProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TensorProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorProto* internal_default_instance() {
-    return reinterpret_cast<const TensorProto*>(
-               &_TensorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    15;
-
-  friend void swap(TensorProto& a, TensorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorProto* New() const final {
-    return CreateMaybeMessage<TensorProto>(nullptr);
-  }
-
-  TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorProto& from);
-  void MergeFrom(const TensorProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorProto";
-  }
-  protected:
-  explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TensorProto_Segment Segment;
-
-  typedef TensorProto_DataType DataType;
-  static constexpr DataType UNDEFINED =
-    TensorProto_DataType_UNDEFINED;
-  static constexpr DataType FLOAT =
-    TensorProto_DataType_FLOAT;
-  static constexpr DataType UINT8 =
-    TensorProto_DataType_UINT8;
-  static constexpr DataType INT8 =
-    TensorProto_DataType_INT8;
-  static constexpr DataType UINT16 =
-    TensorProto_DataType_UINT16;
-  static constexpr DataType INT16 =
-    TensorProto_DataType_INT16;
-  static constexpr DataType INT32 =
-    TensorProto_DataType_INT32;
-  static constexpr DataType INT64 =
-    TensorProto_DataType_INT64;
-  static constexpr DataType STRING =
-    TensorProto_DataType_STRING;
-  static constexpr DataType BOOL =
-    TensorProto_DataType_BOOL;
-  static constexpr DataType FLOAT16 =
-    TensorProto_DataType_FLOAT16;
-  static constexpr DataType DOUBLE =
-    TensorProto_DataType_DOUBLE;
-  static constexpr DataType UINT32 =
-    TensorProto_DataType_UINT32;
-  static constexpr DataType UINT64 =
-    TensorProto_DataType_UINT64;
-  static constexpr DataType COMPLEX64 =
-    TensorProto_DataType_COMPLEX64;
-  static constexpr DataType COMPLEX128 =
-    TensorProto_DataType_COMPLEX128;
-  static constexpr DataType BFLOAT16 =
-    TensorProto_DataType_BFLOAT16;
-  static constexpr DataType FLOAT8E4M3FN =
-    TensorProto_DataType_FLOAT8E4M3FN;
-  static constexpr DataType FLOAT8E4M3FNUZ =
-    TensorProto_DataType_FLOAT8E4M3FNUZ;
-  static constexpr DataType FLOAT8E5M2 =
-    TensorProto_DataType_FLOAT8E5M2;
-  static constexpr DataType FLOAT8E5M2FNUZ =
-    TensorProto_DataType_FLOAT8E5M2FNUZ;
-  static constexpr DataType UINT4 =
-    TensorProto_DataType_UINT4;
-  static constexpr DataType INT4 =
-    TensorProto_DataType_INT4;
-  static constexpr DataType FLOAT4E2M1 =
-    TensorProto_DataType_FLOAT4E2M1;
-  static constexpr DataType FLOAT8E8M0 =
-    TensorProto_DataType_FLOAT8E8M0;
-  static inline bool DataType_IsValid(int value) {
-    return TensorProto_DataType_IsValid(value);
-  }
-  static constexpr DataType DataType_MIN =
-    TensorProto_DataType_DataType_MIN;
-  static constexpr DataType DataType_MAX =
-    TensorProto_DataType_DataType_MAX;
-  static constexpr int DataType_ARRAYSIZE =
-    TensorProto_DataType_DataType_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& DataType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, DataType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function DataType_Name.");
-    return TensorProto_DataType_Name(enum_t_value);
-  }
-  static inline bool DataType_Parse(const std::string& name,
-      DataType* value) {
-    return TensorProto_DataType_Parse(name, value);
-  }
-
-  typedef TensorProto_DataLocation DataLocation;
-  static constexpr DataLocation DEFAULT =
-    TensorProto_DataLocation_DEFAULT;
-  static constexpr DataLocation EXTERNAL =
-    TensorProto_DataLocation_EXTERNAL;
-  static inline bool DataLocation_IsValid(int value) {
-    return TensorProto_DataLocation_IsValid(value);
-  }
-  static constexpr DataLocation DataLocation_MIN =
-    TensorProto_DataLocation_DataLocation_MIN;
-  static constexpr DataLocation DataLocation_MAX =
-    TensorProto_DataLocation_DataLocation_MAX;
-  static constexpr int DataLocation_ARRAYSIZE =
-    TensorProto_DataLocation_DataLocation_ARRAYSIZE;
-  template<typename T>
-  static inline const std::string& DataLocation_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, DataLocation>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function DataLocation_Name.");
-    return TensorProto_DataLocation_Name(enum_t_value);
-  }
-  static inline bool DataLocation_Parse(const std::string& name,
-      DataLocation* value) {
-    return TensorProto_DataLocation_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimsFieldNumber = 1,
-    kFloatDataFieldNumber = 4,
-    kInt32DataFieldNumber = 5,
-    kStringDataFieldNumber = 6,
-    kInt64DataFieldNumber = 7,
-    kDoubleDataFieldNumber = 10,
-    kUint64DataFieldNumber = 11,
-    kExternalDataFieldNumber = 13,
-    kMetadataPropsFieldNumber = 16,
-    kNameFieldNumber = 8,
-    kRawDataFieldNumber = 9,
-    kDocStringFieldNumber = 12,
-    kSegmentFieldNumber = 3,
-    kDataTypeFieldNumber = 2,
-    kDataLocationFieldNumber = 14,
-  };
-  // repeated int64 dims = 1;
-  int dims_size() const;
-  private:
-  int _internal_dims_size() const;
-  public:
-  void clear_dims();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_dims() const;
-  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_dims();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
-  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      dims() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_dims();
-
-  // repeated float float_data = 4 [packed = true];
-  int float_data_size() const;
-  private:
-  int _internal_float_data_size() const;
-  public:
-  void clear_float_data();
-  private:
-  float _internal_float_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      _internal_float_data() const;
-  void _internal_add_float_data(float value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      _internal_mutable_float_data();
-  public:
-  float float_data(int index) const;
-  void set_float_data(int index, float value);
-  void add_float_data(float value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-      float_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-      mutable_float_data();
-
-  // repeated int32 int32_data = 5 [packed = true];
-  int int32_data_size() const;
-  private:
-  int _internal_int32_data_size() const;
-  public:
-  void clear_int32_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-      _internal_int32_data() const;
-  void _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-      _internal_mutable_int32_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int32 int32_data(int index) const;
-  void set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
-  void add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-      int32_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-      mutable_int32_data();
-
-  // repeated bytes string_data = 6;
-  int string_data_size() const;
-  private:
-  int _internal_string_data_size() const;
-  public:
-  void clear_string_data();
-  const std::string& string_data(int index) const;
-  std::string* mutable_string_data(int index);
-  void set_string_data(int index, const std::string& value);
-  void set_string_data(int index, std::string&& value);
-  void set_string_data(int index, const char* value);
-  void set_string_data(int index, const void* value, size_t size);
-  std::string* add_string_data();
-  void add_string_data(const std::string& value);
-  void add_string_data(std::string&& value);
-  void add_string_data(const char* value);
-  void add_string_data(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
-  private:
-  const std::string& _internal_string_data(int index) const;
-  std::string* _internal_add_string_data();
-  public:
-
-  // repeated int64 int64_data = 7 [packed = true];
-  int int64_data_size() const;
-  private:
-  int _internal_int64_data_size() const;
-  public:
-  void clear_int64_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_int64_data() const;
-  void _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_int64_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 int64_data(int index) const;
-  void set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      int64_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_int64_data();
-
-  // repeated double double_data = 10 [packed = true];
-  int double_data_size() const;
-  private:
-  int _internal_double_data_size() const;
-  public:
-  void clear_double_data();
-  private:
-  double _internal_double_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-      _internal_double_data() const;
-  void _internal_add_double_data(double value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-      _internal_mutable_double_data();
-  public:
-  double double_data(int index) const;
-  void set_double_data(int index, double value);
-  void add_double_data(double value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-      double_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-      mutable_double_data();
-
-  // repeated uint64 uint64_data = 11 [packed = true];
-  int uint64_data_size() const;
-  private:
-  int _internal_uint64_data_size() const;
-  public:
-  void clear_uint64_data();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_uint64_data(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-      _internal_uint64_data() const;
-  void _internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-      _internal_mutable_uint64_data();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::uint64 uint64_data(int index) const;
-  void set_uint64_data(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
-  void add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-      uint64_data() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-      mutable_uint64_data();
-
-  // repeated .onnx.StringStringEntryProto external_data = 13;
-  int external_data_size() const;
-  private:
-  int _internal_external_data_size() const;
-  public:
-  void clear_external_data();
-  ::onnx::StringStringEntryProto* mutable_external_data(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_external_data();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_external_data(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_external_data();
-  public:
-  const ::onnx::StringStringEntryProto& external_data(int index) const;
-  ::onnx::StringStringEntryProto* add_external_data();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      external_data() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 16;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // string name = 8;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // bytes raw_data = 9;
-  void clear_raw_data();
-  const std::string& raw_data() const;
-  void set_raw_data(const std::string& value);
-  void set_raw_data(std::string&& value);
-  void set_raw_data(const char* value);
-  void set_raw_data(const void* value, size_t size);
-  std::string* mutable_raw_data();
-  std::string* release_raw_data();
-  void set_allocated_raw_data(std::string* raw_data);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_raw_data();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_raw_data(
-      std::string* raw_data);
-  private:
-  const std::string& _internal_raw_data() const;
-  void _internal_set_raw_data(const std::string& value);
-  std::string* _internal_mutable_raw_data();
-  public:
-
-  // string doc_string = 12;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // .onnx.TensorProto.Segment segment = 3;
-  bool has_segment() const;
-  private:
-  bool _internal_has_segment() const;
-  public:
-  void clear_segment();
-  const ::onnx::TensorProto_Segment& segment() const;
-  ::onnx::TensorProto_Segment* release_segment();
-  ::onnx::TensorProto_Segment* mutable_segment();
-  void set_allocated_segment(::onnx::TensorProto_Segment* segment);
-  private:
-  const ::onnx::TensorProto_Segment& _internal_segment() const;
-  ::onnx::TensorProto_Segment* _internal_mutable_segment();
-  public:
-  void unsafe_arena_set_allocated_segment(
-      ::onnx::TensorProto_Segment* segment);
-  ::onnx::TensorProto_Segment* unsafe_arena_release_segment();
-
-  // int32 data_type = 2;
-  void clear_data_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 data_type() const;
-  void set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_data_type() const;
-  void _internal_set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // .onnx.TensorProto.DataLocation data_location = 14;
-  void clear_data_location();
-  ::onnx::TensorProto_DataLocation data_location() const;
-  void set_data_location(::onnx::TensorProto_DataLocation value);
-  private:
-  ::onnx::TensorProto_DataLocation _internal_data_location() const;
-  void _internal_set_data_location(::onnx::TensorProto_DataLocation value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
-  mutable std::atomic<int> _dims_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
-  mutable std::atomic<int> _float_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_data_;
-  mutable std::atomic<int> _int32_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_data_;
-  mutable std::atomic<int> _int64_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
-  mutable std::atomic<int> _double_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > uint64_data_;
-  mutable std::atomic<int> _uint64_data_cached_byte_size_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > external_data_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::onnx::TensorProto_Segment* segment_;
-  ::PROTOBUF_NAMESPACE_ID::int32 data_type_;
-  int data_location_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class SparseTensorProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) */ {
- public:
-  inline SparseTensorProto() : SparseTensorProto(nullptr) {};
-  virtual ~SparseTensorProto();
-
-  SparseTensorProto(const SparseTensorProto& from);
-  SparseTensorProto(SparseTensorProto&& from) noexcept
-    : SparseTensorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline SparseTensorProto& operator=(const SparseTensorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SparseTensorProto& operator=(SparseTensorProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const SparseTensorProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const SparseTensorProto* internal_default_instance() {
-    return reinterpret_cast<const SparseTensorProto*>(
-               &_SparseTensorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    16;
-
-  friend void swap(SparseTensorProto& a, SparseTensorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SparseTensorProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SparseTensorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline SparseTensorProto* New() const final {
-    return CreateMaybeMessage<SparseTensorProto>(nullptr);
-  }
-
-  SparseTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<SparseTensorProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const SparseTensorProto& from);
-  void MergeFrom(const SparseTensorProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(SparseTensorProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.SparseTensorProto";
-  }
-  protected:
-  explicit SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimsFieldNumber = 3,
-    kValuesFieldNumber = 1,
-    kIndicesFieldNumber = 2,
-  };
-  // repeated int64 dims = 3;
-  int dims_size() const;
-  private:
-  int _internal_dims_size() const;
-  public:
-  void clear_dims();
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      _internal_dims() const;
-  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      _internal_mutable_dims();
-  public:
-  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
-  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
-  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-      dims() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-      mutable_dims();
-
-  // .onnx.TensorProto values = 1;
-  bool has_values() const;
-  private:
-  bool _internal_has_values() const;
-  public:
-  void clear_values();
-  const ::onnx::TensorProto& values() const;
-  ::onnx::TensorProto* release_values();
-  ::onnx::TensorProto* mutable_values();
-  void set_allocated_values(::onnx::TensorProto* values);
-  private:
-  const ::onnx::TensorProto& _internal_values() const;
-  ::onnx::TensorProto* _internal_mutable_values();
-  public:
-  void unsafe_arena_set_allocated_values(
-      ::onnx::TensorProto* values);
-  ::onnx::TensorProto* unsafe_arena_release_values();
-
-  // .onnx.TensorProto indices = 2;
-  bool has_indices() const;
-  private:
-  bool _internal_has_indices() const;
-  public:
-  void clear_indices();
-  const ::onnx::TensorProto& indices() const;
-  ::onnx::TensorProto* release_indices();
-  ::onnx::TensorProto* mutable_indices();
-  void set_allocated_indices(::onnx::TensorProto* indices);
-  private:
-  const ::onnx::TensorProto& _internal_indices() const;
-  ::onnx::TensorProto* _internal_mutable_indices();
-  public:
-  void unsafe_arena_set_allocated_indices(
-      ::onnx::TensorProto* indices);
-  ::onnx::TensorProto* unsafe_arena_release_indices();
-
-  // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
-  mutable std::atomic<int> _dims_cached_byte_size_;
-  ::onnx::TensorProto* values_;
-  ::onnx::TensorProto* indices_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TensorShapeProto_Dimension PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) */ {
- public:
-  inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {};
-  virtual ~TensorShapeProto_Dimension();
-
-  TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
-  TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
-    : TensorShapeProto_Dimension() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TensorShapeProto_Dimension& default_instance();
-
-  enum ValueCase {
-    kDimValue = 1,
-    kDimParam = 2,
-    VALUE_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorShapeProto_Dimension* internal_default_instance() {
-    return reinterpret_cast<const TensorShapeProto_Dimension*>(
-               &_TensorShapeProto_Dimension_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    17;
-
-  friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorShapeProto_Dimension* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorShapeProto_Dimension* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorShapeProto_Dimension* New() const final {
-    return CreateMaybeMessage<TensorShapeProto_Dimension>(nullptr);
-  }
-
-  TensorShapeProto_Dimension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorShapeProto_Dimension>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorShapeProto_Dimension& from);
-  void MergeFrom(const TensorShapeProto_Dimension& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorShapeProto_Dimension* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorShapeProto.Dimension";
-  }
-  protected:
-  explicit TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDenotationFieldNumber = 3,
-    kDimValueFieldNumber = 1,
-    kDimParamFieldNumber = 2,
-  };
-  // string denotation = 3;
-  void clear_denotation();
-  const std::string& denotation() const;
-  void set_denotation(const std::string& value);
-  void set_denotation(std::string&& value);
-  void set_denotation(const char* value);
-  void set_denotation(const char* value, size_t size);
-  std::string* mutable_denotation();
-  std::string* release_denotation();
-  void set_allocated_denotation(std::string* denotation);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_denotation();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_denotation(
-      std::string* denotation);
-  private:
-  const std::string& _internal_denotation() const;
-  void _internal_set_denotation(const std::string& value);
-  std::string* _internal_mutable_denotation();
-  public:
-
-  // int64 dim_value = 1;
-  private:
-  bool _internal_has_dim_value() const;
-  public:
-  void clear_dim_value();
-  ::PROTOBUF_NAMESPACE_ID::int64 dim_value() const;
-  void set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dim_value() const;
-  void _internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // string dim_param = 2;
-  private:
-  bool _internal_has_dim_param() const;
-  public:
-  void clear_dim_param();
-  const std::string& dim_param() const;
-  void set_dim_param(const std::string& value);
-  void set_dim_param(std::string&& value);
-  void set_dim_param(const char* value);
-  void set_dim_param(const char* value, size_t size);
-  std::string* mutable_dim_param();
-  std::string* release_dim_param();
-  void set_allocated_dim_param(std::string* dim_param);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_dim_param();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_dim_param(
-      std::string* dim_param);
-  private:
-  const std::string& _internal_dim_param() const;
-  void _internal_set_dim_param(const std::string& value);
-  std::string* _internal_mutable_dim_param();
-  public:
-
-  void clear_value();
-  ValueCase value_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension)
- private:
-  class _Internal;
-  void set_has_dim_value();
-  void set_has_dim_param();
-
-  inline bool has_value() const;
-  inline void clear_has_value();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
-  union ValueUnion {
-    ValueUnion() {}
-    ::PROTOBUF_NAMESPACE_ID::int64 dim_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
-  } value_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TensorShapeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) */ {
- public:
-  inline TensorShapeProto() : TensorShapeProto(nullptr) {};
-  virtual ~TensorShapeProto();
-
-  TensorShapeProto(const TensorShapeProto& from);
-  TensorShapeProto(TensorShapeProto&& from) noexcept
-    : TensorShapeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TensorShapeProto& operator=(const TensorShapeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TensorShapeProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TensorShapeProto* internal_default_instance() {
-    return reinterpret_cast<const TensorShapeProto*>(
-               &_TensorShapeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    18;
-
-  friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TensorShapeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TensorShapeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TensorShapeProto* New() const final {
-    return CreateMaybeMessage<TensorShapeProto>(nullptr);
-  }
-
-  TensorShapeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TensorShapeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TensorShapeProto& from);
-  void MergeFrom(const TensorShapeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TensorShapeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TensorShapeProto";
-  }
-  protected:
-  explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TensorShapeProto_Dimension Dimension;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDimFieldNumber = 1,
-  };
-  // repeated .onnx.TensorShapeProto.Dimension dim = 1;
-  int dim_size() const;
-  private:
-  int _internal_dim_size() const;
-  public:
-  void clear_dim();
-  ::onnx::TensorShapeProto_Dimension* mutable_dim(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >*
-      mutable_dim();
-  private:
-  const ::onnx::TensorShapeProto_Dimension& _internal_dim(int index) const;
-  ::onnx::TensorShapeProto_Dimension* _internal_add_dim();
-  public:
-  const ::onnx::TensorShapeProto_Dimension& dim(int index) const;
-  ::onnx::TensorShapeProto_Dimension* add_dim();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >&
-      dim() const;
-
-  // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension > dim_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Tensor PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) */ {
- public:
-  inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {};
-  virtual ~TypeProto_Tensor();
-
-  TypeProto_Tensor(const TypeProto_Tensor& from);
-  TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
-    : TypeProto_Tensor() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto_Tensor& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Tensor* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Tensor*>(
-               &_TypeProto_Tensor_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    19;
-
-  friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Tensor* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Tensor* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Tensor* New() const final {
-    return CreateMaybeMessage<TypeProto_Tensor>(nullptr);
-  }
-
-  TypeProto_Tensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Tensor>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Tensor& from);
-  void MergeFrom(const TypeProto_Tensor& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Tensor* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Tensor";
-  }
-  protected:
-  explicit TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShapeFieldNumber = 2,
-    kElemTypeFieldNumber = 1,
-  };
-  // .onnx.TensorShapeProto shape = 2;
-  bool has_shape() const;
-  private:
-  bool _internal_has_shape() const;
-  public:
-  void clear_shape();
-  const ::onnx::TensorShapeProto& shape() const;
-  ::onnx::TensorShapeProto* release_shape();
-  ::onnx::TensorShapeProto* mutable_shape();
-  void set_allocated_shape(::onnx::TensorShapeProto* shape);
-  private:
-  const ::onnx::TensorShapeProto& _internal_shape() const;
-  ::onnx::TensorShapeProto* _internal_mutable_shape();
-  public:
-  void unsafe_arena_set_allocated_shape(
-      ::onnx::TensorShapeProto* shape);
-  ::onnx::TensorShapeProto* unsafe_arena_release_shape();
-
-  // int32 elem_type = 1;
-  void clear_elem_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
-  void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
-  void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::onnx::TensorShapeProto* shape_;
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Sequence PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) */ {
- public:
-  inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {};
-  virtual ~TypeProto_Sequence();
-
-  TypeProto_Sequence(const TypeProto_Sequence& from);
-  TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
-    : TypeProto_Sequence() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Sequence& operator=(TypeProto_Sequence&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto_Sequence& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Sequence* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Sequence*>(
-               &_TypeProto_Sequence_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    20;
-
-  friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Sequence* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Sequence* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Sequence* New() const final {
-    return CreateMaybeMessage<TypeProto_Sequence>(nullptr);
-  }
-
-  TypeProto_Sequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Sequence>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Sequence& from);
-  void MergeFrom(const TypeProto_Sequence& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Sequence* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Sequence";
-  }
-  protected:
-  explicit TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kElemTypeFieldNumber = 1,
-  };
-  // .onnx.TypeProto elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  const ::onnx::TypeProto& elem_type() const;
-  ::onnx::TypeProto* release_elem_type();
-  ::onnx::TypeProto* mutable_elem_type();
-  void set_allocated_elem_type(::onnx::TypeProto* elem_type);
-  private:
-  const ::onnx::TypeProto& _internal_elem_type() const;
-  ::onnx::TypeProto* _internal_mutable_elem_type();
-  public:
-  void unsafe_arena_set_allocated_elem_type(
-      ::onnx::TypeProto* elem_type);
-  ::onnx::TypeProto* unsafe_arena_release_elem_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::onnx::TypeProto* elem_type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Map PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) */ {
- public:
-  inline TypeProto_Map() : TypeProto_Map(nullptr) {};
-  virtual ~TypeProto_Map();
-
-  TypeProto_Map(const TypeProto_Map& from);
-  TypeProto_Map(TypeProto_Map&& from) noexcept
-    : TypeProto_Map() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Map& operator=(const TypeProto_Map& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Map& operator=(TypeProto_Map&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto_Map& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Map* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Map*>(
-               &_TypeProto_Map_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    21;
-
-  friend void swap(TypeProto_Map& a, TypeProto_Map& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Map* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Map* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Map* New() const final {
-    return CreateMaybeMessage<TypeProto_Map>(nullptr);
-  }
-
-  TypeProto_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Map>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Map& from);
-  void MergeFrom(const TypeProto_Map& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Map* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Map";
-  }
-  protected:
-  explicit TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueTypeFieldNumber = 2,
-    kKeyTypeFieldNumber = 1,
-  };
-  // .onnx.TypeProto value_type = 2;
-  bool has_value_type() const;
-  private:
-  bool _internal_has_value_type() const;
-  public:
-  void clear_value_type();
-  const ::onnx::TypeProto& value_type() const;
-  ::onnx::TypeProto* release_value_type();
-  ::onnx::TypeProto* mutable_value_type();
-  void set_allocated_value_type(::onnx::TypeProto* value_type);
-  private:
-  const ::onnx::TypeProto& _internal_value_type() const;
-  ::onnx::TypeProto* _internal_mutable_value_type();
-  public:
-  void unsafe_arena_set_allocated_value_type(
-      ::onnx::TypeProto* value_type);
-  ::onnx::TypeProto* unsafe_arena_release_value_type();
-
-  // int32 key_type = 1;
-  void clear_key_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 key_type() const;
-  void set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_key_type() const;
-  void _internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::onnx::TypeProto* value_type_;
-  ::PROTOBUF_NAMESPACE_ID::int32 key_type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_Optional PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) */ {
- public:
-  inline TypeProto_Optional() : TypeProto_Optional(nullptr) {};
-  virtual ~TypeProto_Optional();
-
-  TypeProto_Optional(const TypeProto_Optional& from);
-  TypeProto_Optional(TypeProto_Optional&& from) noexcept
-    : TypeProto_Optional() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_Optional& operator=(TypeProto_Optional&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto_Optional& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_Optional* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_Optional*>(
-               &_TypeProto_Optional_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    22;
-
-  friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_Optional* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_Optional* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_Optional* New() const final {
-    return CreateMaybeMessage<TypeProto_Optional>(nullptr);
-  }
-
-  TypeProto_Optional* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_Optional>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_Optional& from);
-  void MergeFrom(const TypeProto_Optional& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_Optional* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.Optional";
-  }
-  protected:
-  explicit TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kElemTypeFieldNumber = 1,
-  };
-  // .onnx.TypeProto elem_type = 1;
-  bool has_elem_type() const;
-  private:
-  bool _internal_has_elem_type() const;
-  public:
-  void clear_elem_type();
-  const ::onnx::TypeProto& elem_type() const;
-  ::onnx::TypeProto* release_elem_type();
-  ::onnx::TypeProto* mutable_elem_type();
-  void set_allocated_elem_type(::onnx::TypeProto* elem_type);
-  private:
-  const ::onnx::TypeProto& _internal_elem_type() const;
-  ::onnx::TypeProto* _internal_mutable_elem_type();
-  public:
-  void unsafe_arena_set_allocated_elem_type(
-      ::onnx::TypeProto* elem_type);
-  ::onnx::TypeProto* unsafe_arena_release_elem_type();
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::onnx::TypeProto* elem_type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto_SparseTensor PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) */ {
- public:
-  inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {};
-  virtual ~TypeProto_SparseTensor();
-
-  TypeProto_SparseTensor(const TypeProto_SparseTensor& from);
-  TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
-    : TypeProto_SparseTensor() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto_SparseTensor& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto_SparseTensor* internal_default_instance() {
-    return reinterpret_cast<const TypeProto_SparseTensor*>(
-               &_TypeProto_SparseTensor_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    23;
-
-  friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto_SparseTensor* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto_SparseTensor* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto_SparseTensor* New() const final {
-    return CreateMaybeMessage<TypeProto_SparseTensor>(nullptr);
-  }
-
-  TypeProto_SparseTensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto_SparseTensor>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto_SparseTensor& from);
-  void MergeFrom(const TypeProto_SparseTensor& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto_SparseTensor* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto.SparseTensor";
-  }
-  protected:
-  explicit TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kShapeFieldNumber = 2,
-    kElemTypeFieldNumber = 1,
-  };
-  // .onnx.TensorShapeProto shape = 2;
-  bool has_shape() const;
-  private:
-  bool _internal_has_shape() const;
-  public:
-  void clear_shape();
-  const ::onnx::TensorShapeProto& shape() const;
-  ::onnx::TensorShapeProto* release_shape();
-  ::onnx::TensorShapeProto* mutable_shape();
-  void set_allocated_shape(::onnx::TensorShapeProto* shape);
-  private:
-  const ::onnx::TensorShapeProto& _internal_shape() const;
-  ::onnx::TensorShapeProto* _internal_mutable_shape();
-  public:
-  void unsafe_arena_set_allocated_shape(
-      ::onnx::TensorShapeProto* shape);
-  ::onnx::TensorShapeProto* unsafe_arena_release_shape();
-
-  // int32 elem_type = 1;
-  void clear_elem_type();
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
-  void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
-  void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::onnx::TensorShapeProto* shape_;
-  ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class TypeProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto) */ {
- public:
-  inline TypeProto() : TypeProto(nullptr) {};
-  virtual ~TypeProto();
-
-  TypeProto(const TypeProto& from);
-  TypeProto(TypeProto&& from) noexcept
-    : TypeProto() {
-    *this = ::std::move(from);
-  }
-
-  inline TypeProto& operator=(const TypeProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TypeProto& operator=(TypeProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const TypeProto& default_instance();
-
-  enum ValueCase {
-    kTensorType = 1,
-    kSequenceType = 4,
-    kMapType = 5,
-    kOptionalType = 9,
-    kSparseTensorType = 8,
-    VALUE_NOT_SET = 0,
-  };
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TypeProto* internal_default_instance() {
-    return reinterpret_cast<const TypeProto*>(
-               &_TypeProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    24;
-
-  friend void swap(TypeProto& a, TypeProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TypeProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(TypeProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TypeProto* New() const final {
-    return CreateMaybeMessage<TypeProto>(nullptr);
-  }
-
-  TypeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TypeProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const TypeProto& from);
-  void MergeFrom(const TypeProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(TypeProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.TypeProto";
-  }
-  protected:
-  explicit TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef TypeProto_Tensor Tensor;
-  typedef TypeProto_Sequence Sequence;
-  typedef TypeProto_Map Map;
-  typedef TypeProto_Optional Optional;
-  typedef TypeProto_SparseTensor SparseTensor;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDenotationFieldNumber = 6,
-    kTensorTypeFieldNumber = 1,
-    kSequenceTypeFieldNumber = 4,
-    kMapTypeFieldNumber = 5,
-    kOptionalTypeFieldNumber = 9,
-    kSparseTensorTypeFieldNumber = 8,
-  };
-  // string denotation = 6;
-  void clear_denotation();
-  const std::string& denotation() const;
-  void set_denotation(const std::string& value);
-  void set_denotation(std::string&& value);
-  void set_denotation(const char* value);
-  void set_denotation(const char* value, size_t size);
-  std::string* mutable_denotation();
-  std::string* release_denotation();
-  void set_allocated_denotation(std::string* denotation);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_denotation();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_denotation(
-      std::string* denotation);
-  private:
-  const std::string& _internal_denotation() const;
-  void _internal_set_denotation(const std::string& value);
-  std::string* _internal_mutable_denotation();
-  public:
-
-  // .onnx.TypeProto.Tensor tensor_type = 1;
-  bool has_tensor_type() const;
-  private:
-  bool _internal_has_tensor_type() const;
-  public:
-  void clear_tensor_type();
-  const ::onnx::TypeProto_Tensor& tensor_type() const;
-  ::onnx::TypeProto_Tensor* release_tensor_type();
-  ::onnx::TypeProto_Tensor* mutable_tensor_type();
-  void set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type);
-  private:
-  const ::onnx::TypeProto_Tensor& _internal_tensor_type() const;
-  ::onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
-  public:
-  void unsafe_arena_set_allocated_tensor_type(
-      ::onnx::TypeProto_Tensor* tensor_type);
-  ::onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
-
-  // .onnx.TypeProto.Sequence sequence_type = 4;
-  bool has_sequence_type() const;
-  private:
-  bool _internal_has_sequence_type() const;
-  public:
-  void clear_sequence_type();
-  const ::onnx::TypeProto_Sequence& sequence_type() const;
-  ::onnx::TypeProto_Sequence* release_sequence_type();
-  ::onnx::TypeProto_Sequence* mutable_sequence_type();
-  void set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type);
-  private:
-  const ::onnx::TypeProto_Sequence& _internal_sequence_type() const;
-  ::onnx::TypeProto_Sequence* _internal_mutable_sequence_type();
-  public:
-  void unsafe_arena_set_allocated_sequence_type(
-      ::onnx::TypeProto_Sequence* sequence_type);
-  ::onnx::TypeProto_Sequence* unsafe_arena_release_sequence_type();
-
-  // .onnx.TypeProto.Map map_type = 5;
-  bool has_map_type() const;
-  private:
-  bool _internal_has_map_type() const;
-  public:
-  void clear_map_type();
-  const ::onnx::TypeProto_Map& map_type() const;
-  ::onnx::TypeProto_Map* release_map_type();
-  ::onnx::TypeProto_Map* mutable_map_type();
-  void set_allocated_map_type(::onnx::TypeProto_Map* map_type);
-  private:
-  const ::onnx::TypeProto_Map& _internal_map_type() const;
-  ::onnx::TypeProto_Map* _internal_mutable_map_type();
-  public:
-  void unsafe_arena_set_allocated_map_type(
-      ::onnx::TypeProto_Map* map_type);
-  ::onnx::TypeProto_Map* unsafe_arena_release_map_type();
-
-  // .onnx.TypeProto.Optional optional_type = 9;
-  bool has_optional_type() const;
-  private:
-  bool _internal_has_optional_type() const;
-  public:
-  void clear_optional_type();
-  const ::onnx::TypeProto_Optional& optional_type() const;
-  ::onnx::TypeProto_Optional* release_optional_type();
-  ::onnx::TypeProto_Optional* mutable_optional_type();
-  void set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type);
-  private:
-  const ::onnx::TypeProto_Optional& _internal_optional_type() const;
-  ::onnx::TypeProto_Optional* _internal_mutable_optional_type();
-  public:
-  void unsafe_arena_set_allocated_optional_type(
-      ::onnx::TypeProto_Optional* optional_type);
-  ::onnx::TypeProto_Optional* unsafe_arena_release_optional_type();
-
-  // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-  bool has_sparse_tensor_type() const;
-  private:
-  bool _internal_has_sparse_tensor_type() const;
-  public:
-  void clear_sparse_tensor_type();
-  const ::onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
-  ::onnx::TypeProto_SparseTensor* release_sparse_tensor_type();
-  ::onnx::TypeProto_SparseTensor* mutable_sparse_tensor_type();
-  void set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type);
-  private:
-  const ::onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
-  ::onnx::TypeProto_SparseTensor* _internal_mutable_sparse_tensor_type();
-  public:
-  void unsafe_arena_set_allocated_sparse_tensor_type(
-      ::onnx::TypeProto_SparseTensor* sparse_tensor_type);
-  ::onnx::TypeProto_SparseTensor* unsafe_arena_release_sparse_tensor_type();
-
-  void clear_value();
-  ValueCase value_case() const;
-  // @@protoc_insertion_point(class_scope:onnx.TypeProto)
- private:
-  class _Internal;
-  void set_has_tensor_type();
-  void set_has_sequence_type();
-  void set_has_map_type();
-  void set_has_optional_type();
-  void set_has_sparse_tensor_type();
-
-  inline bool has_value() const;
-  inline void clear_has_value();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
-  union ValueUnion {
-    ValueUnion() {}
-    ::onnx::TypeProto_Tensor* tensor_type_;
-    ::onnx::TypeProto_Sequence* sequence_type_;
-    ::onnx::TypeProto_Map* map_type_;
-    ::onnx::TypeProto_Optional* optional_type_;
-    ::onnx::TypeProto_SparseTensor* sparse_tensor_type_;
-  } value_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class OperatorSetIdProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) */ {
- public:
-  inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {};
-  virtual ~OperatorSetIdProto();
-
-  OperatorSetIdProto(const OperatorSetIdProto& from);
-  OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
-    : OperatorSetIdProto() {
-    *this = ::std::move(from);
-  }
-
-  inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const OperatorSetIdProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const OperatorSetIdProto* internal_default_instance() {
-    return reinterpret_cast<const OperatorSetIdProto*>(
-               &_OperatorSetIdProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    25;
-
-  friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(OperatorSetIdProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(OperatorSetIdProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline OperatorSetIdProto* New() const final {
-    return CreateMaybeMessage<OperatorSetIdProto>(nullptr);
-  }
-
-  OperatorSetIdProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<OperatorSetIdProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const OperatorSetIdProto& from);
-  void MergeFrom(const OperatorSetIdProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(OperatorSetIdProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.OperatorSetIdProto";
-  }
-  protected:
-  explicit OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDomainFieldNumber = 1,
-    kVersionFieldNumber = 2,
-  };
-  // string domain = 1;
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // int64 version = 2;
-  void clear_version();
-  ::PROTOBUF_NAMESPACE_ID::int64 version() const;
-  void set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::int64 _internal_version() const;
-  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::int64 version_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// -------------------------------------------------------------------
-
-class FunctionProto PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) */ {
- public:
-  inline FunctionProto() : FunctionProto(nullptr) {};
-  virtual ~FunctionProto();
-
-  FunctionProto(const FunctionProto& from);
-  FunctionProto(FunctionProto&& from) noexcept
-    : FunctionProto() {
-    *this = ::std::move(from);
-  }
-
-  inline FunctionProto& operator=(const FunctionProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FunctionProto& operator=(FunctionProto&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const FunctionProto& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const FunctionProto* internal_default_instance() {
-    return reinterpret_cast<const FunctionProto*>(
-               &_FunctionProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    26;
-
-  friend void swap(FunctionProto& a, FunctionProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FunctionProto* other) {
-    if (other == this) return;
-    if (GetArena() == other->GetArena()) {
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FunctionProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline FunctionProto* New() const final {
-    return CreateMaybeMessage<FunctionProto>(nullptr);
-  }
-
-  FunctionProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<FunctionProto>(arena);
-  }
-  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
-    final;
-  void CopyFrom(const FunctionProto& from);
-  void MergeFrom(const FunctionProto& from);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  void DiscardUnknownFields();
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-
-  private:
-  inline void SharedCtor();
-  inline void SharedDtor();
-  void SetCachedSize(int size) const;
-  void InternalSwap(FunctionProto* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "onnx.FunctionProto";
-  }
-  protected:
-  explicit FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  public:
-
-  std::string GetTypeName() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kInputFieldNumber = 4,
-    kOutputFieldNumber = 5,
-    kAttributeFieldNumber = 6,
-    kNodeFieldNumber = 7,
-    kOpsetImportFieldNumber = 9,
-    kAttributeProtoFieldNumber = 11,
-    kValueInfoFieldNumber = 12,
-    kMetadataPropsFieldNumber = 14,
-    kNameFieldNumber = 1,
-    kDocStringFieldNumber = 8,
-    kDomainFieldNumber = 10,
-    kOverloadFieldNumber = 13,
-  };
-  // repeated string input = 4;
-  int input_size() const;
-  private:
-  int _internal_input_size() const;
-  public:
-  void clear_input();
-  const std::string& input(int index) const;
-  std::string* mutable_input(int index);
-  void set_input(int index, const std::string& value);
-  void set_input(int index, std::string&& value);
-  void set_input(int index, const char* value);
-  void set_input(int index, const char* value, size_t size);
-  std::string* add_input();
-  void add_input(const std::string& value);
-  void add_input(std::string&& value);
-  void add_input(const char* value);
-  void add_input(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
-  private:
-  const std::string& _internal_input(int index) const;
-  std::string* _internal_add_input();
-  public:
-
-  // repeated string output = 5;
-  int output_size() const;
-  private:
-  int _internal_output_size() const;
-  public:
-  void clear_output();
-  const std::string& output(int index) const;
-  std::string* mutable_output(int index);
-  void set_output(int index, const std::string& value);
-  void set_output(int index, std::string&& value);
-  void set_output(int index, const char* value);
-  void set_output(int index, const char* value, size_t size);
-  std::string* add_output();
-  void add_output(const std::string& value);
-  void add_output(std::string&& value);
-  void add_output(const char* value);
-  void add_output(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
-  private:
-  const std::string& _internal_output(int index) const;
-  std::string* _internal_add_output();
-  public:
-
-  // repeated string attribute = 6;
-  int attribute_size() const;
-  private:
-  int _internal_attribute_size() const;
-  public:
-  void clear_attribute();
-  const std::string& attribute(int index) const;
-  std::string* mutable_attribute(int index);
-  void set_attribute(int index, const std::string& value);
-  void set_attribute(int index, std::string&& value);
-  void set_attribute(int index, const char* value);
-  void set_attribute(int index, const char* value, size_t size);
-  std::string* add_attribute();
-  void add_attribute(const std::string& value);
-  void add_attribute(std::string&& value);
-  void add_attribute(const char* value);
-  void add_attribute(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& attribute() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_attribute();
-  private:
-  const std::string& _internal_attribute(int index) const;
-  std::string* _internal_add_attribute();
-  public:
-
-  // repeated .onnx.NodeProto node = 7;
-  int node_size() const;
-  private:
-  int _internal_node_size() const;
-  public:
-  void clear_node();
-  ::onnx::NodeProto* mutable_node(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-      mutable_node();
-  private:
-  const ::onnx::NodeProto& _internal_node(int index) const;
-  ::onnx::NodeProto* _internal_add_node();
-  public:
-  const ::onnx::NodeProto& node(int index) const;
-  ::onnx::NodeProto* add_node();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-      node() const;
-
-  // repeated .onnx.OperatorSetIdProto opset_import = 9;
-  int opset_import_size() const;
-  private:
-  int _internal_opset_import_size() const;
-  public:
-  void clear_opset_import();
-  ::onnx::OperatorSetIdProto* mutable_opset_import(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-      mutable_opset_import();
-  private:
-  const ::onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* _internal_add_opset_import();
-  public:
-  const ::onnx::OperatorSetIdProto& opset_import(int index) const;
-  ::onnx::OperatorSetIdProto* add_opset_import();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-      opset_import() const;
-
-  // repeated .onnx.AttributeProto attribute_proto = 11;
-  int attribute_proto_size() const;
-  private:
-  int _internal_attribute_proto_size() const;
-  public:
-  void clear_attribute_proto();
-  ::onnx::AttributeProto* mutable_attribute_proto(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-      mutable_attribute_proto();
-  private:
-  const ::onnx::AttributeProto& _internal_attribute_proto(int index) const;
-  ::onnx::AttributeProto* _internal_add_attribute_proto();
-  public:
-  const ::onnx::AttributeProto& attribute_proto(int index) const;
-  ::onnx::AttributeProto* add_attribute_proto();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-      attribute_proto() const;
-
-  // repeated .onnx.ValueInfoProto value_info = 12;
-  int value_info_size() const;
-  private:
-  int _internal_value_info_size() const;
-  public:
-  void clear_value_info();
-  ::onnx::ValueInfoProto* mutable_value_info(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-      mutable_value_info();
-  private:
-  const ::onnx::ValueInfoProto& _internal_value_info(int index) const;
-  ::onnx::ValueInfoProto* _internal_add_value_info();
-  public:
-  const ::onnx::ValueInfoProto& value_info(int index) const;
-  ::onnx::ValueInfoProto* add_value_info();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-      value_info() const;
-
-  // repeated .onnx.StringStringEntryProto metadata_props = 14;
-  int metadata_props_size() const;
-  private:
-  int _internal_metadata_props_size() const;
-  public:
-  void clear_metadata_props();
-  ::onnx::StringStringEntryProto* mutable_metadata_props(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-      mutable_metadata_props();
-  private:
-  const ::onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* _internal_add_metadata_props();
-  public:
-  const ::onnx::StringStringEntryProto& metadata_props(int index) const;
-  ::onnx::StringStringEntryProto* add_metadata_props();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-      metadata_props() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
-  std::string* mutable_name();
-  std::string* release_name();
-  void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string doc_string = 8;
-  void clear_doc_string();
-  const std::string& doc_string() const;
-  void set_doc_string(const std::string& value);
-  void set_doc_string(std::string&& value);
-  void set_doc_string(const char* value);
-  void set_doc_string(const char* value, size_t size);
-  std::string* mutable_doc_string();
-  std::string* release_doc_string();
-  void set_allocated_doc_string(std::string* doc_string);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_doc_string();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_doc_string(
-      std::string* doc_string);
-  private:
-  const std::string& _internal_doc_string() const;
-  void _internal_set_doc_string(const std::string& value);
-  std::string* _internal_mutable_doc_string();
-  public:
-
-  // string domain = 10;
-  void clear_domain();
-  const std::string& domain() const;
-  void set_domain(const std::string& value);
-  void set_domain(std::string&& value);
-  void set_domain(const char* value);
-  void set_domain(const char* value, size_t size);
-  std::string* mutable_domain();
-  std::string* release_domain();
-  void set_allocated_domain(std::string* domain);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_domain();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_domain(
-      std::string* domain);
-  private:
-  const std::string& _internal_domain() const;
-  void _internal_set_domain(const std::string& value);
-  std::string* _internal_mutable_domain();
-  public:
-
-  // string overload = 13;
-  void clear_overload();
-  const std::string& overload() const;
-  void set_overload(const std::string& value);
-  void set_overload(std::string&& value);
-  void set_overload(const char* value);
-  void set_overload(const char* value, size_t size);
-  std::string* mutable_overload();
-  std::string* release_overload();
-  void set_allocated_overload(std::string* overload);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_overload();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_overload(
-      std::string* overload);
-  private:
-  const std::string& _internal_overload() const;
-  void _internal_set_overload(const std::string& value);
-  std::string* _internal_mutable_overload();
-  public:
-
-  // @@protoc_insertion_point(class_scope:onnx.FunctionProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> attribute_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto > node_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto > opset_import_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto > attribute_proto_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto > value_info_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto > metadata_props_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_onnx_2eproto3;
-};
-// ===================================================================
-
-
-// ===================================================================
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// AttributeProto
-
-// string name = 1;
-inline void AttributeProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& AttributeProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.name)
-  return _internal_name();
-}
-inline void AttributeProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& AttributeProto::_internal_name() const {
-  return name_.Get();
-}
-inline void AttributeProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.name)
-}
-inline void AttributeProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.name)
-}
-inline void AttributeProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name)
-}
-inline std::string* AttributeProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.name)
-}
-
-// string ref_attr_name = 21;
-inline void AttributeProto::clear_ref_attr_name() {
-  ref_attr_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& AttributeProto::ref_attr_name() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name)
-  return _internal_ref_attr_name();
-}
-inline void AttributeProto::set_ref_attr_name(const std::string& value) {
-  _internal_set_ref_attr_name(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::mutable_ref_attr_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name)
-  return _internal_mutable_ref_attr_name();
-}
-inline const std::string& AttributeProto::_internal_ref_attr_name() const {
-  return ref_attr_name_.Get();
-}
-inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
-  
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_ref_attr_name(std::string&& value) {
-  
-  ref_attr_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.ref_attr_name)
-}
-inline void AttributeProto::set_ref_attr_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.ref_attr_name)
-}
-inline void AttributeProto::set_ref_attr_name(const char* value,
-    size_t size) {
-  
-  ref_attr_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
-  
-  return ref_attr_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_ref_attr_name() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name)
-  return ref_attr_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_ref_attr_name(std::string* ref_attr_name) {
-  if (ref_attr_name != nullptr) {
-    
-  } else {
-    
-  }
-  ref_attr_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ref_attr_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name)
-}
-inline std::string* AttributeProto::unsafe_arena_release_ref_attr_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.ref_attr_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return ref_attr_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_ref_attr_name(
-    std::string* ref_attr_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (ref_attr_name != nullptr) {
-    
-  } else {
-    
-  }
-  ref_attr_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ref_attr_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.ref_attr_name)
-}
-
-// string doc_string = 13;
-inline void AttributeProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& AttributeProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string)
-  return _internal_doc_string();
-}
-inline void AttributeProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& AttributeProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.doc_string)
-}
-inline void AttributeProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.doc_string)
-}
-inline void AttributeProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string)
-}
-inline std::string* AttributeProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.doc_string)
-}
-
-// .onnx.AttributeProto.AttributeType type = 20;
-inline void AttributeProto::clear_type() {
-  type_ = 0;
-}
-inline ::onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
-  return static_cast< ::onnx::AttributeProto_AttributeType >(type_);
-}
-inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type)
-  return _internal_type();
-}
-inline void AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) {
-  
-  type_ = value;
-}
-inline void AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) {
-  _internal_set_type(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.type)
-}
-
-// float f = 2;
-inline void AttributeProto::clear_f() {
-  f_ = 0;
-}
-inline float AttributeProto::_internal_f() const {
-  return f_;
-}
-inline float AttributeProto::f() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.f)
-  return _internal_f();
-}
-inline void AttributeProto::_internal_set_f(float value) {
-  
-  f_ = value;
-}
-inline void AttributeProto::set_f(float value) {
-  _internal_set_f(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.f)
-}
-
-// int64 i = 3;
-inline void AttributeProto::clear_i() {
-  i_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::_internal_i() const {
-  return i_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::i() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.i)
-  return _internal_i();
-}
-inline void AttributeProto::_internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  i_ = value;
-}
-inline void AttributeProto::set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_i(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.i)
-}
-
-// bytes s = 4;
-inline void AttributeProto::clear_s() {
-  s_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& AttributeProto::s() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.s)
-  return _internal_s();
-}
-inline void AttributeProto::set_s(const std::string& value) {
-  _internal_set_s(value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::mutable_s() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s)
-  return _internal_mutable_s();
-}
-inline const std::string& AttributeProto::_internal_s() const {
-  return s_.Get();
-}
-inline void AttributeProto::_internal_set_s(const std::string& value) {
-  
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void AttributeProto::set_s(std::string&& value) {
-  
-  s_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.AttributeProto.s)
-}
-inline void AttributeProto::set_s(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.s)
-}
-inline void AttributeProto::set_s(const void* value,
-    size_t size) {
-  
-  s_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::_internal_mutable_s() {
-  
-  return s_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* AttributeProto::release_s() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.s)
-  return s_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void AttributeProto::set_allocated_s(std::string* s) {
-  if (s != nullptr) {
-    
-  } else {
-    
-  }
-  s_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), s,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s)
-}
-inline std::string* AttributeProto::unsafe_arena_release_s() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.AttributeProto.s)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return s_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void AttributeProto::unsafe_arena_set_allocated_s(
-    std::string* s) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (s != nullptr) {
-    
-  } else {
-    
-  }
-  s_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      s, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.s)
-}
-
-// .onnx.TensorProto t = 5;
-inline bool AttributeProto::_internal_has_t() const {
-  return this != internal_default_instance() && t_ != nullptr;
-}
-inline bool AttributeProto::has_t() const {
-  return _internal_has_t();
-}
-inline void AttributeProto::clear_t() {
-  if (GetArena() == nullptr && t_ != nullptr) {
-    delete t_;
-  }
-  t_ = nullptr;
-}
-inline const ::onnx::TensorProto& AttributeProto::_internal_t() const {
-  const ::onnx::TensorProto* p = t_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& AttributeProto::t() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.t)
-  return _internal_t();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_t(
-    ::onnx::TensorProto* t) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
-  }
-  t_ = t;
-  if (t) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t)
-}
-inline ::onnx::TensorProto* AttributeProto::release_t() {
-  auto temp = unsafe_arena_release_t();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.t)
-  
-  ::onnx::TensorProto* temp = t_;
-  t_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* AttributeProto::_internal_mutable_t() {
-  
-  if (t_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    t_ = p;
-  }
-  return t_;
-}
-inline ::onnx::TensorProto* AttributeProto::mutable_t() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t)
-  return _internal_mutable_t();
-}
-inline void AttributeProto::set_allocated_t(::onnx::TensorProto* t) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete t_;
-  }
-  if (t) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(t);
-    if (message_arena != submessage_arena) {
-      t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, t, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  t_ = t;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t)
-}
-
-// .onnx.GraphProto g = 6;
-inline bool AttributeProto::_internal_has_g() const {
-  return this != internal_default_instance() && g_ != nullptr;
-}
-inline bool AttributeProto::has_g() const {
-  return _internal_has_g();
-}
-inline void AttributeProto::clear_g() {
-  if (GetArena() == nullptr && g_ != nullptr) {
-    delete g_;
-  }
-  g_ = nullptr;
-}
-inline const ::onnx::GraphProto& AttributeProto::_internal_g() const {
-  const ::onnx::GraphProto* p = g_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& AttributeProto::g() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.g)
-  return _internal_g();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_g(
-    ::onnx::GraphProto* g) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(g_);
-  }
-  g_ = g;
-  if (g) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g)
-}
-inline ::onnx::GraphProto* AttributeProto::release_g() {
-  auto temp = unsafe_arena_release_g();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.g)
-  
-  ::onnx::GraphProto* temp = g_;
-  g_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* AttributeProto::_internal_mutable_g() {
-  
-  if (g_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    g_ = p;
-  }
-  return g_;
-}
-inline ::onnx::GraphProto* AttributeProto::mutable_g() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g)
-  return _internal_mutable_g();
-}
-inline void AttributeProto::set_allocated_g(::onnx::GraphProto* g) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete g_;
-  }
-  if (g) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(g);
-    if (message_arena != submessage_arena) {
-      g = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, g, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  g_ = g;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g)
-}
-
-// .onnx.SparseTensorProto sparse_tensor = 22;
-inline bool AttributeProto::_internal_has_sparse_tensor() const {
-  return this != internal_default_instance() && sparse_tensor_ != nullptr;
-}
-inline bool AttributeProto::has_sparse_tensor() const {
-  return _internal_has_sparse_tensor();
-}
-inline void AttributeProto::clear_sparse_tensor() {
-  if (GetArena() == nullptr && sparse_tensor_ != nullptr) {
-    delete sparse_tensor_;
-  }
-  sparse_tensor_ = nullptr;
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
-  const ::onnx::SparseTensorProto* p = sparse_tensor_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::SparseTensorProto*>(
-      &::onnx::_SparseTensorProto_default_instance_);
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensor() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor)
-  return _internal_sparse_tensor();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(
-    ::onnx::SparseTensorProto* sparse_tensor) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_);
-  }
-  sparse_tensor_ = sparse_tensor;
-  if (sparse_tensor) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor)
-}
-inline ::onnx::SparseTensorProto* AttributeProto::release_sparse_tensor() {
-  auto temp = unsafe_arena_release_sparse_tensor();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::unsafe_arena_release_sparse_tensor() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor)
-  
-  ::onnx::SparseTensorProto* temp = sparse_tensor_;
-  sparse_tensor_ = nullptr;
-  return temp;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::_internal_mutable_sparse_tensor() {
-  
-  if (sparse_tensor_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::SparseTensorProto>(GetArena());
-    sparse_tensor_ = p;
-  }
-  return sparse_tensor_;
-}
-inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensor() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor)
-  return _internal_mutable_sparse_tensor();
-}
-inline void AttributeProto::set_allocated_sparse_tensor(::onnx::SparseTensorProto* sparse_tensor) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete sparse_tensor_;
-  }
-  if (sparse_tensor) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sparse_tensor);
-    if (message_arena != submessage_arena) {
-      sparse_tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, sparse_tensor, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  sparse_tensor_ = sparse_tensor;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor)
-}
-
-// .onnx.TypeProto tp = 14;
-inline bool AttributeProto::_internal_has_tp() const {
-  return this != internal_default_instance() && tp_ != nullptr;
-}
-inline bool AttributeProto::has_tp() const {
-  return _internal_has_tp();
-}
-inline void AttributeProto::clear_tp() {
-  if (GetArena() == nullptr && tp_ != nullptr) {
-    delete tp_;
-  }
-  tp_ = nullptr;
-}
-inline const ::onnx::TypeProto& AttributeProto::_internal_tp() const {
-  const ::onnx::TypeProto* p = tp_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& AttributeProto::tp() const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp)
-  return _internal_tp();
-}
-inline void AttributeProto::unsafe_arena_set_allocated_tp(
-    ::onnx::TypeProto* tp) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tp_);
-  }
-  tp_ = tp;
-  if (tp) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp)
-}
-inline ::onnx::TypeProto* AttributeProto::release_tp() {
-  auto temp = unsafe_arena_release_tp();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* AttributeProto::unsafe_arena_release_tp() {
-  // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp)
-  
-  ::onnx::TypeProto* temp = tp_;
-  tp_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* AttributeProto::_internal_mutable_tp() {
-  
-  if (tp_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    tp_ = p;
-  }
-  return tp_;
-}
-inline ::onnx::TypeProto* AttributeProto::mutable_tp() {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp)
-  return _internal_mutable_tp();
-}
-inline void AttributeProto::set_allocated_tp(::onnx::TypeProto* tp) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete tp_;
-  }
-  if (tp) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tp);
-    if (message_arena != submessage_arena) {
-      tp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, tp, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  tp_ = tp;
-  // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp)
-}
-
-// repeated float floats = 7;
-inline int AttributeProto::_internal_floats_size() const {
-  return floats_.size();
-}
-inline int AttributeProto::floats_size() const {
-  return _internal_floats_size();
-}
-inline void AttributeProto::clear_floats() {
-  floats_.Clear();
-}
-inline float AttributeProto::_internal_floats(int index) const {
-  return floats_.Get(index);
-}
-inline float AttributeProto::floats(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats)
-  return _internal_floats(index);
-}
-inline void AttributeProto::set_floats(int index, float value) {
-  floats_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats)
-}
-inline void AttributeProto::_internal_add_floats(float value) {
-  floats_.Add(value);
-}
-inline void AttributeProto::add_floats(float value) {
-  _internal_add_floats(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-AttributeProto::_internal_floats() const {
-  return floats_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-AttributeProto::floats() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats)
-  return _internal_floats();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-AttributeProto::_internal_mutable_floats() {
-  return &floats_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-AttributeProto::mutable_floats() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats)
-  return _internal_mutable_floats();
-}
-
-// repeated int64 ints = 8;
-inline int AttributeProto::_internal_ints_size() const {
-  return ints_.size();
-}
-inline int AttributeProto::ints_size() const {
-  return _internal_ints_size();
-}
-inline void AttributeProto::clear_ints() {
-  ints_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::_internal_ints(int index) const {
-  return ints_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 AttributeProto::ints(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints)
-  return _internal_ints(index);
-}
-inline void AttributeProto::set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  ints_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints)
-}
-inline void AttributeProto::_internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  ints_.Add(value);
-}
-inline void AttributeProto::add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_ints(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-AttributeProto::_internal_ints() const {
-  return ints_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-AttributeProto::ints() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints)
-  return _internal_ints();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-AttributeProto::_internal_mutable_ints() {
-  return &ints_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-AttributeProto::mutable_ints() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints)
-  return _internal_mutable_ints();
-}
-
-// repeated bytes strings = 9;
-inline int AttributeProto::_internal_strings_size() const {
-  return strings_.size();
-}
-inline int AttributeProto::strings_size() const {
-  return _internal_strings_size();
-}
-inline void AttributeProto::clear_strings() {
-  strings_.Clear();
-}
-inline std::string* AttributeProto::add_strings() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings)
-  return _internal_add_strings();
-}
-inline const std::string& AttributeProto::_internal_strings(int index) const {
-  return strings_.Get(index);
-}
-inline const std::string& AttributeProto::strings(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings)
-  return _internal_strings(index);
-}
-inline std::string* AttributeProto::mutable_strings(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings)
-  return strings_.Mutable(index);
-}
-inline void AttributeProto::set_strings(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
-  strings_.Mutable(index)->assign(value);
-}
-inline void AttributeProto::set_strings(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings)
-  strings_.Mutable(index)->assign(std::move(value));
-}
-inline void AttributeProto::set_strings(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  strings_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
-  strings_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.AttributeProto.strings)
-}
-inline std::string* AttributeProto::_internal_add_strings() {
-  return strings_.Add();
-}
-inline void AttributeProto::add_strings(const std::string& value) {
-  strings_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(std::string&& value) {
-  strings_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  strings_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.AttributeProto.strings)
-}
-inline void AttributeProto::add_strings(const void* value, size_t size) {
-  strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.AttributeProto.strings)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-AttributeProto::strings() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings)
-  return strings_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-AttributeProto::mutable_strings() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings)
-  return &strings_;
-}
-
-// repeated .onnx.TensorProto tensors = 10;
-inline int AttributeProto::_internal_tensors_size() const {
-  return tensors_.size();
-}
-inline int AttributeProto::tensors_size() const {
-  return _internal_tensors_size();
-}
-inline void AttributeProto::clear_tensors() {
-  tensors_.Clear();
-}
-inline ::onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors)
-  return tensors_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-AttributeProto::mutable_tensors() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors)
-  return &tensors_;
-}
-inline const ::onnx::TensorProto& AttributeProto::_internal_tensors(int index) const {
-  return tensors_.Get(index);
-}
-inline const ::onnx::TensorProto& AttributeProto::tensors(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors)
-  return _internal_tensors(index);
-}
-inline ::onnx::TensorProto* AttributeProto::_internal_add_tensors() {
-  return tensors_.Add();
-}
-inline ::onnx::TensorProto* AttributeProto::add_tensors() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors)
-  return _internal_add_tensors();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-AttributeProto::tensors() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors)
-  return tensors_;
-}
-
-// repeated .onnx.GraphProto graphs = 11;
-inline int AttributeProto::_internal_graphs_size() const {
-  return graphs_.size();
-}
-inline int AttributeProto::graphs_size() const {
-  return _internal_graphs_size();
-}
-inline void AttributeProto::clear_graphs() {
-  graphs_.Clear();
-}
-inline ::onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs)
-  return graphs_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >*
-AttributeProto::mutable_graphs() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs)
-  return &graphs_;
-}
-inline const ::onnx::GraphProto& AttributeProto::_internal_graphs(int index) const {
-  return graphs_.Get(index);
-}
-inline const ::onnx::GraphProto& AttributeProto::graphs(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs)
-  return _internal_graphs(index);
-}
-inline ::onnx::GraphProto* AttributeProto::_internal_add_graphs() {
-  return graphs_.Add();
-}
-inline ::onnx::GraphProto* AttributeProto::add_graphs() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs)
-  return _internal_add_graphs();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::GraphProto >&
-AttributeProto::graphs() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs)
-  return graphs_;
-}
-
-// repeated .onnx.SparseTensorProto sparse_tensors = 23;
-inline int AttributeProto::_internal_sparse_tensors_size() const {
-  return sparse_tensors_.size();
-}
-inline int AttributeProto::sparse_tensors_size() const {
-  return _internal_sparse_tensors_size();
-}
-inline void AttributeProto::clear_sparse_tensors() {
-  sparse_tensors_.Clear();
-}
-inline ::onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensors(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors)
-  return sparse_tensors_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-AttributeProto::mutable_sparse_tensors() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors)
-  return &sparse_tensors_;
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensors(int index) const {
-  return sparse_tensors_.Get(index);
-}
-inline const ::onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors)
-  return _internal_sparse_tensors(index);
-}
-inline ::onnx::SparseTensorProto* AttributeProto::_internal_add_sparse_tensors() {
-  return sparse_tensors_.Add();
-}
-inline ::onnx::SparseTensorProto* AttributeProto::add_sparse_tensors() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors)
-  return _internal_add_sparse_tensors();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-AttributeProto::sparse_tensors() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors)
-  return sparse_tensors_;
-}
-
-// repeated .onnx.TypeProto type_protos = 15;
-inline int AttributeProto::_internal_type_protos_size() const {
-  return type_protos_.size();
-}
-inline int AttributeProto::type_protos_size() const {
-  return _internal_type_protos_size();
-}
-inline void AttributeProto::clear_type_protos() {
-  type_protos_.Clear();
-}
-inline ::onnx::TypeProto* AttributeProto::mutable_type_protos(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos)
-  return type_protos_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >*
-AttributeProto::mutable_type_protos() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos)
-  return &type_protos_;
-}
-inline const ::onnx::TypeProto& AttributeProto::_internal_type_protos(int index) const {
-  return type_protos_.Get(index);
-}
-inline const ::onnx::TypeProto& AttributeProto::type_protos(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos)
-  return _internal_type_protos(index);
-}
-inline ::onnx::TypeProto* AttributeProto::_internal_add_type_protos() {
-  return type_protos_.Add();
-}
-inline ::onnx::TypeProto* AttributeProto::add_type_protos() {
-  // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos)
-  return _internal_add_type_protos();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TypeProto >&
-AttributeProto::type_protos() const {
-  // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos)
-  return type_protos_;
-}
-
-// -------------------------------------------------------------------
-
-// ValueInfoProto
-
-// string name = 1;
-inline void ValueInfoProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ValueInfoProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name)
-  return _internal_name();
-}
-inline void ValueInfoProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& ValueInfoProto::_internal_name() const {
-  return name_.Get();
-}
-inline void ValueInfoProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ValueInfoProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ValueInfoProto.name)
-}
-inline void ValueInfoProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ValueInfoProto.name)
-}
-inline void ValueInfoProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ValueInfoProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ValueInfoProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name)
-}
-inline std::string* ValueInfoProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ValueInfoProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.name)
-}
-
-// .onnx.TypeProto type = 2;
-inline bool ValueInfoProto::_internal_has_type() const {
-  return this != internal_default_instance() && type_ != nullptr;
-}
-inline bool ValueInfoProto::has_type() const {
-  return _internal_has_type();
-}
-inline void ValueInfoProto::clear_type() {
-  if (GetArena() == nullptr && type_ != nullptr) {
-    delete type_;
-  }
-  type_ = nullptr;
-}
-inline const ::onnx::TypeProto& ValueInfoProto::_internal_type() const {
-  const ::onnx::TypeProto* p = type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& ValueInfoProto::type() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type)
-  return _internal_type();
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_type(
-    ::onnx::TypeProto* type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
-  }
-  type_ = type;
-  if (type) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type)
-}
-inline ::onnx::TypeProto* ValueInfoProto::release_type() {
-  auto temp = unsafe_arena_release_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type)
-  
-  ::onnx::TypeProto* temp = type_;
-  type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
-  
-  if (type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    type_ = p;
-  }
-  return type_;
-}
-inline ::onnx::TypeProto* ValueInfoProto::mutable_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type)
-  return _internal_mutable_type();
-}
-inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto* type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete type_;
-  }
-  if (type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type);
-    if (message_arena != submessage_arena) {
-      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, type, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  type_ = type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type)
-}
-
-// string doc_string = 3;
-inline void ValueInfoProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ValueInfoProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string)
-  return _internal_doc_string();
-}
-inline void ValueInfoProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& ValueInfoProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ValueInfoProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ValueInfoProto.doc_string)
-}
-inline void ValueInfoProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ValueInfoProto.doc_string)
-}
-inline void ValueInfoProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ValueInfoProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ValueInfoProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string)
-}
-inline std::string* ValueInfoProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ValueInfoProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ValueInfoProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.doc_string)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 4;
-inline int ValueInfoProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int ValueInfoProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void ValueInfoProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-ValueInfoProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& ValueInfoProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* ValueInfoProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-ValueInfoProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// NodeProto
-
-// repeated string input = 1;
-inline int NodeProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int NodeProto::input_size() const {
-  return _internal_input_size();
-}
-inline void NodeProto::clear_input() {
-  input_.Clear();
-}
-inline std::string* NodeProto::add_input() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input)
-  return _internal_add_input();
-}
-inline const std::string& NodeProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const std::string& NodeProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.input)
-  return _internal_input(index);
-}
-inline std::string* NodeProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input)
-  return input_.Mutable(index);
-}
-inline void NodeProto::set_input(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
-  input_.Mutable(index)->assign(value);
-}
-inline void NodeProto::set_input(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.input)
-  input_.Mutable(index)->assign(std::move(value));
-}
-inline void NodeProto::set_input(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.input)
-}
-inline void NodeProto::set_input(int index, const char* value, size_t size) {
-  input_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.input)
-}
-inline std::string* NodeProto::_internal_add_input() {
-  return input_.Add();
-}
-inline void NodeProto::add_input(const std::string& value) {
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(std::string&& value) {
-  input_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.NodeProto.input)
-}
-inline void NodeProto::add_input(const char* value, size_t size) {
-  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.NodeProto.input)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-NodeProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.input)
-  return input_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-NodeProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input)
-  return &input_;
-}
-
-// repeated string output = 2;
-inline int NodeProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int NodeProto::output_size() const {
-  return _internal_output_size();
-}
-inline void NodeProto::clear_output() {
-  output_.Clear();
-}
-inline std::string* NodeProto::add_output() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output)
-  return _internal_add_output();
-}
-inline const std::string& NodeProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const std::string& NodeProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.output)
-  return _internal_output(index);
-}
-inline std::string* NodeProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output)
-  return output_.Mutable(index);
-}
-inline void NodeProto::set_output(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
-  output_.Mutable(index)->assign(value);
-}
-inline void NodeProto::set_output(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.output)
-  output_.Mutable(index)->assign(std::move(value));
-}
-inline void NodeProto::set_output(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.output)
-}
-inline void NodeProto::set_output(int index, const char* value, size_t size) {
-  output_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.output)
-}
-inline std::string* NodeProto::_internal_add_output() {
-  return output_.Add();
-}
-inline void NodeProto::add_output(const std::string& value) {
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(std::string&& value) {
-  output_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.NodeProto.output)
-}
-inline void NodeProto::add_output(const char* value, size_t size) {
-  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.NodeProto.output)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-NodeProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.output)
-  return output_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-NodeProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output)
-  return &output_;
-}
-
-// string name = 3;
-inline void NodeProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.name)
-  return _internal_name();
-}
-inline void NodeProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& NodeProto::_internal_name() const {
-  return name_.Get();
-}
-inline void NodeProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.name)
-}
-inline void NodeProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.name)
-}
-inline void NodeProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name)
-}
-inline std::string* NodeProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.name)
-}
-
-// string op_type = 4;
-inline void NodeProto::clear_op_type() {
-  op_type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeProto::op_type() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type)
-  return _internal_op_type();
-}
-inline void NodeProto::set_op_type(const std::string& value) {
-  _internal_set_op_type(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::mutable_op_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type)
-  return _internal_mutable_op_type();
-}
-inline const std::string& NodeProto::_internal_op_type() const {
-  return op_type_.Get();
-}
-inline void NodeProto::_internal_set_op_type(const std::string& value) {
-  
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_op_type(std::string&& value) {
-  
-  op_type_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.op_type)
-}
-inline void NodeProto::set_op_type(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.op_type)
-}
-inline void NodeProto::set_op_type(const char* value,
-    size_t size) {
-  
-  op_type_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::_internal_mutable_op_type() {
-  
-  return op_type_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_op_type() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type)
-  return op_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_op_type(std::string* op_type) {
-  if (op_type != nullptr) {
-    
-  } else {
-    
-  }
-  op_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_type,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type)
-}
-inline std::string* NodeProto::unsafe_arena_release_op_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.op_type)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return op_type_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_op_type(
-    std::string* op_type) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (op_type != nullptr) {
-    
-  } else {
-    
-  }
-  op_type_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      op_type, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.op_type)
-}
-
-// string domain = 7;
-inline void NodeProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.domain)
-  return _internal_domain();
-}
-inline void NodeProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& NodeProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void NodeProto::_internal_set_domain(const std::string& value) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_domain(std::string&& value) {
-  
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.domain)
-}
-inline void NodeProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.domain)
-}
-inline void NodeProto::set_domain(const char* value,
-    size_t size) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::_internal_mutable_domain() {
-  
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.domain)
-  return domain_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain)
-}
-inline std::string* NodeProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.domain)
-}
-
-// string overload = 8;
-inline void NodeProto::clear_overload() {
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeProto::overload() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.overload)
-  return _internal_overload();
-}
-inline void NodeProto::set_overload(const std::string& value) {
-  _internal_set_overload(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::mutable_overload() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload)
-  return _internal_mutable_overload();
-}
-inline const std::string& NodeProto::_internal_overload() const {
-  return overload_.Get();
-}
-inline void NodeProto::_internal_set_overload(const std::string& value) {
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_overload(std::string&& value) {
-  
-  overload_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.overload)
-}
-inline void NodeProto::set_overload(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.overload)
-}
-inline void NodeProto::set_overload(const char* value,
-    size_t size) {
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::_internal_mutable_overload() {
-  
-  return overload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_overload() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.overload)
-  return overload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_overload(std::string* overload) {
-  if (overload != nullptr) {
-    
-  } else {
-    
-  }
-  overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload)
-}
-inline std::string* NodeProto::unsafe_arena_release_overload() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.overload)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return overload_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_overload(
-    std::string* overload) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (overload != nullptr) {
-    
-  } else {
-    
-  }
-  overload_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      overload, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.overload)
-}
-
-// repeated .onnx.AttributeProto attribute = 5;
-inline int NodeProto::_internal_attribute_size() const {
-  return attribute_.size();
-}
-inline int NodeProto::attribute_size() const {
-  return _internal_attribute_size();
-}
-inline void NodeProto::clear_attribute() {
-  attribute_.Clear();
-}
-inline ::onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute)
-  return attribute_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-NodeProto::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute)
-  return &attribute_;
-}
-inline const ::onnx::AttributeProto& NodeProto::_internal_attribute(int index) const {
-  return attribute_.Get(index);
-}
-inline const ::onnx::AttributeProto& NodeProto::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute)
-  return _internal_attribute(index);
-}
-inline ::onnx::AttributeProto* NodeProto::_internal_add_attribute() {
-  return attribute_.Add();
-}
-inline ::onnx::AttributeProto* NodeProto::add_attribute() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute)
-  return _internal_add_attribute();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-NodeProto::attribute() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute)
-  return attribute_;
-}
-
-// string doc_string = 6;
-inline void NodeProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string)
-  return _internal_doc_string();
-}
-inline void NodeProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& NodeProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void NodeProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeProto.doc_string)
-}
-inline void NodeProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeProto.doc_string)
-}
-inline void NodeProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string)
-}
-inline std::string* NodeProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeProto.doc_string)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 9;
-inline int NodeProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int NodeProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void NodeProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* NodeProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-NodeProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& NodeProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* NodeProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* NodeProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-NodeProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props)
-  return metadata_props_;
-}
-
-// repeated .onnx.NodeDeviceConfigurationProto device_configurations = 10;
-inline int NodeProto::_internal_device_configurations_size() const {
-  return device_configurations_.size();
-}
-inline int NodeProto::device_configurations_size() const {
-  return _internal_device_configurations_size();
-}
-inline void NodeProto::clear_device_configurations() {
-  device_configurations_.Clear();
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::mutable_device_configurations(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeProto.device_configurations)
-  return device_configurations_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >*
-NodeProto::mutable_device_configurations() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.device_configurations)
-  return &device_configurations_;
-}
-inline const ::onnx::NodeDeviceConfigurationProto& NodeProto::_internal_device_configurations(int index) const {
-  return device_configurations_.Get(index);
-}
-inline const ::onnx::NodeDeviceConfigurationProto& NodeProto::device_configurations(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeProto.device_configurations)
-  return _internal_device_configurations(index);
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::_internal_add_device_configurations() {
-  return device_configurations_.Add();
-}
-inline ::onnx::NodeDeviceConfigurationProto* NodeProto::add_device_configurations() {
-  // @@protoc_insertion_point(field_add:onnx.NodeProto.device_configurations)
-  return _internal_add_device_configurations();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeDeviceConfigurationProto >&
-NodeProto::device_configurations() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeProto.device_configurations)
-  return device_configurations_;
-}
-
-// -------------------------------------------------------------------
-
-// IntIntListEntryProto
-
-// int64 key = 1;
-inline void IntIntListEntryProto::clear_key() {
-  key_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::_internal_key() const {
-  return key_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::key() const {
-  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.key)
-  return _internal_key();
-}
-inline void IntIntListEntryProto::_internal_set_key(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  key_ = value;
-}
-inline void IntIntListEntryProto::set_key(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_key(value);
-  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.key)
-}
-
-// repeated int64 value = 2;
-inline int IntIntListEntryProto::_internal_value_size() const {
-  return value_.size();
-}
-inline int IntIntListEntryProto::value_size() const {
-  return _internal_value_size();
-}
-inline void IntIntListEntryProto::clear_value() {
-  value_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::_internal_value(int index) const {
-  return value_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 IntIntListEntryProto::value(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.IntIntListEntryProto.value)
-  return _internal_value(index);
-}
-inline void IntIntListEntryProto::set_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  value_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.IntIntListEntryProto.value)
-}
-inline void IntIntListEntryProto::_internal_add_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  value_.Add(value);
-}
-inline void IntIntListEntryProto::add_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_value(value);
-  // @@protoc_insertion_point(field_add:onnx.IntIntListEntryProto.value)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-IntIntListEntryProto::_internal_value() const {
-  return value_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-IntIntListEntryProto::value() const {
-  // @@protoc_insertion_point(field_list:onnx.IntIntListEntryProto.value)
-  return _internal_value();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-IntIntListEntryProto::_internal_mutable_value() {
-  return &value_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-IntIntListEntryProto::mutable_value() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.IntIntListEntryProto.value)
-  return _internal_mutable_value();
-}
-
-// -------------------------------------------------------------------
-
-// NodeDeviceConfigurationProto
-
-// string configuration_id = 1;
-inline void NodeDeviceConfigurationProto::clear_configuration_id() {
-  configuration_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& NodeDeviceConfigurationProto::configuration_id() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.configuration_id)
-  return _internal_configuration_id();
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const std::string& value) {
-  _internal_set_configuration_id(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::mutable_configuration_id() {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.configuration_id)
-  return _internal_mutable_configuration_id();
-}
-inline const std::string& NodeDeviceConfigurationProto::_internal_configuration_id() const {
-  return configuration_id_.Get();
-}
-inline void NodeDeviceConfigurationProto::_internal_set_configuration_id(const std::string& value) {
-  
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(std::string&& value) {
-  
-  configuration_id_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline void NodeDeviceConfigurationProto::set_configuration_id(const char* value,
-    size_t size) {
-  
-  configuration_id_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::_internal_mutable_configuration_id() {
-  
-  return configuration_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* NodeDeviceConfigurationProto::release_configuration_id() {
-  // @@protoc_insertion_point(field_release:onnx.NodeDeviceConfigurationProto.configuration_id)
-  return configuration_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void NodeDeviceConfigurationProto::set_allocated_configuration_id(std::string* configuration_id) {
-  if (configuration_id != nullptr) {
-    
-  } else {
-    
-  }
-  configuration_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), configuration_id,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-inline std::string* NodeDeviceConfigurationProto::unsafe_arena_release_configuration_id() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.NodeDeviceConfigurationProto.configuration_id)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return configuration_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void NodeDeviceConfigurationProto::unsafe_arena_set_allocated_configuration_id(
-    std::string* configuration_id) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (configuration_id != nullptr) {
-    
-  } else {
-    
-  }
-  configuration_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      configuration_id, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.NodeDeviceConfigurationProto.configuration_id)
-}
-
-// repeated .onnx.ShardingSpecProto sharding_spec = 2;
-inline int NodeDeviceConfigurationProto::_internal_sharding_spec_size() const {
-  return sharding_spec_.size();
-}
-inline int NodeDeviceConfigurationProto::sharding_spec_size() const {
-  return _internal_sharding_spec_size();
-}
-inline void NodeDeviceConfigurationProto::clear_sharding_spec() {
-  sharding_spec_.Clear();
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::mutable_sharding_spec(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return sharding_spec_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >*
-NodeDeviceConfigurationProto::mutable_sharding_spec() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return &sharding_spec_;
-}
-inline const ::onnx::ShardingSpecProto& NodeDeviceConfigurationProto::_internal_sharding_spec(int index) const {
-  return sharding_spec_.Get(index);
-}
-inline const ::onnx::ShardingSpecProto& NodeDeviceConfigurationProto::sharding_spec(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return _internal_sharding_spec(index);
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::_internal_add_sharding_spec() {
-  return sharding_spec_.Add();
-}
-inline ::onnx::ShardingSpecProto* NodeDeviceConfigurationProto::add_sharding_spec() {
-  // @@protoc_insertion_point(field_add:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return _internal_add_sharding_spec();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardingSpecProto >&
-NodeDeviceConfigurationProto::sharding_spec() const {
-  // @@protoc_insertion_point(field_list:onnx.NodeDeviceConfigurationProto.sharding_spec)
-  return sharding_spec_;
-}
-
-// int32 pipeline_stage = 3;
-inline void NodeDeviceConfigurationProto::clear_pipeline_stage() {
-  pipeline_stage_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 NodeDeviceConfigurationProto::_internal_pipeline_stage() const {
-  return pipeline_stage_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 NodeDeviceConfigurationProto::pipeline_stage() const {
-  // @@protoc_insertion_point(field_get:onnx.NodeDeviceConfigurationProto.pipeline_stage)
-  return _internal_pipeline_stage();
-}
-inline void NodeDeviceConfigurationProto::_internal_set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  pipeline_stage_ = value;
-}
-inline void NodeDeviceConfigurationProto::set_pipeline_stage(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_pipeline_stage(value);
-  // @@protoc_insertion_point(field_set:onnx.NodeDeviceConfigurationProto.pipeline_stage)
-}
-
-// -------------------------------------------------------------------
-
-// ShardingSpecProto
-
-// string tensor_name = 1;
-inline void ShardingSpecProto::clear_tensor_name() {
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ShardingSpecProto::tensor_name() const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.tensor_name)
-  return _internal_tensor_name();
-}
-inline void ShardingSpecProto::set_tensor_name(const std::string& value) {
-  _internal_set_tensor_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::mutable_tensor_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.tensor_name)
-  return _internal_mutable_tensor_name();
-}
-inline const std::string& ShardingSpecProto::_internal_tensor_name() const {
-  return tensor_name_.Get();
-}
-inline void ShardingSpecProto::_internal_set_tensor_name(const std::string& value) {
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ShardingSpecProto::set_tensor_name(std::string&& value) {
-  
-  tensor_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ShardingSpecProto.tensor_name)
-}
-inline void ShardingSpecProto::set_tensor_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ShardingSpecProto.tensor_name)
-}
-inline void ShardingSpecProto::set_tensor_name(const char* value,
-    size_t size) {
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::_internal_mutable_tensor_name() {
-  
-  return tensor_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ShardingSpecProto::release_tensor_name() {
-  // @@protoc_insertion_point(field_release:onnx.ShardingSpecProto.tensor_name)
-  return tensor_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ShardingSpecProto::set_allocated_tensor_name(std::string* tensor_name) {
-  if (tensor_name != nullptr) {
-    
-  } else {
-    
-  }
-  tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ShardingSpecProto.tensor_name)
-}
-inline std::string* ShardingSpecProto::unsafe_arena_release_tensor_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ShardingSpecProto.tensor_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return tensor_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ShardingSpecProto::unsafe_arena_set_allocated_tensor_name(
-    std::string* tensor_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (tensor_name != nullptr) {
-    
-  } else {
-    
-  }
-  tensor_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      tensor_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ShardingSpecProto.tensor_name)
-}
-
-// repeated int64 device = 2;
-inline int ShardingSpecProto::_internal_device_size() const {
-  return device_.size();
-}
-inline int ShardingSpecProto::device_size() const {
-  return _internal_device_size();
-}
-inline void ShardingSpecProto::clear_device() {
-  device_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardingSpecProto::_internal_device(int index) const {
-  return device_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardingSpecProto::device(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.device)
-  return _internal_device(index);
-}
-inline void ShardingSpecProto::set_device(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  device_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.ShardingSpecProto.device)
-}
-inline void ShardingSpecProto::_internal_add_device(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  device_.Add(value);
-}
-inline void ShardingSpecProto::add_device(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_device(value);
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.device)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-ShardingSpecProto::_internal_device() const {
-  return device_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-ShardingSpecProto::device() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.device)
-  return _internal_device();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-ShardingSpecProto::_internal_mutable_device() {
-  return &device_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-ShardingSpecProto::mutable_device() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.device)
-  return _internal_mutable_device();
-}
-
-// repeated .onnx.IntIntListEntryProto index_to_device_group_map = 3;
-inline int ShardingSpecProto::_internal_index_to_device_group_map_size() const {
-  return index_to_device_group_map_.size();
-}
-inline int ShardingSpecProto::index_to_device_group_map_size() const {
-  return _internal_index_to_device_group_map_size();
-}
-inline void ShardingSpecProto::clear_index_to_device_group_map() {
-  index_to_device_group_map_.Clear();
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::mutable_index_to_device_group_map(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.index_to_device_group_map)
-  return index_to_device_group_map_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >*
-ShardingSpecProto::mutable_index_to_device_group_map() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.index_to_device_group_map)
-  return &index_to_device_group_map_;
-}
-inline const ::onnx::IntIntListEntryProto& ShardingSpecProto::_internal_index_to_device_group_map(int index) const {
-  return index_to_device_group_map_.Get(index);
-}
-inline const ::onnx::IntIntListEntryProto& ShardingSpecProto::index_to_device_group_map(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.index_to_device_group_map)
-  return _internal_index_to_device_group_map(index);
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::_internal_add_index_to_device_group_map() {
-  return index_to_device_group_map_.Add();
-}
-inline ::onnx::IntIntListEntryProto* ShardingSpecProto::add_index_to_device_group_map() {
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.index_to_device_group_map)
-  return _internal_add_index_to_device_group_map();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::IntIntListEntryProto >&
-ShardingSpecProto::index_to_device_group_map() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.index_to_device_group_map)
-  return index_to_device_group_map_;
-}
-
-// repeated .onnx.ShardedDimProto sharded_dim = 4;
-inline int ShardingSpecProto::_internal_sharded_dim_size() const {
-  return sharded_dim_.size();
-}
-inline int ShardingSpecProto::sharded_dim_size() const {
-  return _internal_sharded_dim_size();
-}
-inline void ShardingSpecProto::clear_sharded_dim() {
-  sharded_dim_.Clear();
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::mutable_sharded_dim(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardingSpecProto.sharded_dim)
-  return sharded_dim_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >*
-ShardingSpecProto::mutable_sharded_dim() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardingSpecProto.sharded_dim)
-  return &sharded_dim_;
-}
-inline const ::onnx::ShardedDimProto& ShardingSpecProto::_internal_sharded_dim(int index) const {
-  return sharded_dim_.Get(index);
-}
-inline const ::onnx::ShardedDimProto& ShardingSpecProto::sharded_dim(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardingSpecProto.sharded_dim)
-  return _internal_sharded_dim(index);
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::_internal_add_sharded_dim() {
-  return sharded_dim_.Add();
-}
-inline ::onnx::ShardedDimProto* ShardingSpecProto::add_sharded_dim() {
-  // @@protoc_insertion_point(field_add:onnx.ShardingSpecProto.sharded_dim)
-  return _internal_add_sharded_dim();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ShardedDimProto >&
-ShardingSpecProto::sharded_dim() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardingSpecProto.sharded_dim)
-  return sharded_dim_;
-}
-
-// -------------------------------------------------------------------
-
-// ShardedDimProto
-
-// int64 axis = 1;
-inline void ShardedDimProto::clear_axis() {
-  axis_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardedDimProto::_internal_axis() const {
-  return axis_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ShardedDimProto::axis() const {
-  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.axis)
-  return _internal_axis();
-}
-inline void ShardedDimProto::_internal_set_axis(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  axis_ = value;
-}
-inline void ShardedDimProto::set_axis(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_axis(value);
-  // @@protoc_insertion_point(field_set:onnx.ShardedDimProto.axis)
-}
-
-// repeated .onnx.SimpleShardedDimProto simple_sharding = 2;
-inline int ShardedDimProto::_internal_simple_sharding_size() const {
-  return simple_sharding_.size();
-}
-inline int ShardedDimProto::simple_sharding_size() const {
-  return _internal_simple_sharding_size();
-}
-inline void ShardedDimProto::clear_simple_sharding() {
-  simple_sharding_.Clear();
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::mutable_simple_sharding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ShardedDimProto.simple_sharding)
-  return simple_sharding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >*
-ShardedDimProto::mutable_simple_sharding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ShardedDimProto.simple_sharding)
-  return &simple_sharding_;
-}
-inline const ::onnx::SimpleShardedDimProto& ShardedDimProto::_internal_simple_sharding(int index) const {
-  return simple_sharding_.Get(index);
-}
-inline const ::onnx::SimpleShardedDimProto& ShardedDimProto::simple_sharding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ShardedDimProto.simple_sharding)
-  return _internal_simple_sharding(index);
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::_internal_add_simple_sharding() {
-  return simple_sharding_.Add();
-}
-inline ::onnx::SimpleShardedDimProto* ShardedDimProto::add_simple_sharding() {
-  // @@protoc_insertion_point(field_add:onnx.ShardedDimProto.simple_sharding)
-  return _internal_add_simple_sharding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SimpleShardedDimProto >&
-ShardedDimProto::simple_sharding() const {
-  // @@protoc_insertion_point(field_list:onnx.ShardedDimProto.simple_sharding)
-  return simple_sharding_;
-}
-
-// -------------------------------------------------------------------
-
-// SimpleShardedDimProto
-
-// int64 dim_value = 1;
-inline bool SimpleShardedDimProto::_internal_has_dim_value() const {
-  return dim_case() == kDimValue;
-}
-inline void SimpleShardedDimProto::set_has_dim_value() {
-  _oneof_case_[0] = kDimValue;
-}
-inline void SimpleShardedDimProto::clear_dim_value() {
-  if (_internal_has_dim_value()) {
-    dim_.dim_value_ = PROTOBUF_LONGLONG(0);
-    clear_has_dim();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::_internal_dim_value() const {
-  if (_internal_has_dim_value()) {
-    return dim_.dim_value_;
-  }
-  return PROTOBUF_LONGLONG(0);
-}
-inline void SimpleShardedDimProto::_internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  if (!_internal_has_dim_value()) {
-    clear_dim();
-    set_has_dim_value();
-  }
-  dim_.dim_value_ = value;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::dim_value() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_value)
-  return _internal_dim_value();
-}
-inline void SimpleShardedDimProto::set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_dim_value(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_value)
-}
-
-// string dim_param = 2;
-inline bool SimpleShardedDimProto::_internal_has_dim_param() const {
-  return dim_case() == kDimParam;
-}
-inline void SimpleShardedDimProto::set_has_dim_param() {
-  _oneof_case_[0] = kDimParam;
-}
-inline void SimpleShardedDimProto::clear_dim_param() {
-  if (_internal_has_dim_param()) {
-    dim_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-    clear_has_dim();
-  }
-}
-inline const std::string& SimpleShardedDimProto::dim_param() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.dim_param)
-  return _internal_dim_param();
-}
-inline void SimpleShardedDimProto::set_dim_param(const std::string& value) {
-  _internal_set_dim_param(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::mutable_dim_param() {
-  // @@protoc_insertion_point(field_mutable:onnx.SimpleShardedDimProto.dim_param)
-  return _internal_mutable_dim_param();
-}
-inline const std::string& SimpleShardedDimProto::_internal_dim_param() const {
-  if (_internal_has_dim_param()) {
-    return dim_.dim_param_.Get();
-  }
-  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void SimpleShardedDimProto::_internal_set_dim_param(const std::string& value) {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void SimpleShardedDimProto::set_dim_param(std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.dim_param)
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.SimpleShardedDimProto.dim_param)
-}
-inline void SimpleShardedDimProto::set_dim_param(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.SimpleShardedDimProto.dim_param)
-}
-inline void SimpleShardedDimProto::set_dim_param(const char* value,
-                             size_t size) {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  dim_.dim_param_.SetLite(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size),
-      GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::_internal_mutable_dim_param() {
-  if (!_internal_has_dim_param()) {
-    clear_dim();
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  return dim_.dim_param_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* SimpleShardedDimProto::release_dim_param() {
-  // @@protoc_insertion_point(field_release:onnx.SimpleShardedDimProto.dim_param)
-  if (_internal_has_dim_param()) {
-    clear_has_dim();
-    return dim_.dim_param_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void SimpleShardedDimProto::set_allocated_dim_param(std::string* dim_param) {
-  if (has_dim()) {
-    clear_dim();
-  }
-  if (dim_param != nullptr) {
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeSetDefault(dim_param);
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.SimpleShardedDimProto.dim_param)
-}
-inline std::string* SimpleShardedDimProto::unsafe_arena_release_dim_param() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.SimpleShardedDimProto.dim_param)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (_internal_has_dim_param()) {
-    clear_has_dim();
-    return dim_.dim_param_.UnsafeArenaRelease(
-        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void SimpleShardedDimProto::unsafe_arena_set_allocated_dim_param(std::string* dim_param) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (!_internal_has_dim_param()) {
-    dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_dim();
-  if (dim_param) {
-    set_has_dim_param();
-    dim_.dim_param_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dim_param, GetArena());
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SimpleShardedDimProto.dim_param)
-}
-
-// int64 num_shards = 3;
-inline void SimpleShardedDimProto::clear_num_shards() {
-  num_shards_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::_internal_num_shards() const {
-  return num_shards_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleShardedDimProto::num_shards() const {
-  // @@protoc_insertion_point(field_get:onnx.SimpleShardedDimProto.num_shards)
-  return _internal_num_shards();
-}
-inline void SimpleShardedDimProto::_internal_set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  num_shards_ = value;
-}
-inline void SimpleShardedDimProto::set_num_shards(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_num_shards(value);
-  // @@protoc_insertion_point(field_set:onnx.SimpleShardedDimProto.num_shards)
-}
-
-inline bool SimpleShardedDimProto::has_dim() const {
-  return dim_case() != DIM_NOT_SET;
-}
-inline void SimpleShardedDimProto::clear_has_dim() {
-  _oneof_case_[0] = DIM_NOT_SET;
-}
-inline SimpleShardedDimProto::DimCase SimpleShardedDimProto::dim_case() const {
-  return SimpleShardedDimProto::DimCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// TrainingInfoProto
-
-// .onnx.GraphProto initialization = 1;
-inline bool TrainingInfoProto::_internal_has_initialization() const {
-  return this != internal_default_instance() && initialization_ != nullptr;
-}
-inline bool TrainingInfoProto::has_initialization() const {
-  return _internal_has_initialization();
-}
-inline void TrainingInfoProto::clear_initialization() {
-  if (GetArena() == nullptr && initialization_ != nullptr) {
-    delete initialization_;
-  }
-  initialization_ = nullptr;
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
-  const ::onnx::GraphProto* p = initialization_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::initialization() const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization)
-  return _internal_initialization();
-}
-inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(
-    ::onnx::GraphProto* initialization) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(initialization_);
-  }
-  initialization_ = initialization;
-  if (initialization) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization)
-}
-inline ::onnx::GraphProto* TrainingInfoProto::release_initialization() {
-  auto temp = unsafe_arena_release_initialization();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_initialization() {
-  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization)
-  
-  ::onnx::GraphProto* temp = initialization_;
-  initialization_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_initialization() {
-  
-  if (initialization_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    initialization_ = p;
-  }
-  return initialization_;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::mutable_initialization() {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization)
-  return _internal_mutable_initialization();
-}
-inline void TrainingInfoProto::set_allocated_initialization(::onnx::GraphProto* initialization) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete initialization_;
-  }
-  if (initialization) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(initialization);
-    if (message_arena != submessage_arena) {
-      initialization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, initialization, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  initialization_ = initialization;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization)
-}
-
-// .onnx.GraphProto algorithm = 2;
-inline bool TrainingInfoProto::_internal_has_algorithm() const {
-  return this != internal_default_instance() && algorithm_ != nullptr;
-}
-inline bool TrainingInfoProto::has_algorithm() const {
-  return _internal_has_algorithm();
-}
-inline void TrainingInfoProto::clear_algorithm() {
-  if (GetArena() == nullptr && algorithm_ != nullptr) {
-    delete algorithm_;
-  }
-  algorithm_ = nullptr;
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
-  const ::onnx::GraphProto* p = algorithm_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& TrainingInfoProto::algorithm() const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm)
-  return _internal_algorithm();
-}
-inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(
-    ::onnx::GraphProto* algorithm) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(algorithm_);
-  }
-  algorithm_ = algorithm;
-  if (algorithm) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm)
-}
-inline ::onnx::GraphProto* TrainingInfoProto::release_algorithm() {
-  auto temp = unsafe_arena_release_algorithm();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_algorithm() {
-  // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm)
-  
-  ::onnx::GraphProto* temp = algorithm_;
-  algorithm_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::_internal_mutable_algorithm() {
-  
-  if (algorithm_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    algorithm_ = p;
-  }
-  return algorithm_;
-}
-inline ::onnx::GraphProto* TrainingInfoProto::mutable_algorithm() {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm)
-  return _internal_mutable_algorithm();
-}
-inline void TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto* algorithm) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete algorithm_;
-  }
-  if (algorithm) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(algorithm);
-    if (message_arena != submessage_arena) {
-      algorithm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, algorithm, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  algorithm_ = algorithm;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm)
-}
-
-// repeated .onnx.StringStringEntryProto initialization_binding = 3;
-inline int TrainingInfoProto::_internal_initialization_binding_size() const {
-  return initialization_binding_.size();
-}
-inline int TrainingInfoProto::initialization_binding_size() const {
-  return _internal_initialization_binding_size();
-}
-inline void TrainingInfoProto::clear_initialization_binding() {
-  initialization_binding_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_initialization_binding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding)
-  return initialization_binding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TrainingInfoProto::mutable_initialization_binding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding)
-  return &initialization_binding_;
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::_internal_initialization_binding(int index) const {
-  return initialization_binding_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding)
-  return _internal_initialization_binding(index);
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_initialization_binding() {
-  return initialization_binding_.Add();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_initialization_binding() {
-  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding)
-  return _internal_add_initialization_binding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TrainingInfoProto::initialization_binding() const {
-  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding)
-  return initialization_binding_;
-}
-
-// repeated .onnx.StringStringEntryProto update_binding = 4;
-inline int TrainingInfoProto::_internal_update_binding_size() const {
-  return update_binding_.size();
-}
-inline int TrainingInfoProto::update_binding_size() const {
-  return _internal_update_binding_size();
-}
-inline void TrainingInfoProto::clear_update_binding() {
-  update_binding_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::mutable_update_binding(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding)
-  return update_binding_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TrainingInfoProto::mutable_update_binding() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding)
-  return &update_binding_;
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::_internal_update_binding(int index) const {
-  return update_binding_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding)
-  return _internal_update_binding(index);
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_update_binding() {
-  return update_binding_.Add();
-}
-inline ::onnx::StringStringEntryProto* TrainingInfoProto::add_update_binding() {
-  // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding)
-  return _internal_add_update_binding();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TrainingInfoProto::update_binding() const {
-  // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding)
-  return update_binding_;
-}
-
-// -------------------------------------------------------------------
-
-// ModelProto
-
-// int64 ir_version = 1;
-inline void ModelProto::clear_ir_version() {
-  ir_version_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::_internal_ir_version() const {
-  return ir_version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::ir_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version)
-  return _internal_ir_version();
-}
-inline void ModelProto::_internal_set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  ir_version_ = value;
-}
-inline void ModelProto::set_ir_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_ir_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version)
-}
-
-// repeated .onnx.OperatorSetIdProto opset_import = 8;
-inline int ModelProto::_internal_opset_import_size() const {
-  return opset_import_.size();
-}
-inline int ModelProto::opset_import_size() const {
-  return _internal_opset_import_size();
-}
-inline void ModelProto::clear_opset_import() {
-  opset_import_.Clear();
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import)
-  return opset_import_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-ModelProto::mutable_opset_import() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import)
-  return &opset_import_;
-}
-inline const ::onnx::OperatorSetIdProto& ModelProto::_internal_opset_import(int index) const {
-  return opset_import_.Get(index);
-}
-inline const ::onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import)
-  return _internal_opset_import(index);
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::_internal_add_opset_import() {
-  return opset_import_.Add();
-}
-inline ::onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import)
-  return _internal_add_opset_import();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-ModelProto::opset_import() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import)
-  return opset_import_;
-}
-
-// string producer_name = 2;
-inline void ModelProto::clear_producer_name() {
-  producer_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ModelProto::producer_name() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name)
-  return _internal_producer_name();
-}
-inline void ModelProto::set_producer_name(const std::string& value) {
-  _internal_set_producer_name(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::mutable_producer_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name)
-  return _internal_mutable_producer_name();
-}
-inline const std::string& ModelProto::_internal_producer_name() const {
-  return producer_name_.Get();
-}
-inline void ModelProto::_internal_set_producer_name(const std::string& value) {
-  
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_producer_name(std::string&& value) {
-  
-  producer_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.producer_name)
-}
-inline void ModelProto::set_producer_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.producer_name)
-}
-inline void ModelProto::set_producer_name(const char* value,
-    size_t size) {
-  
-  producer_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::_internal_mutable_producer_name() {
-  
-  return producer_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_producer_name() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name)
-  return producer_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_producer_name(std::string* producer_name) {
-  if (producer_name != nullptr) {
-    
-  } else {
-    
-  }
-  producer_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name)
-}
-inline std::string* ModelProto::unsafe_arena_release_producer_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.producer_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return producer_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_producer_name(
-    std::string* producer_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (producer_name != nullptr) {
-    
-  } else {
-    
-  }
-  producer_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      producer_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.producer_name)
-}
-
-// string producer_version = 3;
-inline void ModelProto::clear_producer_version() {
-  producer_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ModelProto::producer_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version)
-  return _internal_producer_version();
-}
-inline void ModelProto::set_producer_version(const std::string& value) {
-  _internal_set_producer_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::mutable_producer_version() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version)
-  return _internal_mutable_producer_version();
-}
-inline const std::string& ModelProto::_internal_producer_version() const {
-  return producer_version_.Get();
-}
-inline void ModelProto::_internal_set_producer_version(const std::string& value) {
-  
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_producer_version(std::string&& value) {
-  
-  producer_version_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.producer_version)
-}
-inline void ModelProto::set_producer_version(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.producer_version)
-}
-inline void ModelProto::set_producer_version(const char* value,
-    size_t size) {
-  
-  producer_version_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::_internal_mutable_producer_version() {
-  
-  return producer_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_producer_version() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version)
-  return producer_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_producer_version(std::string* producer_version) {
-  if (producer_version != nullptr) {
-    
-  } else {
-    
-  }
-  producer_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_version,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version)
-}
-inline std::string* ModelProto::unsafe_arena_release_producer_version() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.producer_version)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return producer_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_producer_version(
-    std::string* producer_version) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (producer_version != nullptr) {
-    
-  } else {
-    
-  }
-  producer_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      producer_version, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.producer_version)
-}
-
-// string domain = 4;
-inline void ModelProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ModelProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.domain)
-  return _internal_domain();
-}
-inline void ModelProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& ModelProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void ModelProto::_internal_set_domain(const std::string& value) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_domain(std::string&& value) {
-  
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.domain)
-}
-inline void ModelProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.domain)
-}
-inline void ModelProto::set_domain(const char* value,
-    size_t size) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::_internal_mutable_domain() {
-  
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.domain)
-  return domain_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain)
-}
-inline std::string* ModelProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.domain)
-}
-
-// int64 model_version = 5;
-inline void ModelProto::clear_model_version() {
-  model_version_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::_internal_model_version() const {
-  return model_version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 ModelProto::model_version() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version)
-  return _internal_model_version();
-}
-inline void ModelProto::_internal_set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  model_version_ = value;
-}
-inline void ModelProto::set_model_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_model_version(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version)
-}
-
-// string doc_string = 6;
-inline void ModelProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& ModelProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string)
-  return _internal_doc_string();
-}
-inline void ModelProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& ModelProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void ModelProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void ModelProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.ModelProto.doc_string)
-}
-inline void ModelProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.ModelProto.doc_string)
-}
-inline void ModelProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* ModelProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ModelProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string)
-}
-inline std::string* ModelProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.ModelProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void ModelProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.doc_string)
-}
-
-// .onnx.GraphProto graph = 7;
-inline bool ModelProto::_internal_has_graph() const {
-  return this != internal_default_instance() && graph_ != nullptr;
-}
-inline bool ModelProto::has_graph() const {
-  return _internal_has_graph();
-}
-inline void ModelProto::clear_graph() {
-  if (GetArena() == nullptr && graph_ != nullptr) {
-    delete graph_;
-  }
-  graph_ = nullptr;
-}
-inline const ::onnx::GraphProto& ModelProto::_internal_graph() const {
-  const ::onnx::GraphProto* p = graph_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::GraphProto*>(
-      &::onnx::_GraphProto_default_instance_);
-}
-inline const ::onnx::GraphProto& ModelProto::graph() const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.graph)
-  return _internal_graph();
-}
-inline void ModelProto::unsafe_arena_set_allocated_graph(
-    ::onnx::GraphProto* graph) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_);
-  }
-  graph_ = graph;
-  if (graph) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph)
-}
-inline ::onnx::GraphProto* ModelProto::release_graph() {
-  auto temp = unsafe_arena_release_graph();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
-  // @@protoc_insertion_point(field_release:onnx.ModelProto.graph)
-  
-  ::onnx::GraphProto* temp = graph_;
-  graph_ = nullptr;
-  return temp;
-}
-inline ::onnx::GraphProto* ModelProto::_internal_mutable_graph() {
-  
-  if (graph_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::GraphProto>(GetArena());
-    graph_ = p;
-  }
-  return graph_;
-}
-inline ::onnx::GraphProto* ModelProto::mutable_graph() {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph)
-  return _internal_mutable_graph();
-}
-inline void ModelProto::set_allocated_graph(::onnx::GraphProto* graph) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete graph_;
-  }
-  if (graph) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(graph);
-    if (message_arena != submessage_arena) {
-      graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, graph, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  graph_ = graph;
-  // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph)
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 14;
-inline int ModelProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int ModelProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void ModelProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-ModelProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& ModelProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* ModelProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-ModelProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props)
-  return metadata_props_;
-}
-
-// repeated .onnx.TrainingInfoProto training_info = 20;
-inline int ModelProto::_internal_training_info_size() const {
-  return training_info_.size();
-}
-inline int ModelProto::training_info_size() const {
-  return _internal_training_info_size();
-}
-inline void ModelProto::clear_training_info() {
-  training_info_.Clear();
-}
-inline ::onnx::TrainingInfoProto* ModelProto::mutable_training_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info)
-  return training_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >*
-ModelProto::mutable_training_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info)
-  return &training_info_;
-}
-inline const ::onnx::TrainingInfoProto& ModelProto::_internal_training_info(int index) const {
-  return training_info_.Get(index);
-}
-inline const ::onnx::TrainingInfoProto& ModelProto::training_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info)
-  return _internal_training_info(index);
-}
-inline ::onnx::TrainingInfoProto* ModelProto::_internal_add_training_info() {
-  return training_info_.Add();
-}
-inline ::onnx::TrainingInfoProto* ModelProto::add_training_info() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info)
-  return _internal_add_training_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TrainingInfoProto >&
-ModelProto::training_info() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info)
-  return training_info_;
-}
-
-// repeated .onnx.FunctionProto functions = 25;
-inline int ModelProto::_internal_functions_size() const {
-  return functions_.size();
-}
-inline int ModelProto::functions_size() const {
-  return _internal_functions_size();
-}
-inline void ModelProto::clear_functions() {
-  functions_.Clear();
-}
-inline ::onnx::FunctionProto* ModelProto::mutable_functions(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions)
-  return functions_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >*
-ModelProto::mutable_functions() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions)
-  return &functions_;
-}
-inline const ::onnx::FunctionProto& ModelProto::_internal_functions(int index) const {
-  return functions_.Get(index);
-}
-inline const ::onnx::FunctionProto& ModelProto::functions(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.functions)
-  return _internal_functions(index);
-}
-inline ::onnx::FunctionProto* ModelProto::_internal_add_functions() {
-  return functions_.Add();
-}
-inline ::onnx::FunctionProto* ModelProto::add_functions() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.functions)
-  return _internal_add_functions();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::FunctionProto >&
-ModelProto::functions() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.functions)
-  return functions_;
-}
-
-// repeated .onnx.DeviceConfigurationProto configuration = 26;
-inline int ModelProto::_internal_configuration_size() const {
-  return configuration_.size();
-}
-inline int ModelProto::configuration_size() const {
-  return _internal_configuration_size();
-}
-inline void ModelProto::clear_configuration() {
-  configuration_.Clear();
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::mutable_configuration(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.ModelProto.configuration)
-  return configuration_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >*
-ModelProto::mutable_configuration() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.configuration)
-  return &configuration_;
-}
-inline const ::onnx::DeviceConfigurationProto& ModelProto::_internal_configuration(int index) const {
-  return configuration_.Get(index);
-}
-inline const ::onnx::DeviceConfigurationProto& ModelProto::configuration(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.ModelProto.configuration)
-  return _internal_configuration(index);
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::_internal_add_configuration() {
-  return configuration_.Add();
-}
-inline ::onnx::DeviceConfigurationProto* ModelProto::add_configuration() {
-  // @@protoc_insertion_point(field_add:onnx.ModelProto.configuration)
-  return _internal_add_configuration();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::DeviceConfigurationProto >&
-ModelProto::configuration() const {
-  // @@protoc_insertion_point(field_list:onnx.ModelProto.configuration)
-  return configuration_;
-}
-
-// -------------------------------------------------------------------
-
-// DeviceConfigurationProto
-
-// string name = 1;
-inline void DeviceConfigurationProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& DeviceConfigurationProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.name)
-  return _internal_name();
-}
-inline void DeviceConfigurationProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& DeviceConfigurationProto::_internal_name() const {
-  return name_.Get();
-}
-inline void DeviceConfigurationProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void DeviceConfigurationProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.DeviceConfigurationProto.name)
-}
-inline void DeviceConfigurationProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.DeviceConfigurationProto.name)
-}
-inline void DeviceConfigurationProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* DeviceConfigurationProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.DeviceConfigurationProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void DeviceConfigurationProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.DeviceConfigurationProto.name)
-}
-inline std::string* DeviceConfigurationProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.DeviceConfigurationProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void DeviceConfigurationProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.DeviceConfigurationProto.name)
-}
-
-// int32 num_devices = 2;
-inline void DeviceConfigurationProto::clear_num_devices() {
-  num_devices_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceConfigurationProto::_internal_num_devices() const {
-  return num_devices_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceConfigurationProto::num_devices() const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.num_devices)
-  return _internal_num_devices();
-}
-inline void DeviceConfigurationProto::_internal_set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  num_devices_ = value;
-}
-inline void DeviceConfigurationProto::set_num_devices(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_num_devices(value);
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.num_devices)
-}
-
-// repeated string device = 3;
-inline int DeviceConfigurationProto::_internal_device_size() const {
-  return device_.size();
-}
-inline int DeviceConfigurationProto::device_size() const {
-  return _internal_device_size();
-}
-inline void DeviceConfigurationProto::clear_device() {
-  device_.Clear();
-}
-inline std::string* DeviceConfigurationProto::add_device() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.DeviceConfigurationProto.device)
-  return _internal_add_device();
-}
-inline const std::string& DeviceConfigurationProto::_internal_device(int index) const {
-  return device_.Get(index);
-}
-inline const std::string& DeviceConfigurationProto::device(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.DeviceConfigurationProto.device)
-  return _internal_device(index);
-}
-inline std::string* DeviceConfigurationProto::mutable_device(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.DeviceConfigurationProto.device)
-  return device_.Mutable(index);
-}
-inline void DeviceConfigurationProto::set_device(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.device)
-  device_.Mutable(index)->assign(value);
-}
-inline void DeviceConfigurationProto::set_device(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.DeviceConfigurationProto.device)
-  device_.Mutable(index)->assign(std::move(value));
-}
-inline void DeviceConfigurationProto::set_device(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  device_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::set_device(int index, const char* value, size_t size) {
-  device_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.DeviceConfigurationProto.device)
-}
-inline std::string* DeviceConfigurationProto::_internal_add_device() {
-  return device_.Add();
-}
-inline void DeviceConfigurationProto::add_device(const std::string& value) {
-  device_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(std::string&& value) {
-  device_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  device_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.DeviceConfigurationProto.device)
-}
-inline void DeviceConfigurationProto::add_device(const char* value, size_t size) {
-  device_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.DeviceConfigurationProto.device)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-DeviceConfigurationProto::device() const {
-  // @@protoc_insertion_point(field_list:onnx.DeviceConfigurationProto.device)
-  return device_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-DeviceConfigurationProto::mutable_device() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.DeviceConfigurationProto.device)
-  return &device_;
-}
-
-// -------------------------------------------------------------------
-
-// StringStringEntryProto
-
-// string key = 1;
-inline void StringStringEntryProto::clear_key() {
-  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& StringStringEntryProto::key() const {
-  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key)
-  return _internal_key();
-}
-inline void StringStringEntryProto::set_key(const std::string& value) {
-  _internal_set_key(value);
-  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::mutable_key() {
-  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key)
-  return _internal_mutable_key();
-}
-inline const std::string& StringStringEntryProto::_internal_key() const {
-  return key_.Get();
-}
-inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
-  
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void StringStringEntryProto::set_key(std::string&& value) {
-  
-  key_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.StringStringEntryProto.key)
-}
-inline void StringStringEntryProto::set_key(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.StringStringEntryProto.key)
-}
-inline void StringStringEntryProto::set_key(const char* value,
-    size_t size) {
-  
-  key_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::_internal_mutable_key() {
-  
-  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* StringStringEntryProto::release_key() {
-  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key)
-  return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void StringStringEntryProto::set_allocated_key(std::string* key) {
-  if (key != nullptr) {
-    
-  } else {
-    
-  }
-  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key)
-}
-inline std::string* StringStringEntryProto::unsafe_arena_release_key() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.StringStringEntryProto.key)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return key_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void StringStringEntryProto::unsafe_arena_set_allocated_key(
-    std::string* key) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (key != nullptr) {
-    
-  } else {
-    
-  }
-  key_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      key, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.StringStringEntryProto.key)
-}
-
-// string value = 2;
-inline void StringStringEntryProto::clear_value() {
-  value_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& StringStringEntryProto::value() const {
-  // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value)
-  return _internal_value();
-}
-inline void StringStringEntryProto::set_value(const std::string& value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::mutable_value() {
-  // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value)
-  return _internal_mutable_value();
-}
-inline const std::string& StringStringEntryProto::_internal_value() const {
-  return value_.Get();
-}
-inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
-  
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void StringStringEntryProto::set_value(std::string&& value) {
-  
-  value_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.StringStringEntryProto.value)
-}
-inline void StringStringEntryProto::set_value(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.StringStringEntryProto.value)
-}
-inline void StringStringEntryProto::set_value(const char* value,
-    size_t size) {
-  
-  value_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::_internal_mutable_value() {
-  
-  return value_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* StringStringEntryProto::release_value() {
-  // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value)
-  return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void StringStringEntryProto::set_allocated_value(std::string* value) {
-  if (value != nullptr) {
-    
-  } else {
-    
-  }
-  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value)
-}
-inline std::string* StringStringEntryProto::unsafe_arena_release_value() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.StringStringEntryProto.value)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return value_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void StringStringEntryProto::unsafe_arena_set_allocated_value(
-    std::string* value) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (value != nullptr) {
-    
-  } else {
-    
-  }
-  value_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      value, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.StringStringEntryProto.value)
-}
-
-// -------------------------------------------------------------------
-
-// TensorAnnotation
-
-// string tensor_name = 1;
-inline void TensorAnnotation::clear_tensor_name() {
-  tensor_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TensorAnnotation::tensor_name() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name)
-  return _internal_tensor_name();
-}
-inline void TensorAnnotation::set_tensor_name(const std::string& value) {
-  _internal_set_tensor_name(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::mutable_tensor_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name)
-  return _internal_mutable_tensor_name();
-}
-inline const std::string& TensorAnnotation::_internal_tensor_name() const {
-  return tensor_name_.Get();
-}
-inline void TensorAnnotation::_internal_set_tensor_name(const std::string& value) {
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorAnnotation::set_tensor_name(std::string&& value) {
-  
-  tensor_name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorAnnotation.tensor_name)
-}
-inline void TensorAnnotation::set_tensor_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorAnnotation.tensor_name)
-}
-inline void TensorAnnotation::set_tensor_name(const char* value,
-    size_t size) {
-  
-  tensor_name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::_internal_mutable_tensor_name() {
-  
-  return tensor_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorAnnotation::release_tensor_name() {
-  // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name)
-  return tensor_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorAnnotation::set_allocated_tensor_name(std::string* tensor_name) {
-  if (tensor_name != nullptr) {
-    
-  } else {
-    
-  }
-  tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name)
-}
-inline std::string* TensorAnnotation::unsafe_arena_release_tensor_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorAnnotation.tensor_name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return tensor_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorAnnotation::unsafe_arena_set_allocated_tensor_name(
-    std::string* tensor_name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (tensor_name != nullptr) {
-    
-  } else {
-    
-  }
-  tensor_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      tensor_name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorAnnotation.tensor_name)
-}
-
-// repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
-inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
-  return quant_parameter_tensor_names_.size();
-}
-inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
-  return _internal_quant_parameter_tensor_names_size();
-}
-inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
-  quant_parameter_tensor_names_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return quant_parameter_tensor_names_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorAnnotation::mutable_quant_parameter_tensor_names() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return &quant_parameter_tensor_names_;
-}
-inline const ::onnx::StringStringEntryProto& TensorAnnotation::_internal_quant_parameter_tensor_names(int index) const {
-  return quant_parameter_tensor_names_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return _internal_quant_parameter_tensor_names(index);
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::_internal_add_quant_parameter_tensor_names() {
-  return quant_parameter_tensor_names_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() {
-  // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return _internal_add_quant_parameter_tensor_names();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorAnnotation::quant_parameter_tensor_names() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names)
-  return quant_parameter_tensor_names_;
-}
-
-// -------------------------------------------------------------------
-
-// GraphProto
-
-// repeated .onnx.NodeProto node = 1;
-inline int GraphProto::_internal_node_size() const {
-  return node_.size();
-}
-inline int GraphProto::node_size() const {
-  return _internal_node_size();
-}
-inline void GraphProto::clear_node() {
-  node_.Clear();
-}
-inline ::onnx::NodeProto* GraphProto::mutable_node(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node)
-  return node_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-GraphProto::mutable_node() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node)
-  return &node_;
-}
-inline const ::onnx::NodeProto& GraphProto::_internal_node(int index) const {
-  return node_.Get(index);
-}
-inline const ::onnx::NodeProto& GraphProto::node(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.node)
-  return _internal_node(index);
-}
-inline ::onnx::NodeProto* GraphProto::_internal_add_node() {
-  return node_.Add();
-}
-inline ::onnx::NodeProto* GraphProto::add_node() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.node)
-  return _internal_add_node();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-GraphProto::node() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.node)
-  return node_;
-}
-
-// string name = 2;
-inline void GraphProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& GraphProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.name)
-  return _internal_name();
-}
-inline void GraphProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& GraphProto::_internal_name() const {
-  return name_.Get();
-}
-inline void GraphProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void GraphProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.GraphProto.name)
-}
-inline void GraphProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.GraphProto.name)
-}
-inline void GraphProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* GraphProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.GraphProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GraphProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name)
-}
-inline std::string* GraphProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.GraphProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void GraphProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.GraphProto.name)
-}
-
-// repeated .onnx.TensorProto initializer = 5;
-inline int GraphProto::_internal_initializer_size() const {
-  return initializer_.size();
-}
-inline int GraphProto::initializer_size() const {
-  return _internal_initializer_size();
-}
-inline void GraphProto::clear_initializer() {
-  initializer_.Clear();
-}
-inline ::onnx::TensorProto* GraphProto::mutable_initializer(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer)
-  return initializer_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >*
-GraphProto::mutable_initializer() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer)
-  return &initializer_;
-}
-inline const ::onnx::TensorProto& GraphProto::_internal_initializer(int index) const {
-  return initializer_.Get(index);
-}
-inline const ::onnx::TensorProto& GraphProto::initializer(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer)
-  return _internal_initializer(index);
-}
-inline ::onnx::TensorProto* GraphProto::_internal_add_initializer() {
-  return initializer_.Add();
-}
-inline ::onnx::TensorProto* GraphProto::add_initializer() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer)
-  return _internal_add_initializer();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorProto >&
-GraphProto::initializer() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer)
-  return initializer_;
-}
-
-// repeated .onnx.SparseTensorProto sparse_initializer = 15;
-inline int GraphProto::_internal_sparse_initializer_size() const {
-  return sparse_initializer_.size();
-}
-inline int GraphProto::sparse_initializer_size() const {
-  return _internal_sparse_initializer_size();
-}
-inline void GraphProto::clear_sparse_initializer() {
-  sparse_initializer_.Clear();
-}
-inline ::onnx::SparseTensorProto* GraphProto::mutable_sparse_initializer(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer)
-  return sparse_initializer_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >*
-GraphProto::mutable_sparse_initializer() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer)
-  return &sparse_initializer_;
-}
-inline const ::onnx::SparseTensorProto& GraphProto::_internal_sparse_initializer(int index) const {
-  return sparse_initializer_.Get(index);
-}
-inline const ::onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer)
-  return _internal_sparse_initializer(index);
-}
-inline ::onnx::SparseTensorProto* GraphProto::_internal_add_sparse_initializer() {
-  return sparse_initializer_.Add();
-}
-inline ::onnx::SparseTensorProto* GraphProto::add_sparse_initializer() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer)
-  return _internal_add_sparse_initializer();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::SparseTensorProto >&
-GraphProto::sparse_initializer() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer)
-  return sparse_initializer_;
-}
-
-// string doc_string = 10;
-inline void GraphProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& GraphProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string)
-  return _internal_doc_string();
-}
-inline void GraphProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& GraphProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void GraphProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void GraphProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.GraphProto.doc_string)
-}
-inline void GraphProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.GraphProto.doc_string)
-}
-inline void GraphProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* GraphProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GraphProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string)
-}
-inline std::string* GraphProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.GraphProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void GraphProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.GraphProto.doc_string)
-}
-
-// repeated .onnx.ValueInfoProto input = 11;
-inline int GraphProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int GraphProto::input_size() const {
-  return _internal_input_size();
-}
-inline void GraphProto::clear_input() {
-  input_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input)
-  return input_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input)
-  return &input_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.input)
-  return _internal_input(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_input() {
-  return input_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_input() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.input)
-  return _internal_add_input();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.input)
-  return input_;
-}
-
-// repeated .onnx.ValueInfoProto output = 12;
-inline int GraphProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int GraphProto::output_size() const {
-  return _internal_output_size();
-}
-inline void GraphProto::clear_output() {
-  output_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output)
-  return output_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output)
-  return &output_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.output)
-  return _internal_output(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_output() {
-  return output_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_output() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.output)
-  return _internal_add_output();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.output)
-  return output_;
-}
-
-// repeated .onnx.ValueInfoProto value_info = 13;
-inline int GraphProto::_internal_value_info_size() const {
-  return value_info_.size();
-}
-inline int GraphProto::value_info_size() const {
-  return _internal_value_info_size();
-}
-inline void GraphProto::clear_value_info() {
-  value_info_.Clear();
-}
-inline ::onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info)
-  return value_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-GraphProto::mutable_value_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info)
-  return &value_info_;
-}
-inline const ::onnx::ValueInfoProto& GraphProto::_internal_value_info(int index) const {
-  return value_info_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& GraphProto::value_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info)
-  return _internal_value_info(index);
-}
-inline ::onnx::ValueInfoProto* GraphProto::_internal_add_value_info() {
-  return value_info_.Add();
-}
-inline ::onnx::ValueInfoProto* GraphProto::add_value_info() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info)
-  return _internal_add_value_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-GraphProto::value_info() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info)
-  return value_info_;
-}
-
-// repeated .onnx.TensorAnnotation quantization_annotation = 14;
-inline int GraphProto::_internal_quantization_annotation_size() const {
-  return quantization_annotation_.size();
-}
-inline int GraphProto::quantization_annotation_size() const {
-  return _internal_quantization_annotation_size();
-}
-inline void GraphProto::clear_quantization_annotation() {
-  quantization_annotation_.Clear();
-}
-inline ::onnx::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation)
-  return quantization_annotation_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >*
-GraphProto::mutable_quantization_annotation() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation)
-  return &quantization_annotation_;
-}
-inline const ::onnx::TensorAnnotation& GraphProto::_internal_quantization_annotation(int index) const {
-  return quantization_annotation_.Get(index);
-}
-inline const ::onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation)
-  return _internal_quantization_annotation(index);
-}
-inline ::onnx::TensorAnnotation* GraphProto::_internal_add_quantization_annotation() {
-  return quantization_annotation_.Add();
-}
-inline ::onnx::TensorAnnotation* GraphProto::add_quantization_annotation() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation)
-  return _internal_add_quantization_annotation();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorAnnotation >&
-GraphProto::quantization_annotation() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation)
-  return quantization_annotation_;
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 16;
-inline int GraphProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int GraphProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void GraphProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* GraphProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-GraphProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& GraphProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* GraphProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* GraphProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-GraphProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// TensorProto_Segment
-
-// int64 begin = 1;
-inline void TensorProto_Segment::clear_begin() {
-  begin_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_begin() const {
-  return begin_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::begin() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin)
-  return _internal_begin();
-}
-inline void TensorProto_Segment::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  begin_ = value;
-}
-inline void TensorProto_Segment::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_begin(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin)
-}
-
-// int64 end = 2;
-inline void TensorProto_Segment::clear_end() {
-  end_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_end() const {
-  return end_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::end() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end)
-  return _internal_end();
-}
-inline void TensorProto_Segment::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  end_ = value;
-}
-inline void TensorProto_Segment::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end)
-}
-
-// -------------------------------------------------------------------
-
-// TensorProto
-
-// repeated int64 dims = 1;
-inline int TensorProto::_internal_dims_size() const {
-  return dims_.size();
-}
-inline int TensorProto::dims_size() const {
-  return _internal_dims_size();
-}
-inline void TensorProto::clear_dims() {
-  dims_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_dims(int index) const {
-  return dims_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::dims(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.dims)
-  return _internal_dims(index);
-}
-inline void TensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.dims)
-}
-inline void TensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Add(value);
-}
-inline void TensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_dims(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.dims)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::_internal_dims() const {
-  return dims_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::dims() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.dims)
-  return _internal_dims();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::_internal_mutable_dims() {
-  return &dims_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::mutable_dims() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims)
-  return _internal_mutable_dims();
-}
-
-// int32 data_type = 2;
-inline void TensorProto::clear_data_type() {
-  data_type_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_data_type() const {
-  return data_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::data_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type)
-  return _internal_data_type();
-}
-inline void TensorProto::_internal_set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  data_type_ = value;
-}
-inline void TensorProto::set_data_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_data_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type)
-}
-
-// .onnx.TensorProto.Segment segment = 3;
-inline bool TensorProto::_internal_has_segment() const {
-  return this != internal_default_instance() && segment_ != nullptr;
-}
-inline bool TensorProto::has_segment() const {
-  return _internal_has_segment();
-}
-inline void TensorProto::clear_segment() {
-  if (GetArena() == nullptr && segment_ != nullptr) {
-    delete segment_;
-  }
-  segment_ = nullptr;
-}
-inline const ::onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
-  const ::onnx::TensorProto_Segment* p = segment_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto_Segment*>(
-      &::onnx::_TensorProto_Segment_default_instance_);
-}
-inline const ::onnx::TensorProto_Segment& TensorProto::segment() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.segment)
-  return _internal_segment();
-}
-inline void TensorProto::unsafe_arena_set_allocated_segment(
-    ::onnx::TensorProto_Segment* segment) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
-  }
-  segment_ = segment;
-  if (segment) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment)
-}
-inline ::onnx::TensorProto_Segment* TensorProto::release_segment() {
-  auto temp = unsafe_arena_release_segment();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.segment)
-  
-  ::onnx::TensorProto_Segment* temp = segment_;
-  segment_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
-  
-  if (segment_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto_Segment>(GetArena());
-    segment_ = p;
-  }
-  return segment_;
-}
-inline ::onnx::TensorProto_Segment* TensorProto::mutable_segment() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment)
-  return _internal_mutable_segment();
-}
-inline void TensorProto::set_allocated_segment(::onnx::TensorProto_Segment* segment) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete segment_;
-  }
-  if (segment) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(segment);
-    if (message_arena != submessage_arena) {
-      segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, segment, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  segment_ = segment;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment)
-}
-
-// repeated float float_data = 4 [packed = true];
-inline int TensorProto::_internal_float_data_size() const {
-  return float_data_.size();
-}
-inline int TensorProto::float_data_size() const {
-  return _internal_float_data_size();
-}
-inline void TensorProto::clear_float_data() {
-  float_data_.Clear();
-}
-inline float TensorProto::_internal_float_data(int index) const {
-  return float_data_.Get(index);
-}
-inline float TensorProto::float_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data)
-  return _internal_float_data(index);
-}
-inline void TensorProto::set_float_data(int index, float value) {
-  float_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data)
-}
-inline void TensorProto::_internal_add_float_data(float value) {
-  float_data_.Add(value);
-}
-inline void TensorProto::add_float_data(float value) {
-  _internal_add_float_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-TensorProto::_internal_float_data() const {
-  return float_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
-TensorProto::float_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data)
-  return _internal_float_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-TensorProto::_internal_mutable_float_data() {
-  return &float_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
-TensorProto::mutable_float_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data)
-  return _internal_mutable_float_data();
-}
-
-// repeated int32 int32_data = 5 [packed = true];
-inline int TensorProto::_internal_int32_data_size() const {
-  return int32_data_.size();
-}
-inline int TensorProto::int32_data_size() const {
-  return _internal_int32_data_size();
-}
-inline void TensorProto::clear_int32_data() {
-  int32_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_int32_data(int index) const {
-  return int32_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::int32_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data)
-  return _internal_int32_data(index);
-}
-inline void TensorProto::set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
-  int32_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data)
-}
-inline void TensorProto::_internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  int32_data_.Add(value);
-}
-inline void TensorProto::add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_add_int32_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-TensorProto::_internal_int32_data() const {
-  return int32_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
-TensorProto::int32_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data)
-  return _internal_int32_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-TensorProto::_internal_mutable_int32_data() {
-  return &int32_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
-TensorProto::mutable_int32_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data)
-  return _internal_mutable_int32_data();
-}
-
-// repeated bytes string_data = 6;
-inline int TensorProto::_internal_string_data_size() const {
-  return string_data_.size();
-}
-inline int TensorProto::string_data_size() const {
-  return _internal_string_data_size();
-}
-inline void TensorProto::clear_string_data() {
-  string_data_.Clear();
-}
-inline std::string* TensorProto::add_string_data() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data)
-  return _internal_add_string_data();
-}
-inline const std::string& TensorProto::_internal_string_data(int index) const {
-  return string_data_.Get(index);
-}
-inline const std::string& TensorProto::string_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data)
-  return _internal_string_data(index);
-}
-inline std::string* TensorProto::mutable_string_data(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data)
-  return string_data_.Mutable(index);
-}
-inline void TensorProto::set_string_data(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
-  string_data_.Mutable(index)->assign(value);
-}
-inline void TensorProto::set_string_data(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data)
-  string_data_.Mutable(index)->assign(std::move(value));
-}
-inline void TensorProto::set_string_data(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  string_data_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.string_data)
-}
-inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
-  string_data_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.string_data)
-}
-inline std::string* TensorProto::_internal_add_string_data() {
-  return string_data_.Add();
-}
-inline void TensorProto::add_string_data(const std::string& value) {
-  string_data_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(std::string&& value) {
-  string_data_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  string_data_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.TensorProto.string_data)
-}
-inline void TensorProto::add_string_data(const void* value, size_t size) {
-  string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.TensorProto.string_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-TensorProto::string_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data)
-  return string_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-TensorProto::mutable_string_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data)
-  return &string_data_;
-}
-
-// repeated int64 int64_data = 7 [packed = true];
-inline int TensorProto::_internal_int64_data_size() const {
-  return int64_data_.size();
-}
-inline int TensorProto::int64_data_size() const {
-  return _internal_int64_data_size();
-}
-inline void TensorProto::clear_int64_data() {
-  int64_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_int64_data(int index) const {
-  return int64_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::int64_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data)
-  return _internal_int64_data(index);
-}
-inline void TensorProto::set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  int64_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data)
-}
-inline void TensorProto::_internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  int64_data_.Add(value);
-}
-inline void TensorProto::add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_int64_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::_internal_int64_data() const {
-  return int64_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-TensorProto::int64_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data)
-  return _internal_int64_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::_internal_mutable_int64_data() {
-  return &int64_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-TensorProto::mutable_int64_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data)
-  return _internal_mutable_int64_data();
-}
-
-// string name = 8;
-inline void TensorProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TensorProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.name)
-  return _internal_name();
-}
-inline void TensorProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& TensorProto::_internal_name() const {
-  return name_.Get();
-}
-inline void TensorProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.name)
-}
-inline void TensorProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.name)
-}
-inline void TensorProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name)
-}
-inline std::string* TensorProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.name)
-}
-
-// string doc_string = 12;
-inline void TensorProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TensorProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string)
-  return _internal_doc_string();
-}
-inline void TensorProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& TensorProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void TensorProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.doc_string)
-}
-inline void TensorProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.doc_string)
-}
-inline void TensorProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string)
-}
-inline std::string* TensorProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.doc_string)
-}
-
-// bytes raw_data = 9;
-inline void TensorProto::clear_raw_data() {
-  raw_data_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TensorProto::raw_data() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data)
-  return _internal_raw_data();
-}
-inline void TensorProto::set_raw_data(const std::string& value) {
-  _internal_set_raw_data(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::mutable_raw_data() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data)
-  return _internal_mutable_raw_data();
-}
-inline const std::string& TensorProto::_internal_raw_data() const {
-  return raw_data_.Get();
-}
-inline void TensorProto::_internal_set_raw_data(const std::string& value) {
-  
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorProto::set_raw_data(std::string&& value) {
-  
-  raw_data_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorProto.raw_data)
-}
-inline void TensorProto::set_raw_data(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorProto.raw_data)
-}
-inline void TensorProto::set_raw_data(const void* value,
-    size_t size) {
-  
-  raw_data_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::_internal_mutable_raw_data() {
-  
-  return raw_data_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorProto::release_raw_data() {
-  // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data)
-  return raw_data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
-  if (raw_data != nullptr) {
-    
-  } else {
-    
-  }
-  raw_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_data,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data)
-}
-inline std::string* TensorProto::unsafe_arena_release_raw_data() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorProto.raw_data)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return raw_data_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorProto::unsafe_arena_set_allocated_raw_data(
-    std::string* raw_data) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (raw_data != nullptr) {
-    
-  } else {
-    
-  }
-  raw_data_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      raw_data, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.raw_data)
-}
-
-// repeated .onnx.StringStringEntryProto external_data = 13;
-inline int TensorProto::_internal_external_data_size() const {
-  return external_data_.size();
-}
-inline int TensorProto::external_data_size() const {
-  return _internal_external_data_size();
-}
-inline void TensorProto::clear_external_data() {
-  external_data_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::mutable_external_data(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data)
-  return external_data_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorProto::mutable_external_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data)
-  return &external_data_;
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::_internal_external_data(int index) const {
-  return external_data_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::external_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data)
-  return _internal_external_data(index);
-}
-inline ::onnx::StringStringEntryProto* TensorProto::_internal_add_external_data() {
-  return external_data_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::add_external_data() {
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data)
-  return _internal_add_external_data();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorProto::external_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data)
-  return external_data_;
-}
-
-// .onnx.TensorProto.DataLocation data_location = 14;
-inline void TensorProto::clear_data_location() {
-  data_location_ = 0;
-}
-inline ::onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
-  return static_cast< ::onnx::TensorProto_DataLocation >(data_location_);
-}
-inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location)
-  return _internal_data_location();
-}
-inline void TensorProto::_internal_set_data_location(::onnx::TensorProto_DataLocation value) {
-  
-  data_location_ = value;
-}
-inline void TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) {
-  _internal_set_data_location(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location)
-}
-
-// repeated double double_data = 10 [packed = true];
-inline int TensorProto::_internal_double_data_size() const {
-  return double_data_.size();
-}
-inline int TensorProto::double_data_size() const {
-  return _internal_double_data_size();
-}
-inline void TensorProto::clear_double_data() {
-  double_data_.Clear();
-}
-inline double TensorProto::_internal_double_data(int index) const {
-  return double_data_.Get(index);
-}
-inline double TensorProto::double_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data)
-  return _internal_double_data(index);
-}
-inline void TensorProto::set_double_data(int index, double value) {
-  double_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data)
-}
-inline void TensorProto::_internal_add_double_data(double value) {
-  double_data_.Add(value);
-}
-inline void TensorProto::add_double_data(double value) {
-  _internal_add_double_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-TensorProto::_internal_double_data() const {
-  return double_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
-TensorProto::double_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data)
-  return _internal_double_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-TensorProto::_internal_mutable_double_data() {
-  return &double_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
-TensorProto::mutable_double_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data)
-  return _internal_mutable_double_data();
-}
-
-// repeated uint64 uint64_data = 11 [packed = true];
-inline int TensorProto::_internal_uint64_data_size() const {
-  return uint64_data_.size();
-}
-inline int TensorProto::uint64_data_size() const {
-  return _internal_uint64_data_size();
-}
-inline void TensorProto::clear_uint64_data() {
-  uint64_data_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::uint64 TensorProto::_internal_uint64_data(int index) const {
-  return uint64_data_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::uint64 TensorProto::uint64_data(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data)
-  return _internal_uint64_data(index);
-}
-inline void TensorProto::set_uint64_data(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  uint64_data_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data)
-}
-inline void TensorProto::_internal_add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  uint64_data_.Add(value);
-}
-inline void TensorProto::add_uint64_data(::PROTOBUF_NAMESPACE_ID::uint64 value) {
-  _internal_add_uint64_data(value);
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-TensorProto::_internal_uint64_data() const {
-  return uint64_data_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
-TensorProto::uint64_data() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data)
-  return _internal_uint64_data();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-TensorProto::_internal_mutable_uint64_data() {
-  return &uint64_data_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
-TensorProto::mutable_uint64_data() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data)
-  return _internal_mutable_uint64_data();
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 16;
-inline int TensorProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int TensorProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void TensorProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-TensorProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* TensorProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* TensorProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-TensorProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props)
-  return metadata_props_;
-}
-
-// -------------------------------------------------------------------
-
-// SparseTensorProto
-
-// .onnx.TensorProto values = 1;
-inline bool SparseTensorProto::_internal_has_values() const {
-  return this != internal_default_instance() && values_ != nullptr;
-}
-inline bool SparseTensorProto::has_values() const {
-  return _internal_has_values();
-}
-inline void SparseTensorProto::clear_values() {
-  if (GetArena() == nullptr && values_ != nullptr) {
-    delete values_;
-  }
-  values_ = nullptr;
-}
-inline const ::onnx::TensorProto& SparseTensorProto::_internal_values() const {
-  const ::onnx::TensorProto* p = values_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& SparseTensorProto::values() const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values)
-  return _internal_values();
-}
-inline void SparseTensorProto::unsafe_arena_set_allocated_values(
-    ::onnx::TensorProto* values) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(values_);
-  }
-  values_ = values;
-  if (values) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values)
-}
-inline ::onnx::TensorProto* SparseTensorProto::release_values() {
-  auto temp = unsafe_arena_release_values();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_values() {
-  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values)
-  
-  ::onnx::TensorProto* temp = values_;
-  values_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_values() {
-  
-  if (values_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    values_ = p;
-  }
-  return values_;
-}
-inline ::onnx::TensorProto* SparseTensorProto::mutable_values() {
-  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values)
-  return _internal_mutable_values();
-}
-inline void SparseTensorProto::set_allocated_values(::onnx::TensorProto* values) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete values_;
-  }
-  if (values) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(values);
-    if (message_arena != submessage_arena) {
-      values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, values, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  values_ = values;
-  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values)
-}
-
-// .onnx.TensorProto indices = 2;
-inline bool SparseTensorProto::_internal_has_indices() const {
-  return this != internal_default_instance() && indices_ != nullptr;
-}
-inline bool SparseTensorProto::has_indices() const {
-  return _internal_has_indices();
-}
-inline void SparseTensorProto::clear_indices() {
-  if (GetArena() == nullptr && indices_ != nullptr) {
-    delete indices_;
-  }
-  indices_ = nullptr;
-}
-inline const ::onnx::TensorProto& SparseTensorProto::_internal_indices() const {
-  const ::onnx::TensorProto* p = indices_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorProto*>(
-      &::onnx::_TensorProto_default_instance_);
-}
-inline const ::onnx::TensorProto& SparseTensorProto::indices() const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices)
-  return _internal_indices();
-}
-inline void SparseTensorProto::unsafe_arena_set_allocated_indices(
-    ::onnx::TensorProto* indices) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(indices_);
-  }
-  indices_ = indices;
-  if (indices) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices)
-}
-inline ::onnx::TensorProto* SparseTensorProto::release_indices() {
-  auto temp = unsafe_arena_release_indices();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::unsafe_arena_release_indices() {
-  // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices)
-  
-  ::onnx::TensorProto* temp = indices_;
-  indices_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorProto* SparseTensorProto::_internal_mutable_indices() {
-  
-  if (indices_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorProto>(GetArena());
-    indices_ = p;
-  }
-  return indices_;
-}
-inline ::onnx::TensorProto* SparseTensorProto::mutable_indices() {
-  // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices)
-  return _internal_mutable_indices();
-}
-inline void SparseTensorProto::set_allocated_indices(::onnx::TensorProto* indices) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete indices_;
-  }
-  if (indices) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(indices);
-    if (message_arena != submessage_arena) {
-      indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, indices, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  indices_ = indices;
-  // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices)
-}
-
-// repeated int64 dims = 3;
-inline int SparseTensorProto::_internal_dims_size() const {
-  return dims_.size();
-}
-inline int SparseTensorProto::dims_size() const {
-  return _internal_dims_size();
-}
-inline void SparseTensorProto::clear_dims() {
-  dims_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SparseTensorProto::_internal_dims(int index) const {
-  return dims_.Get(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 SparseTensorProto::dims(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims)
-  return _internal_dims(index);
-}
-inline void SparseTensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Set(index, value);
-  // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims)
-}
-inline void SparseTensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  dims_.Add(value);
-}
-inline void SparseTensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_add_dims(value);
-  // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-SparseTensorProto::_internal_dims() const {
-  return dims_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
-SparseTensorProto::dims() const {
-  // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims)
-  return _internal_dims();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-SparseTensorProto::_internal_mutable_dims() {
-  return &dims_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
-SparseTensorProto::mutable_dims() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims)
-  return _internal_mutable_dims();
-}
-
-// -------------------------------------------------------------------
-
-// TensorShapeProto_Dimension
-
-// int64 dim_value = 1;
-inline bool TensorShapeProto_Dimension::_internal_has_dim_value() const {
-  return value_case() == kDimValue;
-}
-inline void TensorShapeProto_Dimension::set_has_dim_value() {
-  _oneof_case_[0] = kDimValue;
-}
-inline void TensorShapeProto_Dimension::clear_dim_value() {
-  if (_internal_has_dim_value()) {
-    value_.dim_value_ = PROTOBUF_LONGLONG(0);
-    clear_has_value();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShapeProto_Dimension::_internal_dim_value() const {
-  if (_internal_has_dim_value()) {
-    return value_.dim_value_;
-  }
-  return PROTOBUF_LONGLONG(0);
-}
-inline void TensorShapeProto_Dimension::_internal_set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  if (!_internal_has_dim_value()) {
-    clear_value();
-    set_has_dim_value();
-  }
-  value_.dim_value_ = value;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShapeProto_Dimension::dim_value() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value)
-  return _internal_dim_value();
-}
-inline void TensorShapeProto_Dimension::set_dim_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_dim_value(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value)
-}
-
-// string dim_param = 2;
-inline bool TensorShapeProto_Dimension::_internal_has_dim_param() const {
-  return value_case() == kDimParam;
-}
-inline void TensorShapeProto_Dimension::set_has_dim_param() {
-  _oneof_case_[0] = kDimParam;
-}
-inline void TensorShapeProto_Dimension::clear_dim_param() {
-  if (_internal_has_dim_param()) {
-    value_.dim_param_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-    clear_has_value();
-  }
-}
-inline const std::string& TensorShapeProto_Dimension::dim_param() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param)
-  return _internal_dim_param();
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const std::string& value) {
-  _internal_set_dim_param(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::mutable_dim_param() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param)
-  return _internal_mutable_dim_param();
-}
-inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
-  if (_internal_has_dim_param()) {
-    return value_.dim_param_.Get();
-  }
-  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorShapeProto_Dimension::set_dim_param(std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param)
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline void TensorShapeProto_Dimension::set_dim_param(const char* value,
-                             size_t size) {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  value_.dim_param_.SetLite(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size),
-      GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
-  if (!_internal_has_dim_param()) {
-    clear_value();
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  return value_.dim_param_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorShapeProto_Dimension::release_dim_param() {
-  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param)
-  if (_internal_has_dim_param()) {
-    clear_has_value();
-    return value_.dim_param_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* dim_param) {
-  if (has_value()) {
-    clear_value();
-  }
-  if (dim_param != nullptr) {
-    set_has_dim_param();
-    value_.dim_param_.UnsafeSetDefault(dim_param);
-  }
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
-}
-inline std::string* TensorShapeProto_Dimension::unsafe_arena_release_dim_param() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorShapeProto.Dimension.dim_param)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (_internal_has_dim_param()) {
-    clear_has_value();
-    return value_.dim_param_.UnsafeArenaRelease(
-        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void TensorShapeProto_Dimension::unsafe_arena_set_allocated_dim_param(std::string* dim_param) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (!_internal_has_dim_param()) {
-    value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_value();
-  if (dim_param) {
-    set_has_dim_param();
-    value_.dim_param_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dim_param, GetArena());
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorShapeProto.Dimension.dim_param)
-}
-
-// string denotation = 3;
-inline void TensorShapeProto_Dimension::clear_denotation() {
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TensorShapeProto_Dimension::denotation() const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation)
-  return _internal_denotation();
-}
-inline void TensorShapeProto_Dimension::set_denotation(const std::string& value) {
-  _internal_set_denotation(value);
-  // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::mutable_denotation() {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation)
-  return _internal_mutable_denotation();
-}
-inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
-  return denotation_.Get();
-}
-inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TensorShapeProto_Dimension::set_denotation(std::string&& value) {
-  
-  denotation_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline void TensorShapeProto_Dimension::set_denotation(const char* value,
-    size_t size) {
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
-  
-  return denotation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TensorShapeProto_Dimension::release_denotation() {
-  // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation)
-  return denotation_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* denotation) {
-  if (denotation != nullptr) {
-    
-  } else {
-    
-  }
-  denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
-}
-inline std::string* TensorShapeProto_Dimension::unsafe_arena_release_denotation() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TensorShapeProto.Dimension.denotation)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return denotation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TensorShapeProto_Dimension::unsafe_arena_set_allocated_denotation(
-    std::string* denotation) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (denotation != nullptr) {
-    
-  } else {
-    
-  }
-  denotation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      denotation, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorShapeProto.Dimension.denotation)
-}
-
-inline bool TensorShapeProto_Dimension::has_value() const {
-  return value_case() != VALUE_NOT_SET;
-}
-inline void TensorShapeProto_Dimension::clear_has_value() {
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
-  return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// TensorShapeProto
-
-// repeated .onnx.TensorShapeProto.Dimension dim = 1;
-inline int TensorShapeProto::_internal_dim_size() const {
-  return dim_.size();
-}
-inline int TensorShapeProto::dim_size() const {
-  return _internal_dim_size();
-}
-inline void TensorShapeProto::clear_dim() {
-  dim_.Clear();
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim)
-  return dim_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >*
-TensorShapeProto::mutable_dim() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim)
-  return &dim_;
-}
-inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::_internal_dim(int index) const {
-  return dim_.Get(index);
-}
-inline const ::onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim)
-  return _internal_dim(index);
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::_internal_add_dim() {
-  return dim_.Add();
-}
-inline ::onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
-  // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim)
-  return _internal_add_dim();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::TensorShapeProto_Dimension >&
-TensorShapeProto::dim() const {
-  // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim)
-  return dim_;
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Tensor
-
-// int32 elem_type = 1;
-inline void TypeProto_Tensor::clear_elem_type() {
-  elem_type_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Tensor::_internal_elem_type() const {
-  return elem_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Tensor::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Tensor::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  elem_type_ = value;
-}
-inline void TypeProto_Tensor::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_elem_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type)
-}
-
-// .onnx.TensorShapeProto shape = 2;
-inline bool TypeProto_Tensor::_internal_has_shape() const {
-  return this != internal_default_instance() && shape_ != nullptr;
-}
-inline bool TypeProto_Tensor::has_shape() const {
-  return _internal_has_shape();
-}
-inline void TypeProto_Tensor::clear_shape() {
-  if (GetArena() == nullptr && shape_ != nullptr) {
-    delete shape_;
-  }
-  shape_ = nullptr;
-}
-inline const ::onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
-  const ::onnx::TensorShapeProto* p = shape_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorShapeProto*>(
-      &::onnx::_TensorShapeProto_default_instance_);
-}
-inline const ::onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape)
-  return _internal_shape();
-}
-inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
-    ::onnx::TensorShapeProto* shape) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
-  }
-  shape_ = shape;
-  if (shape) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape)
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
-  auto temp = unsafe_arena_release_shape();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape)
-  
-  ::onnx::TensorShapeProto* temp = shape_;
-  shape_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
-  
-  if (shape_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorShapeProto>(GetArena());
-    shape_ = p;
-  }
-  return shape_;
-}
-inline ::onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape)
-  return _internal_mutable_shape();
-}
-inline void TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto* shape) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete shape_;
-  }
-  if (shape) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
-    if (message_arena != submessage_arena) {
-      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, shape, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  shape_ = shape;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Sequence
-
-// .onnx.TypeProto elem_type = 1;
-inline bool TypeProto_Sequence::_internal_has_elem_type() const {
-  return this != internal_default_instance() && elem_type_ != nullptr;
-}
-inline bool TypeProto_Sequence::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_Sequence::clear_elem_type() {
-  if (GetArena() == nullptr && elem_type_ != nullptr) {
-    delete elem_type_;
-  }
-  elem_type_ = nullptr;
-}
-inline const ::onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
-  const ::onnx::TypeProto* p = elem_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Sequence::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(
-    ::onnx::TypeProto* elem_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
-  }
-  elem_type_ = elem_type;
-  if (elem_type) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type)
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::release_elem_type() {
-  auto temp = unsafe_arena_release_elem_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::unsafe_arena_release_elem_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type)
-  
-  ::onnx::TypeProto* temp = elem_type_;
-  elem_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::_internal_mutable_elem_type() {
-  
-  if (elem_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    elem_type_ = p;
-  }
-  return elem_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Sequence::mutable_elem_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type)
-  return _internal_mutable_elem_type();
-}
-inline void TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto* elem_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete elem_type_;
-  }
-  if (elem_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(elem_type);
-    if (message_arena != submessage_arena) {
-      elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, elem_type, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  elem_type_ = elem_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Map
-
-// int32 key_type = 1;
-inline void TypeProto_Map::clear_key_type() {
-  key_type_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Map::_internal_key_type() const {
-  return key_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_Map::key_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type)
-  return _internal_key_type();
-}
-inline void TypeProto_Map::_internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  key_type_ = value;
-}
-inline void TypeProto_Map::set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_key_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type)
-}
-
-// .onnx.TypeProto value_type = 2;
-inline bool TypeProto_Map::_internal_has_value_type() const {
-  return this != internal_default_instance() && value_type_ != nullptr;
-}
-inline bool TypeProto_Map::has_value_type() const {
-  return _internal_has_value_type();
-}
-inline void TypeProto_Map::clear_value_type() {
-  if (GetArena() == nullptr && value_type_ != nullptr) {
-    delete value_type_;
-  }
-  value_type_ = nullptr;
-}
-inline const ::onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
-  const ::onnx::TypeProto* p = value_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Map::value_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type)
-  return _internal_value_type();
-}
-inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(
-    ::onnx::TypeProto* value_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_);
-  }
-  value_type_ = value_type;
-  if (value_type) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type)
-}
-inline ::onnx::TypeProto* TypeProto_Map::release_value_type() {
-  auto temp = unsafe_arena_release_value_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Map::unsafe_arena_release_value_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type)
-  
-  ::onnx::TypeProto* temp = value_type_;
-  value_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Map::_internal_mutable_value_type() {
-  
-  if (value_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    value_type_ = p;
-  }
-  return value_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Map::mutable_value_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type)
-  return _internal_mutable_value_type();
-}
-inline void TypeProto_Map::set_allocated_value_type(::onnx::TypeProto* value_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete value_type_;
-  }
-  if (value_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value_type);
-    if (message_arena != submessage_arena) {
-      value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, value_type, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  value_type_ = value_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_Optional
-
-// .onnx.TypeProto elem_type = 1;
-inline bool TypeProto_Optional::_internal_has_elem_type() const {
-  return this != internal_default_instance() && elem_type_ != nullptr;
-}
-inline bool TypeProto_Optional::has_elem_type() const {
-  return _internal_has_elem_type();
-}
-inline void TypeProto_Optional::clear_elem_type() {
-  if (GetArena() == nullptr && elem_type_ != nullptr) {
-    delete elem_type_;
-  }
-  elem_type_ = nullptr;
-}
-inline const ::onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
-  const ::onnx::TypeProto* p = elem_type_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TypeProto*>(
-      &::onnx::_TypeProto_default_instance_);
-}
-inline const ::onnx::TypeProto& TypeProto_Optional::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(
-    ::onnx::TypeProto* elem_type) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
-  }
-  elem_type_ = elem_type;
-  if (elem_type) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type)
-}
-inline ::onnx::TypeProto* TypeProto_Optional::release_elem_type() {
-  auto temp = unsafe_arena_release_elem_type();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::unsafe_arena_release_elem_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type)
-  
-  ::onnx::TypeProto* temp = elem_type_;
-  elem_type_ = nullptr;
-  return temp;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::_internal_mutable_elem_type() {
-  
-  if (elem_type_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TypeProto>(GetArena());
-    elem_type_ = p;
-  }
-  return elem_type_;
-}
-inline ::onnx::TypeProto* TypeProto_Optional::mutable_elem_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type)
-  return _internal_mutable_elem_type();
-}
-inline void TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto* elem_type) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete elem_type_;
-  }
-  if (elem_type) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(elem_type);
-    if (message_arena != submessage_arena) {
-      elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, elem_type, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  elem_type_ = elem_type;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto_SparseTensor
-
-// int32 elem_type = 1;
-inline void TypeProto_SparseTensor::clear_elem_type() {
-  elem_type_ = 0;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_SparseTensor::_internal_elem_type() const {
-  return elem_type_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int32 TypeProto_SparseTensor::elem_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type)
-  return _internal_elem_type();
-}
-inline void TypeProto_SparseTensor::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  
-  elem_type_ = value;
-}
-inline void TypeProto_SparseTensor::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _internal_set_elem_type(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type)
-}
-
-// .onnx.TensorShapeProto shape = 2;
-inline bool TypeProto_SparseTensor::_internal_has_shape() const {
-  return this != internal_default_instance() && shape_ != nullptr;
-}
-inline bool TypeProto_SparseTensor::has_shape() const {
-  return _internal_has_shape();
-}
-inline void TypeProto_SparseTensor::clear_shape() {
-  if (GetArena() == nullptr && shape_ != nullptr) {
-    delete shape_;
-  }
-  shape_ = nullptr;
-}
-inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
-  const ::onnx::TensorShapeProto* p = shape_;
-  return p != nullptr ? *p : *reinterpret_cast<const ::onnx::TensorShapeProto*>(
-      &::onnx::_TensorShapeProto_default_instance_);
-}
-inline const ::onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape)
-  return _internal_shape();
-}
-inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(
-    ::onnx::TensorShapeProto* shape) {
-  if (GetArena() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
-  }
-  shape_ = shape;
-  if (shape) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape)
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
-  auto temp = unsafe_arena_release_shape();
-  if (GetArena() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::unsafe_arena_release_shape() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape)
-  
-  ::onnx::TensorShapeProto* temp = shape_;
-  shape_ = nullptr;
-  return temp;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::_internal_mutable_shape() {
-  
-  if (shape_ == nullptr) {
-    auto* p = CreateMaybeMessage<::onnx::TensorShapeProto>(GetArena());
-    shape_ = p;
-  }
-  return shape_;
-}
-inline ::onnx::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape)
-  return _internal_mutable_shape();
-}
-inline void TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto* shape) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
-  if (message_arena == nullptr) {
-    delete shape_;
-  }
-  if (shape) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
-    if (message_arena != submessage_arena) {
-      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, shape, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  shape_ = shape;
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape)
-}
-
-// -------------------------------------------------------------------
-
-// TypeProto
-
-// .onnx.TypeProto.Tensor tensor_type = 1;
-inline bool TypeProto::_internal_has_tensor_type() const {
-  return value_case() == kTensorType;
-}
-inline bool TypeProto::has_tensor_type() const {
-  return _internal_has_tensor_type();
-}
-inline void TypeProto::set_has_tensor_type() {
-  _oneof_case_[0] = kTensorType;
-}
-inline void TypeProto::clear_tensor_type() {
-  if (_internal_has_tensor_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.tensor_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type)
-  if (_internal_has_tensor_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Tensor* temp = value_.tensor_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
-  return _internal_has_tensor_type()
-      ? *value_.tensor_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Tensor*>(&::onnx::_TypeProto_Tensor_default_instance_);
-}
-inline const ::onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type)
-  return _internal_tensor_type();
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type)
-  if (_internal_has_tensor_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Tensor* temp = value_.tensor_type_;
-    value_.tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor* tensor_type) {
-  clear_value();
-  if (tensor_type) {
-    set_has_tensor_type();
-    value_.tensor_type_ = tensor_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type)
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
-  if (!_internal_has_tensor_type()) {
-    clear_value();
-    set_has_tensor_type();
-    value_.tensor_type_ = CreateMaybeMessage< ::onnx::TypeProto_Tensor >(GetArena());
-  }
-  return value_.tensor_type_;
-}
-inline ::onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type)
-  return _internal_mutable_tensor_type();
-}
-
-// .onnx.TypeProto.Sequence sequence_type = 4;
-inline bool TypeProto::_internal_has_sequence_type() const {
-  return value_case() == kSequenceType;
-}
-inline bool TypeProto::has_sequence_type() const {
-  return _internal_has_sequence_type();
-}
-inline void TypeProto::set_has_sequence_type() {
-  _oneof_case_[0] = kSequenceType;
-}
-inline void TypeProto::clear_sequence_type() {
-  if (_internal_has_sequence_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.sequence_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::release_sequence_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type)
-  if (_internal_has_sequence_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Sequence* temp = value_.sequence_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.sequence_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
-  return _internal_has_sequence_type()
-      ? *value_.sequence_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Sequence*>(&::onnx::_TypeProto_Sequence_default_instance_);
-}
-inline const ::onnx::TypeProto_Sequence& TypeProto::sequence_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type)
-  return _internal_sequence_type();
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::unsafe_arena_release_sequence_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type)
-  if (_internal_has_sequence_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Sequence* temp = value_.sequence_type_;
-    value_.sequence_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_sequence_type(::onnx::TypeProto_Sequence* sequence_type) {
-  clear_value();
-  if (sequence_type) {
-    set_has_sequence_type();
-    value_.sequence_type_ = sequence_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type)
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::_internal_mutable_sequence_type() {
-  if (!_internal_has_sequence_type()) {
-    clear_value();
-    set_has_sequence_type();
-    value_.sequence_type_ = CreateMaybeMessage< ::onnx::TypeProto_Sequence >(GetArena());
-  }
-  return value_.sequence_type_;
-}
-inline ::onnx::TypeProto_Sequence* TypeProto::mutable_sequence_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type)
-  return _internal_mutable_sequence_type();
-}
-
-// .onnx.TypeProto.Map map_type = 5;
-inline bool TypeProto::_internal_has_map_type() const {
-  return value_case() == kMapType;
-}
-inline bool TypeProto::has_map_type() const {
-  return _internal_has_map_type();
-}
-inline void TypeProto::set_has_map_type() {
-  _oneof_case_[0] = kMapType;
-}
-inline void TypeProto::clear_map_type() {
-  if (_internal_has_map_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.map_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Map* TypeProto::release_map_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type)
-  if (_internal_has_map_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Map* temp = value_.map_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.map_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
-  return _internal_has_map_type()
-      ? *value_.map_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Map*>(&::onnx::_TypeProto_Map_default_instance_);
-}
-inline const ::onnx::TypeProto_Map& TypeProto::map_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type)
-  return _internal_map_type();
-}
-inline ::onnx::TypeProto_Map* TypeProto::unsafe_arena_release_map_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type)
-  if (_internal_has_map_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Map* temp = value_.map_type_;
-    value_.map_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map* map_type) {
-  clear_value();
-  if (map_type) {
-    set_has_map_type();
-    value_.map_type_ = map_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type)
-}
-inline ::onnx::TypeProto_Map* TypeProto::_internal_mutable_map_type() {
-  if (!_internal_has_map_type()) {
-    clear_value();
-    set_has_map_type();
-    value_.map_type_ = CreateMaybeMessage< ::onnx::TypeProto_Map >(GetArena());
-  }
-  return value_.map_type_;
-}
-inline ::onnx::TypeProto_Map* TypeProto::mutable_map_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type)
-  return _internal_mutable_map_type();
-}
-
-// .onnx.TypeProto.Optional optional_type = 9;
-inline bool TypeProto::_internal_has_optional_type() const {
-  return value_case() == kOptionalType;
-}
-inline bool TypeProto::has_optional_type() const {
-  return _internal_has_optional_type();
-}
-inline void TypeProto::set_has_optional_type() {
-  _oneof_case_[0] = kOptionalType;
-}
-inline void TypeProto::clear_optional_type() {
-  if (_internal_has_optional_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.optional_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_Optional* TypeProto::release_optional_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type)
-  if (_internal_has_optional_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_Optional* temp = value_.optional_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.optional_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
-  return _internal_has_optional_type()
-      ? *value_.optional_type_
-      : *reinterpret_cast< ::onnx::TypeProto_Optional*>(&::onnx::_TypeProto_Optional_default_instance_);
-}
-inline const ::onnx::TypeProto_Optional& TypeProto::optional_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type)
-  return _internal_optional_type();
-}
-inline ::onnx::TypeProto_Optional* TypeProto::unsafe_arena_release_optional_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type)
-  if (_internal_has_optional_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_Optional* temp = value_.optional_type_;
-    value_.optional_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_optional_type(::onnx::TypeProto_Optional* optional_type) {
-  clear_value();
-  if (optional_type) {
-    set_has_optional_type();
-    value_.optional_type_ = optional_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type)
-}
-inline ::onnx::TypeProto_Optional* TypeProto::_internal_mutable_optional_type() {
-  if (!_internal_has_optional_type()) {
-    clear_value();
-    set_has_optional_type();
-    value_.optional_type_ = CreateMaybeMessage< ::onnx::TypeProto_Optional >(GetArena());
-  }
-  return value_.optional_type_;
-}
-inline ::onnx::TypeProto_Optional* TypeProto::mutable_optional_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type)
-  return _internal_mutable_optional_type();
-}
-
-// .onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
-inline bool TypeProto::_internal_has_sparse_tensor_type() const {
-  return value_case() == kSparseTensorType;
-}
-inline bool TypeProto::has_sparse_tensor_type() const {
-  return _internal_has_sparse_tensor_type();
-}
-inline void TypeProto::set_has_sparse_tensor_type() {
-  _oneof_case_[0] = kSparseTensorType;
-}
-inline void TypeProto::clear_sparse_tensor_type() {
-  if (_internal_has_sparse_tensor_type()) {
-    if (GetArena() == nullptr) {
-      delete value_.sparse_tensor_type_;
-    }
-    clear_has_value();
-  }
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type)
-  if (_internal_has_sparse_tensor_type()) {
-    clear_has_value();
-      ::onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
-    if (GetArena() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    value_.sparse_tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
-  return _internal_has_sparse_tensor_type()
-      ? *value_.sparse_tensor_type_
-      : *reinterpret_cast< ::onnx::TypeProto_SparseTensor*>(&::onnx::_TypeProto_SparseTensor_default_instance_);
-}
-inline const ::onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type)
-  return _internal_sparse_tensor_type();
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::unsafe_arena_release_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type)
-  if (_internal_has_sparse_tensor_type()) {
-    clear_has_value();
-    ::onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
-    value_.sparse_tensor_type_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(::onnx::TypeProto_SparseTensor* sparse_tensor_type) {
-  clear_value();
-  if (sparse_tensor_type) {
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = sparse_tensor_type;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type)
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::_internal_mutable_sparse_tensor_type() {
-  if (!_internal_has_sparse_tensor_type()) {
-    clear_value();
-    set_has_sparse_tensor_type();
-    value_.sparse_tensor_type_ = CreateMaybeMessage< ::onnx::TypeProto_SparseTensor >(GetArena());
-  }
-  return value_.sparse_tensor_type_;
-}
-inline ::onnx::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type)
-  return _internal_mutable_sparse_tensor_type();
-}
-
-// string denotation = 6;
-inline void TypeProto::clear_denotation() {
-  denotation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& TypeProto::denotation() const {
-  // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation)
-  return _internal_denotation();
-}
-inline void TypeProto::set_denotation(const std::string& value) {
-  _internal_set_denotation(value);
-  // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::mutable_denotation() {
-  // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation)
-  return _internal_mutable_denotation();
-}
-inline const std::string& TypeProto::_internal_denotation() const {
-  return denotation_.Get();
-}
-inline void TypeProto::_internal_set_denotation(const std::string& value) {
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void TypeProto::set_denotation(std::string&& value) {
-  
-  denotation_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.TypeProto.denotation)
-}
-inline void TypeProto::set_denotation(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.TypeProto.denotation)
-}
-inline void TypeProto::set_denotation(const char* value,
-    size_t size) {
-  
-  denotation_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::_internal_mutable_denotation() {
-  
-  return denotation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* TypeProto::release_denotation() {
-  // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation)
-  return denotation_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void TypeProto::set_allocated_denotation(std::string* denotation) {
-  if (denotation != nullptr) {
-    
-  } else {
-    
-  }
-  denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation)
-}
-inline std::string* TypeProto::unsafe_arena_release_denotation() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.denotation)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return denotation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void TypeProto::unsafe_arena_set_allocated_denotation(
-    std::string* denotation) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (denotation != nullptr) {
-    
-  } else {
-    
-  }
-  denotation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      denotation, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.denotation)
-}
-
-inline bool TypeProto::has_value() const {
-  return value_case() != VALUE_NOT_SET;
-}
-inline void TypeProto::clear_has_value() {
-  _oneof_case_[0] = VALUE_NOT_SET;
-}
-inline TypeProto::ValueCase TypeProto::value_case() const {
-  return TypeProto::ValueCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// OperatorSetIdProto
-
-// string domain = 1;
-inline void OperatorSetIdProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& OperatorSetIdProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain)
-  return _internal_domain();
-}
-inline void OperatorSetIdProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& OperatorSetIdProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void OperatorSetIdProto::set_domain(std::string&& value) {
-  
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.OperatorSetIdProto.domain)
-}
-inline void OperatorSetIdProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.OperatorSetIdProto.domain)
-}
-inline void OperatorSetIdProto::set_domain(const char* value,
-    size_t size) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
-  
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* OperatorSetIdProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain)
-  return domain_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void OperatorSetIdProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain)
-}
-inline std::string* OperatorSetIdProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.OperatorSetIdProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void OperatorSetIdProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OperatorSetIdProto.domain)
-}
-
-// int64 version = 2;
-inline void OperatorSetIdProto::clear_version() {
-  version_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorSetIdProto::_internal_version() const {
-  return version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorSetIdProto::version() const {
-  // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version)
-  return _internal_version();
-}
-inline void OperatorSetIdProto::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  version_ = value;
-}
-inline void OperatorSetIdProto::set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _internal_set_version(value);
-  // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version)
-}
-
-// -------------------------------------------------------------------
-
-// FunctionProto
-
-// string name = 1;
-inline void FunctionProto::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& FunctionProto::name() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.name)
-  return _internal_name();
-}
-inline void FunctionProto::set_name(const std::string& value) {
-  _internal_set_name(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::mutable_name() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name)
-  return _internal_mutable_name();
-}
-inline const std::string& FunctionProto::_internal_name() const {
-  return name_.Get();
-}
-inline void FunctionProto::_internal_set_name(const std::string& value) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_name(std::string&& value) {
-  
-  name_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.name)
-}
-inline void FunctionProto::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.name)
-}
-inline void FunctionProto::set_name(const char* value,
-    size_t size) {
-  
-  name_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::_internal_mutable_name() {
-  
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_name() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name)
-}
-inline std::string* FunctionProto::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.name)
-}
-
-// repeated string input = 4;
-inline int FunctionProto::_internal_input_size() const {
-  return input_.size();
-}
-inline int FunctionProto::input_size() const {
-  return _internal_input_size();
-}
-inline void FunctionProto::clear_input() {
-  input_.Clear();
-}
-inline std::string* FunctionProto::add_input() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input)
-  return _internal_add_input();
-}
-inline const std::string& FunctionProto::_internal_input(int index) const {
-  return input_.Get(index);
-}
-inline const std::string& FunctionProto::input(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.input)
-  return _internal_input(index);
-}
-inline std::string* FunctionProto::mutable_input(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input)
-  return input_.Mutable(index);
-}
-inline void FunctionProto::set_input(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
-  input_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_input(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.input)
-  input_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_input(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.input)
-}
-inline void FunctionProto::set_input(int index, const char* value, size_t size) {
-  input_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.input)
-}
-inline std::string* FunctionProto::_internal_add_input() {
-  return input_.Add();
-}
-inline void FunctionProto::add_input(const std::string& value) {
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(std::string&& value) {
-  input_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  input_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.input)
-}
-inline void FunctionProto::add_input(const char* value, size_t size) {
-  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.input)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::input() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.input)
-  return input_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_input() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input)
-  return &input_;
-}
-
-// repeated string output = 5;
-inline int FunctionProto::_internal_output_size() const {
-  return output_.size();
-}
-inline int FunctionProto::output_size() const {
-  return _internal_output_size();
-}
-inline void FunctionProto::clear_output() {
-  output_.Clear();
-}
-inline std::string* FunctionProto::add_output() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output)
-  return _internal_add_output();
-}
-inline const std::string& FunctionProto::_internal_output(int index) const {
-  return output_.Get(index);
-}
-inline const std::string& FunctionProto::output(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.output)
-  return _internal_output(index);
-}
-inline std::string* FunctionProto::mutable_output(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output)
-  return output_.Mutable(index);
-}
-inline void FunctionProto::set_output(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
-  output_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_output(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.output)
-  output_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_output(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.output)
-}
-inline void FunctionProto::set_output(int index, const char* value, size_t size) {
-  output_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.output)
-}
-inline std::string* FunctionProto::_internal_add_output() {
-  return output_.Add();
-}
-inline void FunctionProto::add_output(const std::string& value) {
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(std::string&& value) {
-  output_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  output_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.output)
-}
-inline void FunctionProto::add_output(const char* value, size_t size) {
-  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.output)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::output() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.output)
-  return output_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_output() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output)
-  return &output_;
-}
-
-// repeated string attribute = 6;
-inline int FunctionProto::_internal_attribute_size() const {
-  return attribute_.size();
-}
-inline int FunctionProto::attribute_size() const {
-  return _internal_attribute_size();
-}
-inline void FunctionProto::clear_attribute() {
-  attribute_.Clear();
-}
-inline std::string* FunctionProto::add_attribute() {
-  // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute)
-  return _internal_add_attribute();
-}
-inline const std::string& FunctionProto::_internal_attribute(int index) const {
-  return attribute_.Get(index);
-}
-inline const std::string& FunctionProto::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute)
-  return _internal_attribute(index);
-}
-inline std::string* FunctionProto::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute)
-  return attribute_.Mutable(index);
-}
-inline void FunctionProto::set_attribute(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
-  attribute_.Mutable(index)->assign(value);
-}
-inline void FunctionProto::set_attribute(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute)
-  attribute_.Mutable(index)->assign(std::move(value));
-}
-inline void FunctionProto::set_attribute(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  attribute_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::set_attribute(int index, const char* value, size_t size) {
-  attribute_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.attribute)
-}
-inline std::string* FunctionProto::_internal_add_attribute() {
-  return attribute_.Add();
-}
-inline void FunctionProto::add_attribute(const std::string& value) {
-  attribute_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(std::string&& value) {
-  attribute_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  attribute_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.attribute)
-}
-inline void FunctionProto::add_attribute(const char* value, size_t size) {
-  attribute_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.attribute)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FunctionProto::attribute() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute)
-  return attribute_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FunctionProto::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute)
-  return &attribute_;
-}
-
-// repeated .onnx.AttributeProto attribute_proto = 11;
-inline int FunctionProto::_internal_attribute_proto_size() const {
-  return attribute_proto_.size();
-}
-inline int FunctionProto::attribute_proto_size() const {
-  return _internal_attribute_proto_size();
-}
-inline void FunctionProto::clear_attribute_proto() {
-  attribute_proto_.Clear();
-}
-inline ::onnx::AttributeProto* FunctionProto::mutable_attribute_proto(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto)
-  return attribute_proto_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >*
-FunctionProto::mutable_attribute_proto() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto)
-  return &attribute_proto_;
-}
-inline const ::onnx::AttributeProto& FunctionProto::_internal_attribute_proto(int index) const {
-  return attribute_proto_.Get(index);
-}
-inline const ::onnx::AttributeProto& FunctionProto::attribute_proto(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto)
-  return _internal_attribute_proto(index);
-}
-inline ::onnx::AttributeProto* FunctionProto::_internal_add_attribute_proto() {
-  return attribute_proto_.Add();
-}
-inline ::onnx::AttributeProto* FunctionProto::add_attribute_proto() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto)
-  return _internal_add_attribute_proto();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::AttributeProto >&
-FunctionProto::attribute_proto() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto)
-  return attribute_proto_;
-}
-
-// repeated .onnx.NodeProto node = 7;
-inline int FunctionProto::_internal_node_size() const {
-  return node_.size();
-}
-inline int FunctionProto::node_size() const {
-  return _internal_node_size();
-}
-inline void FunctionProto::clear_node() {
-  node_.Clear();
-}
-inline ::onnx::NodeProto* FunctionProto::mutable_node(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node)
-  return node_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >*
-FunctionProto::mutable_node() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node)
-  return &node_;
-}
-inline const ::onnx::NodeProto& FunctionProto::_internal_node(int index) const {
-  return node_.Get(index);
-}
-inline const ::onnx::NodeProto& FunctionProto::node(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.node)
-  return _internal_node(index);
-}
-inline ::onnx::NodeProto* FunctionProto::_internal_add_node() {
-  return node_.Add();
-}
-inline ::onnx::NodeProto* FunctionProto::add_node() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.node)
-  return _internal_add_node();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::NodeProto >&
-FunctionProto::node() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.node)
-  return node_;
-}
-
-// string doc_string = 8;
-inline void FunctionProto::clear_doc_string() {
-  doc_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& FunctionProto::doc_string() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string)
-  return _internal_doc_string();
-}
-inline void FunctionProto::set_doc_string(const std::string& value) {
-  _internal_set_doc_string(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::mutable_doc_string() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string)
-  return _internal_mutable_doc_string();
-}
-inline const std::string& FunctionProto::_internal_doc_string() const {
-  return doc_string_.Get();
-}
-inline void FunctionProto::_internal_set_doc_string(const std::string& value) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_doc_string(std::string&& value) {
-  
-  doc_string_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.doc_string)
-}
-inline void FunctionProto::set_doc_string(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.doc_string)
-}
-inline void FunctionProto::set_doc_string(const char* value,
-    size_t size) {
-  
-  doc_string_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::_internal_mutable_doc_string() {
-  
-  return doc_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_doc_string() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string)
-  return doc_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_doc_string(std::string* doc_string) {
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string)
-}
-inline std::string* FunctionProto::unsafe_arena_release_doc_string() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.doc_string)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return doc_string_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_doc_string(
-    std::string* doc_string) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (doc_string != nullptr) {
-    
-  } else {
-    
-  }
-  doc_string_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      doc_string, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.doc_string)
-}
-
-// repeated .onnx.OperatorSetIdProto opset_import = 9;
-inline int FunctionProto::_internal_opset_import_size() const {
-  return opset_import_.size();
-}
-inline int FunctionProto::opset_import_size() const {
-  return _internal_opset_import_size();
-}
-inline void FunctionProto::clear_opset_import() {
-  opset_import_.Clear();
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::mutable_opset_import(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import)
-  return opset_import_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >*
-FunctionProto::mutable_opset_import() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import)
-  return &opset_import_;
-}
-inline const ::onnx::OperatorSetIdProto& FunctionProto::_internal_opset_import(int index) const {
-  return opset_import_.Get(index);
-}
-inline const ::onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import)
-  return _internal_opset_import(index);
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::_internal_add_opset_import() {
-  return opset_import_.Add();
-}
-inline ::onnx::OperatorSetIdProto* FunctionProto::add_opset_import() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import)
-  return _internal_add_opset_import();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::OperatorSetIdProto >&
-FunctionProto::opset_import() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import)
-  return opset_import_;
-}
-
-// string domain = 10;
-inline void FunctionProto::clear_domain() {
-  domain_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& FunctionProto::domain() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain)
-  return _internal_domain();
-}
-inline void FunctionProto::set_domain(const std::string& value) {
-  _internal_set_domain(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::mutable_domain() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain)
-  return _internal_mutable_domain();
-}
-inline const std::string& FunctionProto::_internal_domain() const {
-  return domain_.Get();
-}
-inline void FunctionProto::_internal_set_domain(const std::string& value) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_domain(std::string&& value) {
-  
-  domain_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.domain)
-}
-inline void FunctionProto::set_domain(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.domain)
-}
-inline void FunctionProto::set_domain(const char* value,
-    size_t size) {
-  
-  domain_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::_internal_mutable_domain() {
-  
-  return domain_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_domain() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain)
-  return domain_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_domain(std::string* domain) {
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain)
-}
-inline std::string* FunctionProto::unsafe_arena_release_domain() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.domain)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return domain_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_domain(
-    std::string* domain) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (domain != nullptr) {
-    
-  } else {
-    
-  }
-  domain_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      domain, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.domain)
-}
-
-// string overload = 13;
-inline void FunctionProto::clear_overload() {
-  overload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline const std::string& FunctionProto::overload() const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload)
-  return _internal_overload();
-}
-inline void FunctionProto::set_overload(const std::string& value) {
-  _internal_set_overload(value);
-  // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::mutable_overload() {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload)
-  return _internal_mutable_overload();
-}
-inline const std::string& FunctionProto::_internal_overload() const {
-  return overload_.Get();
-}
-inline void FunctionProto::_internal_set_overload(const std::string& value) {
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void FunctionProto::set_overload(std::string&& value) {
-  
-  overload_.SetLite(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:onnx.FunctionProto.overload)
-}
-inline void FunctionProto::set_overload(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.overload)
-}
-inline void FunctionProto::set_overload(const char* value,
-    size_t size) {
-  
-  overload_.SetLite(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::_internal_mutable_overload() {
-  
-  return overload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline std::string* FunctionProto::release_overload() {
-  // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload)
-  return overload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void FunctionProto::set_allocated_overload(std::string* overload) {
-  if (overload != nullptr) {
-    
-  } else {
-    
-  }
-  overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload)
-}
-inline std::string* FunctionProto::unsafe_arena_release_overload() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:onnx.FunctionProto.overload)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return overload_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void FunctionProto::unsafe_arena_set_allocated_overload(
-    std::string* overload) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (overload != nullptr) {
-    
-  } else {
-    
-  }
-  overload_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      overload, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.FunctionProto.overload)
-}
-
-// repeated .onnx.ValueInfoProto value_info = 12;
-inline int FunctionProto::_internal_value_info_size() const {
-  return value_info_.size();
-}
-inline int FunctionProto::value_info_size() const {
-  return _internal_value_info_size();
-}
-inline void FunctionProto::clear_value_info() {
-  value_info_.Clear();
-}
-inline ::onnx::ValueInfoProto* FunctionProto::mutable_value_info(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info)
-  return value_info_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >*
-FunctionProto::mutable_value_info() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info)
-  return &value_info_;
-}
-inline const ::onnx::ValueInfoProto& FunctionProto::_internal_value_info(int index) const {
-  return value_info_.Get(index);
-}
-inline const ::onnx::ValueInfoProto& FunctionProto::value_info(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info)
-  return _internal_value_info(index);
-}
-inline ::onnx::ValueInfoProto* FunctionProto::_internal_add_value_info() {
-  return value_info_.Add();
-}
-inline ::onnx::ValueInfoProto* FunctionProto::add_value_info() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info)
-  return _internal_add_value_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::ValueInfoProto >&
-FunctionProto::value_info() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info)
-  return value_info_;
-}
-
-// repeated .onnx.StringStringEntryProto metadata_props = 14;
-inline int FunctionProto::_internal_metadata_props_size() const {
-  return metadata_props_.size();
-}
-inline int FunctionProto::metadata_props_size() const {
-  return _internal_metadata_props_size();
-}
-inline void FunctionProto::clear_metadata_props() {
-  metadata_props_.Clear();
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::mutable_metadata_props(int index) {
-  // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props)
-  return metadata_props_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >*
-FunctionProto::mutable_metadata_props() {
-  // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props)
-  return &metadata_props_;
-}
-inline const ::onnx::StringStringEntryProto& FunctionProto::_internal_metadata_props(int index) const {
-  return metadata_props_.Get(index);
-}
-inline const ::onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const {
-  // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props)
-  return _internal_metadata_props(index);
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::_internal_add_metadata_props() {
-  return metadata_props_.Add();
-}
-inline ::onnx::StringStringEntryProto* FunctionProto::add_metadata_props() {
-  // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props)
-  return _internal_add_metadata_props();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx::StringStringEntryProto >&
-FunctionProto::metadata_props() const {
-  // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props)
-  return metadata_props_;
-}
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic pop
-#endif  // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace onnx
-
-PROTOBUF_NAMESPACE_OPEN
-
-template <> struct is_proto_enum< ::onnx::AttributeProto_AttributeType> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::TensorProto_DataType> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::TensorProto_DataLocation> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::Version> : ::std::true_type {};
-template <> struct is_proto_enum< ::onnx::OperatorStatus> : ::std::true_type {};
-
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-
-#include <google/protobuf/port_undef.inc>
-#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto3
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.cpp b/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.cpp
deleted file mode 100644
index 84002c5..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// Created by martinkorelic on 31/08/2024
-//
-
-#include "train.h"
-#include <android/log.h>
-
-#define LOG_TAG "ORTTransformer"
-
-namespace training {
-
-    float train_step(TrainingSessionCache* session_cache,
-                     int64_t* input_ids,
-                     int64_t* attention_mask,
-                     int64_t* position_ids,
-                     int64_t* labels,
-                     int64_t batch_size,
-                     int64_t sequence_length) {
-        const std::vector<int64_t> input_ids_shape({batch_size, sequence_length});
-        const std::vector<int64_t> attention_mask_shape({batch_size, sequence_length});
-        const std::vector<int64_t> position_ids_shape({batch_size, sequence_length});
-        const std::vector<int64_t> labels_shape({batch_size, sequence_length});
-
-        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-
-        std::vector<Ort::Value> user_inputs; // {input_ids, attention_mask, position_ids, labels}
-        // Input_ids batched
-        user_inputs.emplace_back(Ort::Value::CreateTensor(memory_info, input_ids,
-                                                          batch_size * sequence_length * sizeof(int64_t),
-                                                          input_ids_shape.data(), input_ids_shape.size(),
-                                                          ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64));
-        // Attention mask batched
-        user_inputs.emplace_back(Ort::Value::CreateTensor(memory_info, attention_mask,
-                                                          batch_size * sequence_length * sizeof(int64_t),
-                                                          attention_mask_shape.data(), attention_mask_shape.size(),
-                                                          ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64));
-        // Position ids batched
-        user_inputs.emplace_back(Ort::Value::CreateTensor(memory_info, position_ids,
-                                                          batch_size * sequence_length * sizeof(int64_t),
-                                                          position_ids_shape.data(), position_ids_shape.size(),
-                                                          ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64));
-        // Labels batched
-        user_inputs.emplace_back(Ort::Value::CreateTensor(memory_info, labels,
-                                                          batch_size * sequence_length * sizeof(int64_t),
-                                                          labels_shape.data(), labels_shape.size(),
-                                                          ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64));
-
-        // Run the train step and execute the forward + loss + backward.
-        //auto session_run_opts = Ort::RunOptions();
-
-        //auto ortApi = OrtGetApiBase()->GetApi(ORT_API_VERSION)->GetTrainingApi(ORT_API_VERSION);
-        //ortApi->TrainStep(session_cache->training_session, session_run_opts);
-        float loss = *(session_cache->training_session.TrainStep(user_inputs).front().GetTensorMutableData<float>());
-
-        // Update the model parameters by taking a step in the direction of the gradients computed above.
-        //session_cache->training_session.OptimizerStep();
-
-        // Reset the gradients now that the parameters have been updated.
-        // New set of gradients can then be computed for the next round of inputs.
-        //session_cache->training_session.LazyResetGrad();
-
-        user_inputs.clear();
-
-        return loss;
-    }
-
-    void optimizer_step(TrainingSessionCache* session_cache) {
-        // Update the model parameters by taking a step in the direction of the gradients
-        session_cache->training_session.OptimizerStep();
-
-        // Reset the gradients now that the parameters have been updated.
-        // New set of gradients can then be computed for the next round of inputs.
-        session_cache->training_session.LazyResetGrad();
-    }
-
-} // namespace training
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.h
deleted file mode 100644
index 87f1d1f..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/train.h
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Created by martinkorelic on 19/09/2024.
-//
-
-#include "onnxruntime/onnxruntime_training_cxx_api.h"
-#include "session_cache.h"
-
-namespace training {
-
-    // returns the output of the training graph (loss) and updates the parameters
-    // based on the gradients computed.
-    float train_step(TrainingSessionCache* session_cache,
-                     int64_t* input_ids,
-                     int64_t* attention_mask,
-                     int64_t* position_ids,
-                     int64_t* labels,
-                     int64_t batch_size,
-                     int64_t sequence_length);
-
-    void optimizer_step(TrainingSessionCache* session_cache);
-
-} // namespace training
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.cpp b/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.cpp
deleted file mode 100644
index 3be2d57..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_merger.cpp
+++ /dev/null
@@ -1,972 +0,0 @@
-//
-// Created by martinkorelic on 20. 07. 25.
-//
-
-#include "weight_merger.h"
-#include <jni.h>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <fstream>
-#include <filesystem>
-#include <android/log.h>
-#include <nlohmann/json.hpp>
-#include "logging.h"
-
-
-using json = nlohmann::json;
-
-// ParameterTracker constructor implementation
-WeightMerger::ParameterTracker::ParameterTracker(const std::string& layer_name)
-        : base_layer_name(layer_name) {
-}
-
-// WeightMerger constructor implementation
-WeightMerger::WeightMerger()
-        : memory_info_(Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault)) {
-}
-
-
-
-// Helper function to create a copy of OrtValue for user-managed memory
-std::pair<std::unique_ptr<Ort::Value>, void*> WeightMerger::CreateUserManagedCopy(const Ort::Value& original) {
-    auto tensor_info = original.GetTensorTypeAndShapeInfo();
-    std::vector<int64_t> tensor_shape = tensor_info.GetShape();
-    auto tensor_type = tensor_info.GetElementType();
-    size_t total_elements = tensor_info.GetElementCount();
-    size_t element_size = 0;
-
-    // Determine the size of one element based on tensor type
-    switch (tensor_type) {
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT:
-            element_size = sizeof(float);
-            break;
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT16:
-            element_size = sizeof(int16_t);
-            break;
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:
-            element_size = sizeof(int32_t);
-            break;
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64:
-            element_size = sizeof(int64_t);
-            break;
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8:
-            element_size = sizeof(int8_t);
-            break;
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8:
-            element_size = sizeof(uint8_t);
-            break;
-        default:
-            throw std::runtime_error("Unsupported tensor data type");
-    }
-
-    // Allocate memory for the tensor data
-    size_t data_size = total_elements * element_size;
-    void* user_data = allocator_.Alloc(data_size);
-
-    // Copy data from the original tensor
-    std::memcpy(user_data, original.GetTensorRawData(), data_size);
-
-    // Create new tensor with user-managed data
-    auto& ortApi = Ort::GetApi();
-    OrtValue* c_tensor;
-    auto ortStatus = ortApi.CreateTensorWithDataAsOrtValue(
-            memory_info_, user_data, data_size,
-            tensor_shape.data(), tensor_shape.size(),
-            tensor_type, &c_tensor);
-
-    if (ortStatus != nullptr) {
-        const char* error_message = ortApi.GetErrorMessage(ortStatus);
-        ortApi.ReleaseStatus(ortStatus);
-        allocator_.Free(user_data);
-        throw std::runtime_error("Failed to create tensor with user-managed data: " + std::string(error_message));
-    }
-
-    return std::make_pair(std::make_unique<Ort::Value>(c_tensor), user_data);
-}
-
-std::optional<Ort::Value> WeightMerger::GetParameterIfType(
-        const OrtCheckpointState* checkpoint_state,
-        const char* parameter_name,
-        ONNXTensorElementDataType expected_type) {
-
-    Ort::AllocatorWithDefaultOptions allocator;
-
-    const OrtApi* api = OrtGetApiBase()->GetApi(ORT_API_VERSION);
-    const OrtTrainingApi* training_api = api->GetTrainingApi(ORT_API_VERSION);
-
-    // Check parameter type first
-    OrtTensorTypeAndShapeInfo* type_info = nullptr;
-    OrtStatus* status = training_api->GetParameterTypeAndShape(
-            checkpoint_state, parameter_name, &type_info);
-
-    if (status != nullptr) {
-        api->ReleaseStatus(status);
-        return std::nullopt; // Parameter doesn't exist
-    }
-
-    ONNXTensorElementDataType actual_type;
-    status = api->GetTensorElementType(type_info, &actual_type);
-    api->ReleaseTensorTypeAndShapeInfo(type_info);
-
-    if (status != nullptr) {
-        api->ReleaseStatus(status);
-        return std::nullopt;
-    }
-
-    if (actual_type != expected_type) {
-        LOGI("Parameter %s type mismatch: expected %d, got %d",
-             parameter_name, expected_type, actual_type);
-        return std::nullopt;
-    }
-    // Get the shape information
-    size_t dim_count = 0;
-    status = api->GetDimensionsCount(type_info, &dim_count);
-    if (status != nullptr) {
-        api->ReleaseStatus(status);
-        api->ReleaseTensorTypeAndShapeInfo(type_info);
-        return std::nullopt;
-    }
-
-    std::vector<int64_t> shape(dim_count);
-    status = api->GetDimensions(type_info, shape.data(), dim_count);
-    if (status != nullptr) {
-        api->ReleaseStatus(status);
-        api->ReleaseTensorTypeAndShapeInfo(type_info);
-        return std::nullopt;
-    }
-
-    // Create an OrtValue with the correct type and shape
-    OrtValue* parameter = nullptr;
-    status = api->CreateTensorAsOrtValue(
-            allocator,
-            shape.data(),
-            dim_count,
-            actual_type,
-            &parameter
-    );
-
-    if (status != nullptr) {
-        const char* error_message = api->GetErrorMessage(status);
-        LOGI("CreateTensorAsOrtValue failed: %s", error_message);
-        api->ReleaseStatus(status);
-        return std::nullopt;
-    }
-
-    //LOGI("Created tensor element type: %d (UINT8=%d, FLOAT=%d)", created_type,
-    //     ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
-
-    if (status != nullptr) {
-        api->ReleaseStatus(status);
-        return std::nullopt;
-    }
-
-    // Now copy the parameter data into our pre-allocated tensor
-    // NOTE: This kept failing in source code, as it always created float parameter even though we had quantized parameters
-    // This fix needs to be do in source code (orttraining/orttraining/training_api/onnxruntime_training_c_api.cc::640)
-    status = training_api->GetParameter(checkpoint_state, parameter_name, allocator, &parameter);
-
-    if (status != nullptr) {
-        const char* error_message = api->GetErrorMessage(status);
-        LOGI("Error getting parameter type and shape for %s: %s", parameter_name, error_message);
-        api->ReleaseStatus(status);
-        return std::nullopt;
-    }
-
-    return Ort::Value(parameter);
-}
-
-template<typename T>
-std::unique_ptr<Ort::Value> WeightMerger::CreateScalarTensor(T value) {
-    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeDefault);
-
-    // Scalar tensor has empty shape (0 dimensions)
-    std::vector<int64_t> shape = {};
-
-    // Allocate memory for single value
-    std::vector<T> data = {value};
-
-    auto tensor = Ort::Value::CreateTensor<T>(
-            memory_info,
-            data.data(),
-            1,  // single element
-            shape.data(),
-            shape.size()
-    );
-
-    return std::make_unique<Ort::Value>(std::move(tensor));
-}
-
-// Helper function to get tensor shape
-std::vector<int64_t> WeightMerger::get_tensor_shape(const Ort::Value& tensor) {
-    return tensor.GetTensorTypeAndShapeInfo().GetShape();
-}
-
-// Replace prefix in parameter name
-std::string WeightMerger::replace_prefix(const std::string& name, const std::string& old_prefix, const std::string& new_prefix) {
-    if (name.substr(0, old_prefix.length()) == old_prefix) {
-        return new_prefix + name.substr(old_prefix.length());
-    }
-    return name;
-}
-
-// Load and parse PEFT mapping from JSON
-bool WeightMerger::load_peft_mapping(const std::string& json_path) {
-    try {
-        std::ifstream file(json_path);
-        if (!file.is_open()) {
-            LOGE("Failed to open PEFT mapping file: %s", json_path.c_str());
-            return false;
-        }
-
-        json j;
-        file >> j;
-
-        if (!j.contains("peft_mapping")) {
-            LOGE("JSON file does not contain 'peft_mapping' key");
-            return false;
-        }
-
-        for (const auto& [base_layer_name, mapping_data] : j["peft_mapping"].items()) {
-            PeftMapping mapping;
-
-            if (mapping_data.contains("adapter_B")) {
-                mapping.adapter_B = mapping_data["adapter_B"];
-            }
-            if (mapping_data.contains("rank")) {
-                mapping.rank = mapping_data["rank"];
-            }
-            if (mapping_data.contains("alpha")) {
-                mapping.alpha = mapping_data["alpha"];
-            }
-            if (mapping_data.contains("shared_A")) {
-                mapping.shared_A = mapping_data["shared_A"];
-            }
-            if (mapping_data.contains("intermediate")) {
-                mapping.intermediate = mapping_data["intermediate"];
-            }
-            if (mapping_data.contains("adapter_index")) {
-                mapping.adapter_index = mapping_data["adapter_index"];
-            }
-            if (mapping_data.contains("adapter_A")) {
-                mapping.adapter_A = mapping_data["adapter_A"];
-            }
-
-            peft_mapping_[base_layer_name] = mapping;
-            LOGI("Loaded PEFT mapping for: %s", base_layer_name.c_str());
-        }
-
-        LOGI("Successfully loaded %zu PEFT mappings", peft_mapping_.size());
-        return true;
-    } catch (const std::exception& e) {
-        LOGE("Error loading PEFT mapping: %s", e.what());
-        return false;
-    }
-}
-
-// Extract base layer parameters from checkpoint
-void WeightMerger::extract_base_layer_params(Ort::CheckpointState& checkpoint_state) {
-    LOGI("Extracting base layer parameters...");
-
-    for (const auto& [base_layer_name, _] : peft_mapping_) {
-        std::string adjusted_name = replace_prefix(base_layer_name, "base_model.model.model.", "backbone.model.");
-
-        BaseLayerParams base_params;
-
-        // Look for different weight parameter types
-        std::string weight_quantized_name = adjusted_name + ".weight_quantized";
-        std::string weight_scale_name = adjusted_name + ".weight_scale";
-        std::string weight_zero_point_name = adjusted_name + ".weight_zero_point";
-        std::string weight_name = adjusted_name + ".weight";
-
-        // Try to get quantized weight
-        auto quantized_tensor = GetParameterIfType(
-                checkpoint_state,
-                weight_quantized_name.c_str(),
-                ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8
-        );
-
-        if (quantized_tensor.has_value()) {
-            auto [tensor, buffer] = CreateUserManagedCopy(quantized_tensor.value());
-            base_params.weight_quantized = std::move(tensor);
-            base_params.weight_quantized_buffer = buffer;
-            base_params.has_quantized = true;
-            LOGI("Found quantized weight: %s", weight_quantized_name.c_str());
-        } else {
-            // Parameter doesn't exist or has wrong type
-            LOGI("Quantized weight %s not found or has wrong type", weight_quantized_name.c_str());
-        }
-
-        // Try to get weight scale
-        auto scale_tensor = GetParameterIfType(
-                checkpoint_state,
-                weight_scale_name.c_str(),
-                ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT  // Assuming scales are float
-        );
-
-        if (scale_tensor.has_value()) {
-            auto [tensor, buffer] = CreateUserManagedCopy(scale_tensor.value());
-            base_params.x_scale = std::move(tensor);
-            base_params.x_scale_buffer = buffer;
-            LOGI("Found weight scale: %s", weight_scale_name.c_str());
-        } else {
-            LOGI("Weight scale %s not found or has wrong type", weight_scale_name.c_str());
-        }
-
-        // Try to get weight zero point
-        auto zero_point_tensor = GetParameterIfType(
-                checkpoint_state,
-                weight_zero_point_name.c_str(),
-                ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8
-        );
-
-        if (zero_point_tensor.has_value()) {
-            auto [tensor, buffer] = CreateUserManagedCopy(zero_point_tensor.value());
-            base_params.x_zero_point = std::move(tensor);
-            base_params.x_zero_point_buffer = buffer;
-            LOGI("Found weight zero point: %s", weight_zero_point_name.c_str());
-        } else {
-            LOGI("Weight zero point %s not found or has wrong type", weight_zero_point_name.c_str());
-        }
-
-        // Try to get regular weight
-        auto weight_tensor = GetParameterIfType(
-                checkpoint_state,
-                weight_name.c_str(),
-                ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT  // Regular weights are typically float
-        );
-
-        if (weight_tensor.has_value()) {
-            auto [tensor, buffer] = CreateUserManagedCopy(weight_tensor.value());
-            base_params.weight = std::move(tensor);
-            base_params.weight_buffer = buffer;
-            base_params.has_weight = true;
-            LOGI("Found non-quantized weight: %s", weight_name.c_str());
-        } else {
-            LOGI("Non-quantized weight %s not found or has wrong type", weight_name.c_str());
-        }
-
-        if (base_params.has_quantized || base_params.has_weight) {
-            base_layer_params_[adjusted_name] = std::move(base_params);
-            LOGI("Extracted base layer params for: %s", adjusted_name.c_str());
-        } else {
-            LOGW("No parameters found for base layer: %s", adjusted_name.c_str());
-        }
-    }
-}
-
-// Extract adapter parameters from checkpoint
-void WeightMerger::extract_adapter_params(Ort::CheckpointState& checkpoint_state) {
-    LOGI("Extracting adapter parameters...");
-
-    for (const auto& [base_layer_name, mapping] : peft_mapping_) {
-        std::string adjusted_base_name = replace_prefix(base_layer_name, "base_model.model.model.", "backbone.model.");
-
-        adapter_params_[adjusted_base_name] = std::unordered_map<std::string, AdapterParams>();
-
-        // Extract adapter_B
-        if (!mapping.adapter_B.empty()) {
-            std::string adapter_name = replace_prefix(mapping.adapter_B, "base_model.model.model.", "backbone.model.");
-            adapter_name += ".weight";
-
-            try {
-                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
-                AdapterParams params;
-                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
-                params.data = std::move(adapter_tensor);
-                params.raw_buffer = buffer;
-                adapter_params_[adjusted_base_name]["adapter_B"] = std::move(params);
-                LOGI("Found adapter_B param: %s", adapter_name.c_str());
-            } catch (const std::exception& e) {
-                LOGW("Parameter not found or error extracting adapter_B for %s: %s", adapter_name.c_str(), e.what());
-            }
-        }
-
-        // Extract shared_A
-        if (!mapping.shared_A.empty()) {
-            std::string adapter_name = replace_prefix(mapping.shared_A, "base_model.model.model.", "backbone.model.");
-            adapter_name += ".weight";
-
-            try {
-                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
-                AdapterParams params;
-                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
-                params.data = std::move(adapter_tensor);
-                params.raw_buffer = buffer;
-                adapter_params_[adjusted_base_name]["shared_A"] = std::move(params);
-                LOGI("Found shared_A param: %s", adapter_name.c_str());
-            } catch (const std::exception& e) {
-                LOGW("Parameter not found or error extracting shared_A for %s: %s", adapter_name.c_str(), e.what());
-            }
-        }
-
-        // Extract intermediate
-        if (!mapping.intermediate.empty()) {
-            std::string adapter_name = replace_prefix(mapping.intermediate, "base_model.model.model.", "backbone.model.");
-            adapter_name += ".weight";
-
-            try {
-                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
-                AdapterParams params;
-                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
-                params.data = std::move(adapter_tensor);
-                params.raw_buffer = buffer;
-                adapter_params_[adjusted_base_name]["intermediate"] = std::move(params);
-                LOGI("Found intermediate param: %s", adapter_name.c_str());
-            } catch (const std::exception& e) {
-                LOGW("Parameter not found or error extracting intermediate for %s: %s", adapter_name.c_str(), e.what());
-            }
-        }
-
-        // Extract adapter_A (for LoRA)
-        if (!mapping.adapter_A.empty()) {
-            std::string adapter_name = replace_prefix(mapping.adapter_A, "base_model.model.model.", "backbone.model.");
-            adapter_name += ".weight";
-
-            try {
-                Ort::Value tensor = checkpoint_state.GetParameter(adapter_name);
-                AdapterParams params;
-                auto [adapter_tensor, buffer] = CreateUserManagedCopy(tensor);
-                params.data = std::move(adapter_tensor);
-                params.raw_buffer = buffer;
-                adapter_params_[adjusted_base_name]["adapter_A"] = std::move(params);
-                LOGI("Found adapter_A param: %s", adapter_name.c_str());
-            } catch (const std::exception& e) {
-                LOGW("Parameter not found or error extracting adapter_A for %s: %s", adapter_name.c_str(), e.what());
-            }
-        }
-    }
-}
-
-// Load ONNX merger models
-bool WeightMerger::load_merger_models(const std::string& models_directory) {
-    LOGI("Loading merger models from: %s", models_directory.c_str());
-
-    try {
-        // Load LoRA merger model (full precision)
-        std::string lora_model_path = models_directory + "/lora_merger_model.onnx";
-        merger_sessions_["lora"] = std::make_unique<Ort::Session>(
-                Ort::Env(), lora_model_path.c_str(), Ort::SessionOptions{}
-        );
-        LOGI("Loaded LoRA merger model");
-
-        // Load LoRA quantized merger model
-        std::string lora_q_model_path = models_directory + "/lora_qmerger_model.onnx";
-        merger_sessions_["lora_q"] = std::make_unique<Ort::Session>(
-                Ort::Env(), lora_q_model_path.c_str(), Ort::SessionOptions{}
-        );
-        LOGI("Loaded LoRA quantized merger model");
-
-        // Load MARS quantized merger model
-        std::string mars_q_model_path = models_directory + "/mars_qmerger_model.onnx";
-        merger_sessions_["mars_q"] = std::make_unique<Ort::Session>(
-                Ort::Env(), mars_q_model_path.c_str(), Ort::SessionOptions{}
-        );
-        LOGI("Loaded MARS quantized merger model");
-
-        return true;
-    } catch (const std::exception& e) {
-        LOGE("Error loading merger models: %s", e.what());
-        return false;
-    }
-}
-
-// Determine the appropriate merger type based on available parameters
-std::string WeightMerger::get_merger_type(const std::string& base_layer_name) {
-    auto adapter_it = adapter_params_.find(base_layer_name);
-    if (adapter_it == adapter_params_.end()) {
-        return "";
-    }
-
-    auto& adapters = adapter_it->second;
-    bool has_shared_A = adapters.find("shared_A") != adapters.end();
-    bool has_adapter_A = adapters.find("adapter_A") != adapters.end();
-    bool has_quantized = base_layer_params_[base_layer_name].has_quantized;
-
-    if (has_shared_A && has_quantized) {
-        return "mars_q";  // MARS with quantized weights
-    } else if (has_adapter_A && has_quantized) {
-        return "lora_q";  // LoRA with quantized weights
-    } else if (has_adapter_A && !has_quantized) {
-        return "lora";    // LoRA with full precision weights
-    }
-        // TODO: Custom merger model?
-    else {
-        LOGW("Unable to determine merger type for: %s", base_layer_name.c_str());
-        return "";
-    }
-}
-
-void WeightMerger::run_merger_model(const std::string& merger_type, const std::string& base_layer_name) {
-    LOGI("Running %s merger for: %s", merger_type.c_str(), base_layer_name.c_str());
-
-    if (merger_sessions_.find(merger_type) == merger_sessions_.end()) {
-        LOGE("Merger model not found: %s", merger_type.c_str());
-        return;
-    }
-
-    try {
-        auto& session = merger_sessions_[merger_type];
-        auto& base_params = base_layer_params_[base_layer_name];
-        auto& adapter_params = adapter_params_[base_layer_name];
-
-        // Create parameter tracker
-        ParameterTracker tracker(base_layer_name);
-
-        // Prepare input tensors based on merger type
-        std::vector<Ort::Value> input_tensors;
-        std::vector<const char*> input_names;
-
-        // Storage for scalar values (must persist during inference)
-        float alpha_value = peft_mapping_[base_layer_name].alpha;
-        int64_t adapter_index_value = peft_mapping_[base_layer_name].adapter_index;
-        int64_t rank_value = peft_mapping_[base_layer_name].rank;
-
-        if (merger_type == "lora") {
-            // LoRA merger inputs: base_weight, adapter_A, adapter_B, alpha
-            if (!base_params.weight) {
-                LOGE("Missing base weight for LoRA merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.weight));
-            input_names.push_back("weight");
-            tracker.used_base_params.push_back("weight");
-
-            if (adapter_params.find("adapter_A") == adapter_params.end() ||
-                !adapter_params["adapter_A"].data) {
-                LOGE("Missing adapter_A for LoRA merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["adapter_A"].data));
-            input_names.push_back("adapter_A");
-            tracker.used_adapter_params.push_back("adapter_A");
-
-            if (adapter_params.find("adapter_B") == adapter_params.end() ||
-                !adapter_params["adapter_B"].data) {
-                LOGE("Missing adapter_B for LoRA merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
-            input_names.push_back("adapter_B");
-            tracker.used_adapter_params.push_back("adapter_B");
-
-            // Create alpha tensor with persistent memory
-            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-            std::vector<int64_t> scalar_shape = {};
-            auto alpha_tensor = Ort::Value::CreateTensor<float>(
-                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
-            input_tensors.push_back(std::move(alpha_tensor));
-            input_names.push_back("alpha");
-
-        } else if (merger_type == "lora_q") {
-            // LoRA quantized merger inputs
-            if (!base_params.weight_quantized) {
-                LOGE("Missing quantized weight for LoRA quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.weight_quantized));
-            input_names.push_back("weight_quantized");
-            tracker.used_base_params.push_back("weight_quantized");
-
-            if (!base_params.x_scale) {
-                LOGE("Missing x_scale for LoRA quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.x_scale));
-            input_names.push_back("x_scale");
-            tracker.used_base_params.push_back("x_scale");
-
-            if (!base_params.x_zero_point) {
-                LOGE("Missing x_zero_point for LoRA quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.x_zero_point));
-            input_names.push_back("x_zero_point");
-            tracker.used_base_params.push_back("x_zero_point");
-
-            if (adapter_params.find("adapter_A") == adapter_params.end() ||
-                !adapter_params["adapter_A"].data) {
-                LOGE("Missing adapter_A for LoRA quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["adapter_A"].data));
-            input_names.push_back("adapter_A");
-            tracker.used_adapter_params.push_back("adapter_A");
-
-            if (adapter_params.find("adapter_B") == adapter_params.end() ||
-                !adapter_params["adapter_B"].data) {
-                LOGE("Missing adapter_B for LoRA quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
-            input_names.push_back("adapter_B");
-            tracker.used_adapter_params.push_back("adapter_B");
-
-            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-            std::vector<int64_t> scalar_shape = {};
-            auto alpha_tensor = Ort::Value::CreateTensor<float>(
-                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
-            input_tensors.push_back(std::move(alpha_tensor));
-            input_names.push_back("alpha");
-
-        } else if (merger_type == "mars_q") {
-            // MARS quantized merger inputs
-            if (!base_params.weight_quantized) {
-                LOGE("Missing quantized weight for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.weight_quantized));
-            input_names.push_back("weight_quantized");
-            tracker.used_base_params.push_back("weight_quantized");
-
-            if (!base_params.x_scale) {
-                LOGE("Missing x_scale for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.x_scale));
-            input_names.push_back("x_scale");
-            tracker.used_base_params.push_back("x_scale");
-
-            if (!base_params.x_zero_point) {
-                LOGE("Missing x_zero_point for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*base_params.x_zero_point));
-            input_names.push_back("x_zero_point");
-            tracker.used_base_params.push_back("x_zero_point");
-
-            if (adapter_params.find("shared_A") == adapter_params.end() ||
-                !adapter_params["shared_A"].data) {
-                LOGE("Missing shared_A for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["shared_A"].data));
-            input_names.push_back("shared_A");
-            tracker.used_adapter_params.push_back("shared_A");
-
-            if (adapter_params.find("adapter_B") == adapter_params.end() ||
-                !adapter_params["adapter_B"].data) {
-                LOGE("Missing adapter_B for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["adapter_B"].data));
-            input_names.push_back("adapter_B");
-            tracker.used_adapter_params.push_back("adapter_B");
-
-            if (adapter_params.find("intermediate") == adapter_params.end() ||
-                !adapter_params["intermediate"].data) {
-                LOGE("Missing intermediate for MARS quantized merger");
-                return;
-            }
-            input_tensors.push_back(std::move(*adapter_params["intermediate"].data));
-            input_names.push_back("intermediate");
-            tracker.used_adapter_params.push_back("intermediate");
-
-            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-            std::vector<int64_t> scalar_shape = {};
-
-            auto alpha_tensor = Ort::Value::CreateTensor<float>(
-                    memory_info, &alpha_value, 1, scalar_shape.data(), scalar_shape.size());
-            input_tensors.push_back(std::move(alpha_tensor));
-            input_names.push_back("alpha");
-
-            auto adapter_index_tensor = Ort::Value::CreateTensor<int64_t>(
-                    memory_info, &adapter_index_value, 1, scalar_shape.data(), scalar_shape.size());
-            input_tensors.push_back(std::move(adapter_index_tensor));
-            input_names.push_back("adapter_index");
-
-            auto rank_tensor = Ort::Value::CreateTensor<int64_t>(
-                    memory_info, &rank_value, 1, scalar_shape.data(), scalar_shape.size());
-            input_tensors.push_back(std::move(rank_tensor));
-            input_names.push_back("rank");
-        }
-
-        // Get output names
-        std::vector<const char*> output_names;
-        if (merger_type == "lora") {
-            output_names.push_back("merged_weight");
-        } else { // lora_q or mars_q
-            output_names.push_back("merged_weight_quantized");
-            output_names.push_back("merged_zero_point");
-            output_names.push_back("merged_scale");
-        }
-
-        // Run inference
-        std::vector<Ort::Value> output_tensors = session->Run(
-                Ort::RunOptions{nullptr},
-                input_names.data(),
-                input_tensors.data(),
-                input_tensors.size(),
-                output_names.data(),
-                output_names.size()
-        );
-
-        // Store outputs BEFORE freeing input memory
-        MergedOutput output;
-        if (merger_type == "lora") {
-            output.has_weight = true;
-            auto [output_tensor, buffer] = CreateUserManagedCopy(output_tensors[0]);
-            output.merged_weight_buffer = buffer;
-            output.merged_weight = std::move(output_tensor);
-        } else { // lora_q or mars_q
-            output.has_quantized = true;
-            auto [output_tensor, buffer] = CreateUserManagedCopy(output_tensors[0]);
-            output.merged_weight_quantized_buffer = buffer;
-            output.merged_weight_quantized = std::move(output_tensor);
-
-            auto [output_tensor1, buffer1] = CreateUserManagedCopy(output_tensors[1]);
-            output.merged_zero_point_buffer = buffer1;
-            output.merged_zero_point = std::move(output_tensor1);
-
-            auto [output_tensor2, buffer2] = CreateUserManagedCopy(output_tensors[2]);
-            output.merged_scale_buffer = buffer2;
-            output.merged_scale = std::move(output_tensor2);
-        }
-
-        // Store the merged output
-        merged_outputs_[base_layer_name] = std::move(output);
-
-        // Now free the used parameters
-        free_used_parameters(tracker);
-
-        // Clear input and output tensors
-        input_tensors.clear();
-        output_tensors.clear();
-
-        LOGI("Completed %s merger for: %s", merger_type.c_str(), base_layer_name.c_str());
-
-    } catch (const std::exception& e) {
-        LOGE("Error running merger model %s for %s: %s", merger_type.c_str(), base_layer_name.c_str(), e.what());
-    }
-}
-
-// Add this method to your WeightMerger class
-void WeightMerger::free_used_parameters(const ParameterTracker& tracker) {
-    //LOGI("Freeing used parameters for layer: %s", tracker.base_layer_name.c_str());
-
-    // Free base layer parameters that were used
-    auto base_it = base_layer_params_.find(tracker.base_layer_name);
-    if (base_it != base_layer_params_.end()) {
-        auto& base_params = base_it->second;
-
-        for (const auto& param_name : tracker.used_base_params) {
-            if (param_name == "weight_quantized" && base_params.weight_quantized_buffer) {
-                //LOGI("Freeing base weight_quantized buffer");
-                allocator_.Free(base_params.weight_quantized_buffer);
-                base_params.weight_quantized_buffer = nullptr;
-                base_params.weight_quantized.reset();
-            }
-            else if (param_name == "x_scale" && base_params.x_scale_buffer) {
-                //LOGI("Freeing base x_scale buffer");
-                allocator_.Free(base_params.x_scale_buffer);
-                base_params.x_scale_buffer = nullptr;
-                base_params.x_scale.reset();
-            }
-            else if (param_name == "x_zero_point" && base_params.x_zero_point_buffer) {
-                //LOGI("Freeing base x_zero_point buffer");
-                allocator_.Free(base_params.x_zero_point_buffer);
-                base_params.x_zero_point_buffer = nullptr;
-                base_params.x_zero_point.reset();
-            }
-            else if (param_name == "weight" && base_params.weight_buffer) {
-                //LOGI("Freeing base weight buffer");
-                allocator_.Free(base_params.weight_buffer);
-                base_params.weight_buffer = nullptr;
-                base_params.weight.reset();
-            }
-        }
-    }
-
-    // Free adapter parameters that were used
-    auto adapter_it = adapter_params_.find(tracker.base_layer_name);
-    if (adapter_it != adapter_params_.end()) {
-        auto& adapter_map = adapter_it->second;
-
-        for (const auto& param_name : tracker.used_adapter_params) {
-            auto param_it = adapter_map.find(param_name);
-            if (param_it != adapter_map.end() && param_it->second.raw_buffer) {
-                //LOGI("Freeing adapter %s buffer", param_name.c_str());
-                allocator_.Free(param_it->second.raw_buffer);
-                param_it->second.raw_buffer = nullptr;
-                param_it->second.data.reset();
-                // Remove the empty adapter parameter entry
-                adapter_map.erase(param_it);
-            }
-        }
-
-        // If no more adapter parameters for this layer, remove the entire entry
-        if (adapter_map.empty()) {
-            adapter_params_.erase(adapter_it);
-        }
-    }
-}
-
-
-// Helper function to convert OrtValue to vector for saving
-template<typename T>
-std::vector<T> WeightMerger::ortvalue_to_vector(const Ort::Value& tensor) {
-    const T* data = tensor.GetTensorData<T>();
-    size_t size = tensor.GetTensorTypeAndShapeInfo().GetElementCount();
-    return std::vector<T>(data, data + size);
-}
-
-// Save merged parameters using OrtValueSerializer
-void WeightMerger::save_merged_parameters(const std::string& output_directory) {
-    LOGI("Saving merged parameters to: %s", output_directory.c_str());
-
-    // Create output directory if it doesn't exist
-    std::filesystem::create_directories(output_directory);
-
-    int z = 0;
-
-    for (auto& [base_layer_name, output] : merged_outputs_) {
-        try {
-            // Create safe filename by replacing invalid characters
-            std::string safe_name = inference_name(base_layer_name);
-
-            if (output.has_quantized) {
-                // Save quantized weights in a subdirectory
-                std::string quant_dir = output_directory + "/" + safe_name;
-                std::filesystem::create_directories(quant_dir);
-
-                // Save quantized weight
-                if (output.merged_weight_quantized) {
-                    std::string quant_file = quant_dir + "/weight_quantized.tensor";
-
-                    if (!OrtValueSerializer::save_tensor(quant_file, *output.merged_weight_quantized,
-                                                         safe_name + ".weight_quantized")) {
-                        LOGE("Failed to save quantized weight for %s", base_layer_name.c_str());
-                    }
-                }
-
-                // Save zero point
-                if (output.merged_zero_point) {
-                    std::string zero_point_file = quant_dir + "/weight_zero_point.tensor";
-                    if (!OrtValueSerializer::save_tensor(zero_point_file, *output.merged_zero_point,
-                                                         safe_name + ".weight_zero_point")) {
-                        LOGE("Failed to save zero point for %s", base_layer_name.c_str());
-                    }
-                }
-
-                // Save scale
-                if (output.merged_scale) {
-                    std::string scale_file = quant_dir + "/weight_scale.tensor";
-                    if (!OrtValueSerializer::save_tensor(scale_file, *output.merged_scale,
-                                                         base_layer_name + ".weight_scale")) {
-                        LOGE("Failed to save scale for %s", base_layer_name.c_str());
-                    }
-                }
-
-                // Free quantized buffers
-                if (output.merged_weight_quantized_buffer) {
-                    allocator_.Free(output.merged_weight_quantized_buffer);
-                    output.merged_weight_quantized_buffer = nullptr;
-                }
-                if (output.merged_zero_point_buffer) {
-                    allocator_.Free(output.merged_zero_point_buffer);
-                    output.merged_zero_point_buffer = nullptr;
-                }
-                if (output.merged_scale_buffer) {
-                    allocator_.Free(output.merged_scale_buffer);
-                    output.merged_scale_buffer = nullptr;
-                }
-                output.merged_weight_quantized.reset();
-                output.merged_zero_point.reset();
-                output.merged_scale.reset();
-
-            } else if (output.has_weight) {
-                // Save regular weight
-                if (output.merged_weight) {
-                    std::string weight_file = output_directory + "/" + safe_name + ".tensor";
-                    if (OrtValueSerializer::save_tensor(weight_file, *output.merged_weight, base_layer_name)) {
-                        LOGI("Saved weight for %s to %s", base_layer_name.c_str(), weight_file.c_str());
-                    } else {
-                        LOGE("Failed to save weight for %s", base_layer_name.c_str());
-                    }
-                }
-
-                // Free weight buffer
-                if (output.merged_weight_buffer) {
-                    allocator_.Free(output.merged_weight_buffer);
-                    output.merged_weight_buffer = nullptr;
-                }
-                output.merged_weight.reset();
-            }
-
-        } catch (const std::exception& e) {
-            LOGE("Error saving parameters for layer %s: %s", base_layer_name.c_str(), e.what());
-        }
-    }
-}
-
-// Helper function to create correct tensor names for inference initializers
-std::string WeightMerger::inference_name(const std::string& layer_name) {
-    std::string result = layer_name;
-
-    // Remove "backbone." prefix if present
-    if (result.find("backbone.") == 0) {
-        result = result.substr(9); // Remove "backbone."
-    }
-
-    // Replace "self_attn" with "attn"
-    size_t pos = result.find("self_attn");
-    if (pos != std::string::npos) {
-        result.replace(pos, 9, "attn"); // "self_attn" is 9 characters
-    }
-
-    // Replace "base_layer" with "MatMul.weight"
-    pos = result.find("base_layer");
-    if (pos != std::string::npos) {
-        result.replace(pos, 10, "MatMul"); // "base_layer" is 10 characters
-    }
-
-    return result;
-}
-
-
-
-// Main method to perform weight merging
-bool WeightMerger::merge_and_export_weights(Ort::CheckpointState& checkpoint_state,
-                              const std::string& peft_mapping_path,
-                              const std::string& merger_models_directory,
-                              const std::string& output_directory) {
-    LOGI("Starting weight merging process...");
-
-    // Load PEFT mapping
-    if (!load_peft_mapping(peft_mapping_path)) {
-        LOGE("Failed to load PEFT mapping");
-        return false;
-    }
-
-    // Load merger models
-    if (!load_merger_models(merger_models_directory)) {
-        LOGE("Failed to load merger models");
-        return false;
-    }
-
-    // Extract parameters from checkpoint
-    extract_base_layer_params(checkpoint_state);
-    extract_adapter_params(checkpoint_state);
-
-    // Process each base layer
-    for (const auto& [base_layer_name, mapping] : peft_mapping_) {
-        std::string adjusted_name = replace_prefix(base_layer_name, "base_model.model.model.", "backbone.model.");
-
-        // Determine appropriate merger type
-        std::string merger_type = get_merger_type(adjusted_name);
-        if (merger_type.empty()) {
-            LOGW("Skipping layer due to unknown merger type: %s", adjusted_name.c_str());
-            continue;
-        }
-
-        // Run the appropriate merger
-        run_merger_model(merger_type, adjusted_name);
-    }
-
-    // Save merged parameters
-    save_merged_parameters(output_directory);
-
-    LOGI("Weight merging process completed successfully");
-    return true;
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.cpp b/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.cpp
deleted file mode 100644
index bdbfd1c..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.cpp
+++ /dev/null
@@ -1,563 +0,0 @@
-//
-// Created by martin on 17. 07. 25.
-//
-
-
-#include <fstream>
-#include <iostream>
-#include <cstring>
-#include "weight_serializer.h"
-
-// Implementation
-
-bool OrtValueSerializer::save_tensor(const std::string& filepath, const Ort::Value& tensor, const std::string& tensor_name) {
-    try {
-        // Convert OrtValue to TensorProto
-        onnx::TensorProto tensor_proto = ortvalue_to_tensorproto(tensor, tensor_name);
-
-        // Write to file
-        std::ofstream file(filepath, std::ios::binary);
-        if (!file.is_open()) {
-            return false;
-        }
-
-        bool success = tensor_proto.SerializeToOstream(&file);
-        file.close();
-        return success;
-
-    } catch (const std::exception& e) {
-        return false;
-    }
-}
-
-std::unique_ptr<Ort::Value> OrtValueSerializer::load_tensor(const std::string& filepath) {
-    try {
-        // Read from file
-        std::ifstream file(filepath, std::ios::binary);
-        if (!file.is_open()) {
-            throw std::runtime_error("Failed to open file: " + filepath);
-        }
-
-        onnx::TensorProto tensor_proto;
-        if (!tensor_proto.ParseFromIstream(&file)) {
-            file.close();
-            throw std::runtime_error("Failed to parse TensorProto from file: " + filepath);
-        }
-        file.close();
-
-        // Convert TensorProto to OrtValue
-        return tensorproto_to_ortvalue(tensor_proto);
-
-    } catch (const std::exception& e) {
-        throw std::runtime_error("Error loading tensor: " + std::string(e.what()));
-    }
-}
-
-bool OrtValueSerializer::is_valid_tensor_file(const std::string& filepath) {
-    try {
-        std::ifstream file(filepath, std::ios::binary);
-        if (!file.is_open()) {
-            return false;
-        }
-
-        onnx::TensorProto tensor_proto;
-        bool valid = tensor_proto.ParseFromIstream(&file);
-        file.close();
-        return valid;
-
-    } catch (const std::exception& e) {
-        return false;
-    }
-}
-
-onnx::TensorProto OrtValueSerializer::ortvalue_to_tensorproto(const Ort::Value& value, const std::string& name) {
-    onnx::TensorProto tensor_proto;
-
-    // Set name if provided
-    if (!name.empty()) {
-        tensor_proto.set_name(name);
-    }
-
-    // Get shape and set dimensions
-    auto tensor_info = value.GetTensorTypeAndShapeInfo();
-    auto shape = tensor_info.GetShape();
-    for (auto dim : shape) {
-        tensor_proto.add_dims(dim);
-    }
-
-    // Get element type
-    ONNXTensorElementDataType element_type = tensor_info.GetElementType();
-
-    // Set data type and copy data
-    switch (element_type) {
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT: {
-            tensor_proto.set_data_type(onnx::TensorProto::FLOAT);
-            auto data_vec = ortvalue_to_vector<float>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(float));
-            break;
-        }
-
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8: {
-            tensor_proto.set_data_type(onnx::TensorProto::INT8);
-            auto data_vec = ortvalue_to_vector<int8_t>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(int8_t));
-            break;
-        }
-
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8: {
-            tensor_proto.set_data_type(onnx::TensorProto::UINT8);
-            auto data_vec = ortvalue_to_vector<uint8_t>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(uint8_t));
-            break;
-        }
-
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32: {
-            tensor_proto.set_data_type(onnx::TensorProto::INT32);
-            auto data_vec = ortvalue_to_vector<int32_t>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(int32_t));
-            break;
-        }
-
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64: {
-            tensor_proto.set_data_type(onnx::TensorProto::INT64);
-            auto data_vec = ortvalue_to_vector<int64_t>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(int64_t));
-            break;
-        }
-
-        case ONNX_TENSOR_ELEMENT_DATA_TYPE_DOUBLE: {
-            tensor_proto.set_data_type(onnx::TensorProto::DOUBLE);
-            auto data_vec = ortvalue_to_vector<double>(value);
-            tensor_proto.set_raw_data(data_vec.data(), data_vec.size() * sizeof(double));
-            break;
-        }
-
-        default:
-            throw std::runtime_error("Unsupported tensor element type: " + std::to_string(element_type));
-    }
-
-    return tensor_proto;
-}
-
-
-std::unique_ptr<Ort::Value> OrtValueSerializer::tensorproto_to_ortvalue(const onnx::TensorProto& tensor) {
-    // Get shape
-    std::vector<int64_t> shape;
-    for (int i = 0; i < tensor.dims_size(); ++i) {
-        shape.push_back(tensor.dims(i));
-    }
-
-    // Calculate total size
-    size_t total_size = 1;
-    for (auto dim : shape) {
-        total_size *= dim;
-    }
-
-    // Create memory info for CPU
-    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-
-    // Handle different data types
-    switch (tensor.data_type()) {
-        case onnx::TensorProto::FLOAT: {
-            // Create vector to hold the data (RAII managed)
-            std::vector<float> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(float)) {
-                    throw std::runtime_error("Raw data size mismatch for FLOAT tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.float_data_size() != total_size) {
-                    throw std::runtime_error("Float data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = tensor.float_data(i);
-                }
-            }
-
-            // Create tensor with data copy - ORT will manage memory internally
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<float>(memory_info, data_vec.data(), total_size,
-                                                    shape.data(), shape.size())
-            );
-        }
-
-        case onnx::TensorProto::INT8: {
-            std::vector<int8_t> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(int8_t)) {
-                    throw std::runtime_error("Raw data size mismatch for INT8 tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    throw std::runtime_error("Int8 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = static_cast<int8_t>(tensor.int32_data(i));
-                }
-            }
-
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<int8_t>(memory_info, data_vec.data(), total_size,
-                                                     shape.data(), shape.size())
-            );
-        }
-
-        case onnx::TensorProto::UINT8: {
-            std::vector<uint8_t> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(uint8_t)) {
-                    throw std::runtime_error("Raw data size mismatch for UINT8 tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    throw std::runtime_error("Uint8 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = static_cast<uint8_t>(tensor.int32_data(i));
-                }
-            }
-
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<uint8_t>(memory_info, data_vec.data(), total_size,
-                                                      shape.data(), shape.size())
-            );
-        }
-
-        case onnx::TensorProto::INT32: {
-            std::vector<int32_t> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(int32_t)) {
-                    throw std::runtime_error("Raw data size mismatch for INT32 tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    throw std::runtime_error("Int32 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = tensor.int32_data(i);
-                }
-            }
-
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<int32_t>(memory_info, data_vec.data(), total_size,
-                                                      shape.data(), shape.size())
-            );
-        }
-
-        case onnx::TensorProto::INT64: {
-            std::vector<int64_t> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(int64_t)) {
-                    throw std::runtime_error("Raw data size mismatch for INT64 tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int64_data_size() != total_size) {
-                    throw std::runtime_error("Int64 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = tensor.int64_data(i);
-                }
-            }
-
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<int64_t>(memory_info, data_vec.data(), total_size,
-                                                      shape.data(), shape.size())
-            );
-        }
-
-        case onnx::TensorProto::DOUBLE: {
-            std::vector<double> data_vec(total_size);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != total_size * sizeof(double)) {
-                    throw std::runtime_error("Raw data size mismatch for DOUBLE tensor");
-                }
-                std::memcpy(data_vec.data(), raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.double_data_size() != total_size) {
-                    throw std::runtime_error("Double data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data_vec[i] = tensor.double_data(i);
-                }
-            }
-
-            return std::make_unique<Ort::Value>(
-                    Ort::Value::CreateTensor<double>(memory_info, data_vec.data(), total_size,
-                                                     shape.data(), shape.size())
-            );
-        }
-
-        default:
-            throw std::runtime_error("Unsupported tensor data type: " + std::to_string(tensor.data_type()));
-    }
-}
-
-
-std::pair<Ort::Value, void*> OrtValueSerializer::tensorproto_to_ortvalue_with_allocator(
-        const onnx::TensorProto& tensor,
-        Ort::MemoryInfo& memory_info_,
-        Ort::AllocatorWithDefaultOptions& allocator_) {
-
-    // Get shape
-    std::vector<int64_t> shape;
-    for (int i = 0; i < tensor.dims_size(); ++i) {
-        shape.push_back(tensor.dims(i));
-    }
-
-    // Calculate total size
-    size_t total_size = 1;
-    for (auto dim : shape) {
-        total_size *= dim;
-    }
-
-    void* buffer_ptr = nullptr;
-    Ort::Value ort_value{nullptr};
-
-    // Handle different data types
-    switch (tensor.data_type()) {
-        case onnx::TensorProto::FLOAT: {
-            size_t data_size = total_size * sizeof(float);
-            buffer_ptr = allocator_.Alloc(data_size);
-            float* data = static_cast<float*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for FLOAT tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.float_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Float data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = tensor.float_data(i);
-                }
-            }
-
-            // Create tensor with user-managed data
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create FLOAT tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        case onnx::TensorProto::INT8: {
-            size_t data_size = total_size * sizeof(int8_t);
-            buffer_ptr = allocator_.Alloc(data_size);
-            int8_t* data = static_cast<int8_t*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for INT8 tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Int8 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = static_cast<int8_t>(tensor.int32_data(i));
-                }
-            }
-
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create INT8 tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        case onnx::TensorProto::UINT8: {
-            size_t data_size = total_size * sizeof(uint8_t);
-            buffer_ptr = allocator_.Alloc(data_size);
-            uint8_t* data = static_cast<uint8_t*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for UINT8 tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Uint8 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = static_cast<uint8_t>(tensor.int32_data(i));
-                }
-            }
-
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create UINT8 tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        case onnx::TensorProto::INT32: {
-            size_t data_size = total_size * sizeof(int32_t);
-            buffer_ptr = allocator_.Alloc(data_size);
-            int32_t* data = static_cast<int32_t*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for INT32 tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int32_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Int32 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = tensor.int32_data(i);
-                }
-            }
-
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create INT32 tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        case onnx::TensorProto::INT64: {
-            size_t data_size = total_size * sizeof(int64_t);
-            buffer_ptr = allocator_.Alloc(data_size);
-            int64_t* data = static_cast<int64_t*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for INT64 tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.int64_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Int64 data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = tensor.int64_data(i);
-                }
-            }
-
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create INT64 tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        case onnx::TensorProto::DOUBLE: {
-            size_t data_size = total_size * sizeof(double);
-            buffer_ptr = allocator_.Alloc(data_size);
-            double* data = static_cast<double*>(buffer_ptr);
-
-            if (tensor.has_raw_data()) {
-                const std::string& raw_data = tensor.raw_data();
-                if (raw_data.size() != data_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Raw data size mismatch for DOUBLE tensor");
-                }
-                std::memcpy(data, raw_data.data(), raw_data.size());
-            } else {
-                if (tensor.double_data_size() != total_size) {
-                    allocator_.Free(buffer_ptr);
-                    throw std::runtime_error("Double data size mismatch");
-                }
-                for (size_t i = 0; i < total_size; ++i) {
-                    data[i] = tensor.double_data(i);
-                }
-            }
-
-            try {
-                ort_value = Ort::Value::CreateTensor(
-                        memory_info_,
-                        buffer_ptr,
-                        data_size,
-                        shape.data(),
-                        shape.size(),
-                        ONNX_TENSOR_ELEMENT_DATA_TYPE_DOUBLE);
-            } catch (const std::exception& e) {
-                allocator_.Free(buffer_ptr);
-                throw std::runtime_error("Failed to create DOUBLE tensor: " + std::string(e.what()));
-            }
-            break;
-        }
-
-        default:
-            throw std::runtime_error("Unsupported tensor data type: " + std::to_string(tensor.data_type()));
-    }
-
-    return std::make_pair(std::move(ort_value), buffer_ptr);
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.h b/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.h
deleted file mode 100644
index 181df25..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/cpp/weight_serializer.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Created by martin on 17. 07. 25.
-//
-
-#ifndef ORTTRANSFORMER_WEIGHT_SERIALIZER_H
-#define ORTTRANSFORMER_WEIGHT_SERIALIZER_H
-
-#include <onnxruntime_training_cxx_api.h>
-#include <string>
-#include <vector>
-#include <memory>
-#include <fstream>
-#include <stdexcept>
-#include <cstring>
-#include "proto/onnx.pb.h"
-
-class OrtValueSerializer {
-public:
-    static bool save_tensor(const std::string& filepath, const Ort::Value& tensor, const std::string& tensor_name = "");
-    static std::unique_ptr<Ort::Value> load_tensor(const std::string& filepath);
-    static bool is_valid_tensor_file(const std::string& filepath);
-
-    static std::pair<Ort::Value, void*>  tensorproto_to_ortvalue_with_allocator(
-            const onnx::TensorProto& tensor,
-            Ort::MemoryInfo& memory_info_,
-            Ort::AllocatorWithDefaultOptions& allocator_);
-
-private:
-    static onnx::TensorProto ortvalue_to_tensorproto(const Ort::Value& value, const std::string& name);
-    static std::unique_ptr<Ort::Value> tensorproto_to_ortvalue(const onnx::TensorProto& tensor);
-
-    template<typename T>
-    static std::vector<T> ortvalue_to_vector(const Ort::Value& value) {
-        auto tensor_info = value.GetTensorTypeAndShapeInfo();
-        auto shape = tensor_info.GetShape();
-
-        size_t element_count = 1;
-        for (auto dim : shape) {
-            element_count *= dim;
-        }
-
-        const T* data = value.GetTensorData<T>();
-        return std::vector<T>(data, data + element_count);
-    }
-};
-
-#endif //ORTTRANSFORMER_WEIGHT_SERIALIZER_H
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/DataUtil.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/DataUtil.kt
deleted file mode 100644
index 8143a2e..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/DataUtil.kt
+++ /dev/null
@@ -1,167 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import org.json.JSONObject
-
-class DataCollatorForSupervisedDataset(private val tokenizer: ORTTokenizerNative) {
-
-    fun collate(batch: List<ORTDataCurator.TrainingSample>): CollatedBatch {
-        val padToken = tokenizer.padToken
-        val padLabel = -100
-
-        val maxLength = batch.maxOf { it.inputIds.size }
-
-        val inputIdsPadded = batch.map { sample ->
-            val padded = sample.inputIds + List(maxLength - sample.inputIds.size) { padToken }
-            padded.map { it?.toLong() ?: 0 }.toLongArray()
-        }
-
-        val labelsPadded = batch.map { sample ->
-            val padded = sample.labels + List(maxLength - sample.labels.size) { padLabel }
-            padded.map { it.toLong() }.toLongArray()
-        }
-
-        // Create attention mask: 1 for non-pad tokens, 0 for pad tokens
-        val attentionMaskPadded = batch.map { sample ->
-            // Original tokens get attention (1), padded tokens don't (0)
-            val originalLength = sample.inputIds.size
-            val paddingLength = maxLength - originalLength
-
-            val attentionMask = List(originalLength) { 1L } + List(paddingLength) { 0L }
-            attentionMask.toLongArray()
-        }
-
-        return CollatedBatch(
-            inputIds = inputIdsPadded.toTypedArray(),
-            labels = labelsPadded.toTypedArray(),
-            attentionMask = attentionMaskPadded.toTypedArray(),
-            sequenceLength = maxLength,
-            batchSize = batch.size
-        )
-    }
-
-    data class CollatedBatch(
-        val inputIds: Array<LongArray>,
-        val labels: Array<LongArray>,
-        val attentionMask: Array<LongArray>,
-        val sequenceLength: Int,
-        val batchSize: Int
-    )
-}
-
-// Interface for preprocessing functions
-interface TaskPreprocessor {
-    fun preprocess(json: JSONObject): Pair<String, String>
-}
-
-// Factory function using the interface
-fun getPreprocessFunctionForTask(
-    taskName: String,
-    customPreprocess: TaskPreprocessor? = null
-): TaskPreprocessor {
-    if (customPreprocess != null) {
-        return customPreprocess
-    }
-
-    return when (taskName.lowercase()) {
-        "logiqa" -> LogiqaPreprocessor
-        "boolq" -> BoolqPreprocessor
-        "mini_personalqa" -> MiniPersonalQAPreprocessor
-        "mini_recommendation" -> MiniRecommendationPreprocessor
-        "cola" -> CoLAPreprocessor
-        else -> throw IllegalArgumentException("Unsupported task: $taskName. Please provide a customPreprocess function.")
-    }
-}
-
-// Concrete implementations
-object LogiqaPreprocessor : TaskPreprocessor {
-    override fun preprocess(json: JSONObject): Pair<String, String> {
-        val labelMap = mapOf(0 to "A", 1 to "B", 2 to "C", 3 to "D")
-
-        val article = json.optString("text", "")
-        val question = json.optString("question", "")
-        val optionsArray = json.optJSONArray("options")
-        val answer = json.optInt("answer", -1)
-
-        var options = ""
-        if (optionsArray != null) {
-            for (i in 0 until optionsArray.length()) {
-                val option = optionsArray.optString(i, "")
-                options += "${labelMap[i]} $option\n"
-            }
-        }
-
-        val input = "Write a multi-choice question for the following article:\n" +
-                "Article: $article\n" +
-                "Question: $question\n" +
-                "Options: $options" +
-                "Answer: \n\n "
-
-        val label = labelMap[answer] ?: ""
-
-        return input to label
-    }
-}
-
-object BoolqPreprocessor : TaskPreprocessor {
-    override fun preprocess(json: JSONObject): Pair<String, String> {
-        val question = json.optString("question", "")
-        val passage = json.optString("passage", "")
-        val answer = json.optString("answer", "")
-
-        val input = "Q: $question?\nP: $passage\nA: \n\n "
-
-        return input to answer
-    }
-}
-
-object MiniPersonalQAPreprocessor : TaskPreprocessor {
-    override fun preprocess(json: JSONObject): Pair<String, String> {
-        val questionText = json.optString("question", "")
-        val choicesObject = json.optJSONObject("choices")
-        val correctAnswer = json.optString("correct_answer", "")
-
-        // Build the formatted question
-        var formatted = "Question: $questionText\n\n"
-
-        if (choicesObject != null) {
-            val keys = choicesObject.keys()
-            while (keys.hasNext()) {
-                val choiceKey = keys.next()
-                val choiceValue = choicesObject.optString(choiceKey, "")
-                formatted += "$choiceKey: $choiceValue\n"
-            }
-        }
-
-        val input = formatted + "\n\nAnswer: "
-        val label = correctAnswer
-
-        return input to label
-    }
-}
-
-object MiniRecommendationPreprocessor : TaskPreprocessor {
-    override fun preprocess(json: JSONObject): Pair<String, String> {
-        val userQuery = json.optString("prompt", "")
-        val recommendation = json.optString("recommendation", "")
-
-        val formatted = "Recommend best actions based on this user query: $userQuery"
-
-        val input = formatted + "\n\nAnswer: "
-
-        val label = recommendation
-
-        return input to label
-    }
-}
-
-object CoLAPreprocessor : TaskPreprocessor {
-    override fun preprocess(json: JSONObject): Pair<String, String> {
-        val sentence = json.optString("sentence", "")
-        val label = json.optInt("label", 0)
-
-        val input = "Is this sentence grammatically acceptable? $sentence\nA: "
-        val output = if (label == 1) "acceptable" else "unacceptable"
-
-        return input to output
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAINative.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAINative.kt
deleted file mode 100644
index 944bc7f..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAINative.kt
+++ /dev/null
@@ -1,96 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import android.util.Log
-
-/**
- * ONNX Runtime GenAI class
- */
-@Deprecated("Unfinished and abandoned class, use ORTGeneratorNative")
-class ORTGenAINative(artifactDir : String, val genAIPath: String) {
-
-    private val LOG_TAG = "ORTGenAINative"
-
-    var genAIModel : Long = 0
-    var weightCache : Long = 0
-
-    var trainConfigPath : String = "${artifactDir}/training_config.json"
-
-    fun createGenAISessionFromTraining(trainModel: Long) {
-        Log.d(LOG_TAG, trainConfigPath)
-        val requiresGrad = loadTrainableLayerNamesJSON(trainConfigPath)
-
-        if (requiresGrad == null) {
-            Log.e(LOG_TAG, "No training config provided. GenAI model cannot be initialized.")
-        } else {
-            Log.d(LOG_TAG, "Loading the training model...")
-            weightCache = cacheSessionWeights(trainModel, requiresGrad)
-            Log.d(LOG_TAG, "Cached trainable weights, now loading GenAI model...")
-            genAIModel = createGenAISession(weightCache, genAIPath)
-            Log.d(LOG_TAG, "Successfully created GenAI model")
-        }
-
-    }
-
-    fun initializeGenerateStream(prompt: String) {
-        initializeGenAIInference(genAIModel, prompt)
-    }
-
-    fun generateStream() : String {
-        return performGenAIInferenceStep(genAIModel)
-    }
-
-    fun generate(prompt: String) : String {
-
-        if (genAIModel == 0L) {
-            Log.d(LOG_TAG, "GenAI model is not initialized yet. Have you initialized the model?")
-        }
-        Log.d(LOG_TAG, "Starting a new inference...")
-        // Initialize the GenAI inference session with the prompt
-        initializeGenAIInference(genAIModel, prompt)
-
-        var newToken = ""
-        var fullResults = ""
-
-        // Decode the tokens as you go
-        while (newToken != "[STOP]") {
-            newToken = performGenAIInferenceStep(genAIModel)
-            if (newToken != "[STOP]") {
-                fullResults += newToken
-            }
-            Log.d(LOG_TAG, fullResults)
-        }
-
-        return fullResults
-    }
-
-    fun destroySession() {
-        releaseGenAISession(genAIModel)
-        releaseWeightSession(weightCache)
-    }
-
-    // NOTE: This should have been external functions, but were deprecated due to incompatibility with ONNX GenAI framework
-
-    fun releaseWeightSession(weightCache: Long) {
-        throw NotImplementedError("releaseWeightSession not yet implemented")
-    }
-
-    fun releaseGenAISession(genModel: Long) {
-        throw NotImplementedError("releaseGenAISession not yet implemented")
-    }
-
-    fun initializeGenAIInference(genModel: Long, prompt: String) {
-        throw NotImplementedError("initializeGenAIInference not yet implemented")
-    }
-
-    fun performGenAIInferenceStep(genModel: Long): String {
-        throw NotImplementedError("performGenAIInferenceStep not yet implemented")
-    }
-
-    fun cacheSessionWeights(trainModel: Long, requiresGrad: Array<String>): Long {
-        throw NotImplementedError("cacheSessionWeights not yet implemented")
-    }
-
-    fun createGenAISession(weightCache: Long, genAIPath: String): Long {
-        throw NotImplementedError("createGenAISession not yet implemented")
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAITokenizer.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAITokenizer.kt
deleted file mode 100644
index 01eedb6..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGenAITokenizer.kt
+++ /dev/null
@@ -1,106 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import ai.onnxruntime.genai.Generator
-import ai.onnxruntime.genai.Model
-import ai.onnxruntime.genai.Tokenizer
-import android.util.Log
-import org.json.JSONObject
-import java.io.File
-
-/**
- * ONNX Runtime GenAI tokenizer class
- */
-@Deprecated("Unfinished and abandoned class, use ORTTokenizerNative")
-class ORTGenAITokenizer(folderPath: String) {
-
-    private var LOG_TAG = "ORTTokenizer"
-
-    private var model: Model = Model(folderPath)
-    private var tokenizer: Tokenizer = model.createTokenizer()
-    //private var generatorParams : GeneratorParams = model.createGeneratorParams()
-
-    var vocabSize: Int = 0
-    var eosToken: Int = 0
-    var padToken : Int = 0
-    private var modelType: String = ""
-
-    init {
-
-        val modelFields = readModelFieldsFromJson("${folderPath}/genai_config.json")
-        if (!modelFields) {
-            Log.e(LOG_TAG, "Error reading training_config.json fields for tokenizer.")
-        }
-    }
-
-    fun tokenize(promptText: String): IntArray {
-        return tokenizer.encode(promptText).getSequence(0)
-    }
-
-    fun tokenizeBatch(textInputs: Array<String>): List<List<Int>> {
-        val sequences = tokenizer.encodeBatch(textInputs)
-
-        val tokenizedInputs : MutableList<MutableList<Int>> = mutableListOf()
-        for (i in 0..<sequences.numSequences()) {
-            tokenizedInputs.add(sequences.getSequence(i).toMutableList())
-        }
-
-        return tokenizedInputs
-    }
-
-    fun decode(inputIds: IntArray): String? {
-        return tokenizer.decode(inputIds)
-    }
-
-    fun readModelFieldsFromJson(filePath: String): Boolean {
-        try {
-            // Read the JSON file from internal storage
-            val jsonFile = File(filePath)
-            if (!jsonFile.exists()) {
-                println("File does not exist: $filePath")
-                return false
-            }
-
-            val jsonString = jsonFile.readText()
-
-            // Parse the JSON object
-            val jsonObject = JSONObject(jsonString)
-
-            // Navigate to the 'model' object
-            val modelObject = jsonObject.getJSONObject("model")
-
-            // Extract the fields 'type' and 'vocab_size'
-            this.modelType = modelObject.getString("type")
-            this.vocabSize = modelObject.getInt("vocab_size")
-            this.eosToken = modelObject.getInt("eos_token_id")
-            this.padToken = modelObject.getInt("pad_token_id")
-
-            return true
-
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        return false
-    }
-
-    fun generate(promptText: String) {
-
-        val tokens = tokenizer.encode(promptText)
-        val generatorParams = model.createGeneratorParams()
-        generatorParams.setInput(tokens)
-        //Log.d("ORTGenerator", "${tokens.getSequence(0)}")
-        val generator = Generator(model, generatorParams)
-        val maxlen = 100
-        var i = 0;
-        while (i < maxlen) {
-            Log.d("ORTGenerator", "Computing logits...")
-            generator.computeLogits()
-            Log.d("ORTGenerator", "token...")
-            generator.generateNextToken()
-            val seq = generator.getSequence(0)
-            val decoded_token = tokenizer.decode(seq)
-            Log.d("ORTGenerator", "${decoded_token}")
-            i+=1
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGeneratorNative.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGeneratorNative.kt
deleted file mode 100644
index 3ca0f49..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTGeneratorNative.kt
+++ /dev/null
@@ -1,279 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import android.util.Log
-import com.martinkorelic.ortmobile.repository.GenerationCallback
-import java.io.File
-
-class ORTGeneratorNative(val cacheDir : String, private var tokenizer: ORTTokenizerNative, var _generationConfig : ORTGenerationConfig) {
-
-    private var LOG_TAG = "ORTGeneratorNative"
-
-    private var inferenceModel : Long = 0
-
-    private var modelLoadTimeMs : Long = 0L
-
-    var pastAttentionMaskLength : Int = 0
-
-    var generationConfig: ORTGenerationConfig
-        get() = _generationConfig
-        set(value) {
-            if (_generationConfig != value) {
-                _generationConfig = value
-                updateSamplingOptions(_generationConfig.sampling)
-            }
-        }
-
-    // Conversation state if we are using multi-turn conversation
-    val conversationState: ORTConversationState? = tokenizer.chatTemplate?.let {
-        ORTConversationState(
-            ORTChatTemplateHandler(it),
-            tokenizer.getSpecialTokensWithContent(),
-            generationConfig.systemPrompt
-        )
-    }
-
-    suspend fun createInferenceModel() {
-        var start : Long = 0L
-        if (generationConfig.trackMetrics) {
-            start = System.currentTimeMillis()
-        }
-
-        if (generationConfig.loadMergedWeights) {
-            // Check if the directory even exists in inferenceModelPath + "/merged"
-            val mergedWeightsDir = File("${cacheDir}/${generationConfig.repoName}/inference", "merged")
-            if (!mergedWeightsDir.exists() || !mergedWeightsDir.isDirectory) {
-                Log.w(LOG_TAG, "Merged weights directory does not exist: ${mergedWeightsDir.absolutePath}, disabling merged weights loading")
-                generationConfig.loadMergedWeights = false
-            }
-        }
-
-        // Check if ONNX name has .onnx extension, add it if missing
-        if (!generationConfig.onnxName.endsWith(".onnx", ignoreCase = true)) {
-            generationConfig.onnxName += ".onnx"
-        }
-
-        // Create the inference session
-        inferenceModel = createInferenceSession(
-            "${cacheDir}/${generationConfig.repoName}/inference",
-            generationConfig.onnxName,
-            cacheDir,
-            generationConfig.loadMergedWeights,
-            generationConfig.deviceOptions.coreConfigId,
-            generationConfig.deviceOptions.memoryConfigId,
-            generationConfig.deviceOptions.executionProvider,
-            generationConfig.deviceOptions.enableProfiling
-        )
-
-        // Update with sampling configurations
-        updateSamplingOptions(generationConfig.sampling)
-
-        if (generationConfig.trackMetrics) {
-            modelLoadTimeMs = System.currentTimeMillis() - start
-        }
-    }
-
-    /**
-     * Generation loop with KV caching enabled in native inference model.
-     * This generation loop generates token by token.
-     * Generates multi-turn conversation if chat template is enabled in tokenizer configuration.
-     */
-    fun generate(promptText: String,
-                         generationArgs : ORTGenerationConfig,
-                         callback: GenerationCallback? = null) : String {
-
-        val decodedText = StringBuilder()
-
-        // Apply new system prompt if exists
-        generationArgs.systemPrompt?.let {
-            conversationState?.setSystemPrompt(it)
-        }
-
-        var inputText = promptText
-
-        try {
-
-            conversationState?.let {
-                // NOTE: Sometimes one token from the previous assistant message keeps prepending and sometimes not
-                // TODO: Will need fix
-                inputText = it.addUserMessage(inputText)
-            }
-
-            // Generate input tokens, but do not add if we already have past attention mask
-            var inputTokens = tokenizer.tokenize(inputText, prependBos = pastAttentionMaskLength == 0)
-
-            if (inputTokens == null) {
-                Log.d(LOG_TAG, "Failed to generate tokens for the prompt.")
-                return ""
-            }
-
-            var (inputIds, attentionMask, positionIds) = createModelInputs(inputTokens)
-            val generatedIds = inputIds
-
-            var decoded = 0
-
-            var currentGenerationTime : Long = 0L
-            var cumulativeGenerationTime : Long = 0L
-            var prefillStartMs : Long = 0L
-            var prefillTimeMs : Long = 0L
-            var avgTokensPerS : Double = 0.0
-            var isEosToken : Boolean = false
-
-            Log.d(LOG_TAG, "Starting generation...")
-
-            callback?.onStartGeneration(
-                InferenceProgress(
-                    token = "",
-                    tokenId = -1,
-                    totalDecodedTokens = decoded,
-                    prefillTimeMs = prefillTimeMs,
-                    timeToLoadModelMs = modelLoadTimeMs,
-                    generationTimeMs = cumulativeGenerationTime,
-                    avgTokensPerSecond =  avgTokensPerS,
-                    isCompleted = this.tokenizer.isEosToken(inputIds.last().toInt())
-                )
-            )
-
-            prefillStartMs = System.currentTimeMillis()
-
-            while (decoded <= generationArgs.maxSequenceLength) {
-
-                // Trim maximum tokens from beginning of the sequence if they go over the limit
-                if (inputIds.size > tokenizer.maximumTokenLength) {
-                    val trimmedInputs = tokenizer.trimModelInputs(inputIds, attentionMask, positionIds)
-                    inputIds = trimmedInputs.first
-                    attentionMask = trimmedInputs.second
-                    positionIds = trimmedInputs.third
-                }
-
-                Log.d(LOG_TAG, inputIds.toString())
-
-                if (generationArgs.trackMetrics && decoded == 0) {
-                    prefillTimeMs = prefillStartMs - System.currentTimeMillis()
-                } else if (generationArgs.trackMetrics) {
-                    currentGenerationTime = System.currentTimeMillis()
-                }
-
-                val nextTokenId = performInferenceStep(
-                    inferenceModel,
-                    inputIds.toLongArray(),
-                    attentionMask.toLongArray(),
-                    positionIds.toLongArray(),
-                    1,
-                    attentionMask.size,
-                    inputIds.size,
-                    this.tokenizer.vocabSize
-                )
-
-                if (generationArgs.trackMetrics && decoded != 0) {
-                    cumulativeGenerationTime += (System.currentTimeMillis() - currentGenerationTime)
-                }
-
-                if (generationArgs.trackMetrics && decoded == 0) {
-                    prefillTimeMs = System.currentTimeMillis() - prefillStartMs
-                } else if (generationArgs.trackMetrics) {
-                    avgTokensPerS = decoded.toDouble() / (cumulativeGenerationTime / 1000.0)
-                }
-
-                // Append the next token ID to generated ids
-                generatedIds.add(nextTokenId.toLong())
-
-                // Replace the next input id (since we are generating token by token)
-                inputIds = mutableListOf(nextTokenId.toLong())
-
-                // Update the attention mask to reflect the new token
-                attentionMask.add(1L)
-
-                // Update position IDs by appending the next position index
-                val nextPositionId = positionIds.last() + 1
-                positionIds = mutableListOf(nextPositionId)
-
-                var decodedToken = tokenizer.decodeToken(nextTokenId)
-
-                // Append the new token to the decoded text
-                isEosToken = this.tokenizer.isEosToken(inputIds.last().toInt())
-
-                // Let's not append eosToken
-                if (!isEosToken)
-                    decodedText.append(decodedToken)
-                // Emit token if needed
-                callback?.onPartialResult(
-                    InferenceProgress(
-                        token = decodedToken,
-                        tokenId = inputIds.last().toInt(),
-                        totalDecodedTokens = decoded,
-                        prefillTimeMs = prefillTimeMs,
-                        timeToLoadModelMs = modelLoadTimeMs,
-                        generationTimeMs = cumulativeGenerationTime,
-                        avgTokensPerSecond =  avgTokensPerS,
-                        isCompleted = isEosToken
-                    )
-                )
-                decoded++
-
-                Log.d(LOG_TAG, decodedText.toString())
-
-                // Break if end of sequence
-                // Also break if assistant has completed the sequence if multi-turn is enabled
-                if (isEosToken)
-                    break
-            }
-
-            // If using multi-turn conversation, we need to add assistant message back
-            conversationState?.let {
-                it.addAssistantMessage(decodedText.toString())
-                pastAttentionMaskLength = attentionMask.size - 2
-            }
-
-            callback?.onCompletion(
-                InferenceProgress(
-                    token = "",
-                    tokenId = -1,
-                    totalDecodedTokens = decoded,
-                    prefillTimeMs = prefillTimeMs,
-                    timeToLoadModelMs = modelLoadTimeMs,
-                    generationTimeMs = cumulativeGenerationTime,
-                    avgTokensPerSecond =  avgTokensPerS,
-                    isCompleted = true
-            ))
-        } catch (e: Throwable) {
-            Log.e(LOG_TAG, e.toString())
-            callback?.onError(e)
-        }
-
-        return decodedText.toString()
-    }
-
-    fun resetConversation() {
-        conversationState?.resetForNewConversation()
-        pastAttentionMaskLength = 0
-    }
-
-    fun destroySession() {
-        releaseInferenceSession(inferenceModel)
-        resetConversation()
-        inferenceModel = 0
-        modelLoadTimeMs = 0L
-    }
-
-    fun createModelInputs(inputIds: IntArray): Triple<MutableList<Long>, MutableList<Long>, MutableList<Long>> {
-        val inputIdsList = inputIds.map { it.toLong() }.toMutableList()
-        val attentionMaskList = MutableList(pastAttentionMaskLength + inputIds.size) { 1L }
-        val positionIdsList = MutableList(inputIds.size) { it.toLong() }
-        return Triple(inputIdsList, attentionMaskList, positionIdsList)
-    }
-
-    fun updateSamplingOptions(args : SamplingOptions) {
-        val methodMap = mapOf("greedy" to 0, "top_k" to 1, "top_p" to 2)
-        val methodInt = methodMap[args.method] ?: 0
-        setSamplingConfig(inferenceModel, methodInt, args.temperature, args.topK, args.topP, args.seed)
-    }
-
-    external fun performInferenceStep(session: Long, input_ids: LongArray, attention_mask: LongArray, position_ids : LongArray, batchSize: Int, sequenceLength: Int, pastSequenceLength : Int, vocabSize : Int) : Int
-
-    external fun createInferenceSession(inferenceModelPath : String, inferenceModelName : String, cacheDirPath : String, loadMergedWeights : Boolean, coreConfigId : String, memoryConfigId : String, executionProvider : String, enableProfiling : Boolean) : Long
-
-    external fun releaseInferenceSession(session: Long)
-
-    external fun setSamplingConfig(session: Long, samplingMethod : Int, temperature : Float, topK : Int, topP : Float, seed : Int)
-
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTProgress.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTProgress.kt
deleted file mode 100644
index 71cc4d8..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/ORTProgress.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import com.martinkorelic.ortmobile.entity.VectorEntityInterface
-
-data class TrainingProgress(
-    val currentStep: Int,
-    val currentEpoch: Int,
-    val totalLoss: Float = 0f,
-    val epochLoss: Float,
-    val stepLoss: Float,
-    val learningRate: Float,
-    val stepDurationMs: Long,
-    val epochDurationMs: Long,
-    val totalDurationMs: Long,
-    val isCompleted: Boolean = false
-)
-
-data class InferenceProgress(
-    val token: String,
-    val tokenId : Int,
-    val totalDecodedTokens: Int,
-    val prefillTimeMs: Long = 0L,
-    val timeToLoadModelMs: Long = 0L,
-    val generationTimeMs: Long = 0L,
-    val avgTokensPerSecond: Double = 0.0,
-    val isCompleted: Boolean = false
-)
-
-data class RagResult(
-    val documents: List<Pair<VectorEntityInterface, Double>>?,
-    val embeddingTimeMs : Long = 0L,
-    val queryTimeMs : Long = 0L
-)
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/LLMRepository.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/LLMRepository.kt
deleted file mode 100644
index e30bb40..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/LLMRepository.kt
+++ /dev/null
@@ -1,499 +0,0 @@
-package com.martinkorelic.ortmobile.repository
-
-import android.content.Context
-import android.util.Log
-import com.martinkorelic.ortmobile.InferenceProgress
-import com.martinkorelic.ortmobile.ORTGenAINative
-import com.martinkorelic.ortmobile.ORTGenAITokenizer
-import com.martinkorelic.ortmobile.ORTGenerationConfig
-import com.martinkorelic.ortmobile.ORTGeneratorNative
-import com.martinkorelic.ortmobile.ORTRagArguments
-import com.martinkorelic.ortmobile.ORTRagConfig
-import com.martinkorelic.ortmobile.ORTRetriever
-import com.martinkorelic.ortmobile.ORTTokenizerNative
-import com.martinkorelic.ortmobile.ORTTrainerNative
-import com.martinkorelic.ortmobile.ORTTrainingConfig
-import com.martinkorelic.ortmobile.RagResult
-import com.martinkorelic.ortmobile.TaskPreprocessor
-import com.martinkorelic.ortmobile.TrainingProgress
-import com.martinkorelic.ortmobile.parseGenerationArguments
-import com.martinkorelic.ortmobile.parseRagArguments
-import com.martinkorelic.ortmobile.parseTrainingArguments
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import java.io.File
-
-enum class LLMState {
-    NotInitialized,
-    ReadyTrain,
-    Training,
-    ReadyGenerate,
-    Generating,
-    Querying,
-    SavingModel
-}
-
-interface GenerationCallback {
-    fun onModelLoadStart() {}
-    fun onModelLoadEnd() {}
-    fun onStartGeneration(inferenceProgress: InferenceProgress) {}
-    fun onPartialResult(inferenceProgress: InferenceProgress) {}
-    fun onCompletion(inferenceProgress: InferenceProgress) {}
-    fun onError(error: Throwable) {}
-}
-
-interface TrainingCallback {
-    fun onModelLoadStart() {}
-    fun onModelLoadEnd() {}
-    fun onDataLoadStart() {}
-    fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch : Int) {}
-    fun onSaveModelStart(trainingProgress: TrainingProgress) {}
-    fun onSaveModelEnd(trainingProgress: TrainingProgress) {}
-    fun onOptimizerStep(trainingProgress: TrainingProgress) {}
-    fun onStepStart(trainingProgress: TrainingProgress) {}
-    fun onStepEnd(trainingProgress: TrainingProgress) {}
-    fun onEpochStart(trainingProgress: TrainingProgress) {}
-    fun onEpochEnd(trainingProgress: TrainingProgress) {}
-    fun onMergeStart(trainingProgress: TrainingProgress) {}
-    fun onMergeEnd(trainingProgress: TrainingProgress) {}
-    fun onCompletion(trainingProgress: TrainingProgress) {}
-    fun onError(error: Throwable) {}
-}
-
-interface RagCallback {
-    fun onModelLoadStart() {}
-    fun onModelLoadEnd() {}
-    fun onQueryStart() {}
-    fun onQueryResults(queryResult: RagResult) {}
-    fun onQueryEnd() {}
-    fun onError(error: Throwable) {}
-}
-
-class LLMRepository(val applicationContext: Context, private val cacheDir : String, initialModel : String? = null) {
-
-    private val LOG_TAG = "LLMRepository"
-
-    // TODO: Should rename into something else as it doesn't refer to only just one model, but rather a set of different models for training/inference/embedding
-    private var _modelName: String = ""
-
-    var modelName: String
-        get() = _modelName
-        set(value) {
-            if (value in availableModels) {
-                _modelName = value
-                updatePaths()
-            } else {
-                Log.w(LOG_TAG, "Model '$value' not found in available models: $availableModels. Keeping modelName as '$_modelName'.")
-            }
-        }
-
-    /**
-     * Returns all LLM models that are present on device
-     */
-    val availableModels: List<String>
-        get() {
-            val dir = File(cacheDir)
-            return dir.listFiles { file -> file.isDirectory }?.map { it.name } ?: emptyList()
-        }
-
-    // Configuration paths
-    private var tokenizerConfigPath : String = "$cacheDir/$_modelName/tokenizer"
-    private var trainingConfigPath = "$cacheDir/$_modelName/train/training_config.json"
-    private var generationConfigPath = "$cacheDir/$_modelName/inference/generation_config.json"
-    private var embeddingConfigPath = "$cacheDir/$_modelName/inference/rag_config.json"
-
-    // Training, generation and RAG config
-    private var _trainingConfig = ORTTrainingConfig()
-    private var _generationConfig = ORTGenerationConfig()
-    private var _ragConfig = ORTRagConfig()
-
-    var trainingConfig: ORTTrainingConfig
-        get() = _trainingConfig
-        set(value) {
-            _trainingConfig = value
-        }
-
-    var generationConfig: ORTGenerationConfig
-        get() = _generationConfig
-        set(value) {
-            _generationConfig = value
-            ortNativeInference?.generationConfig = _generationConfig
-        }
-
-    var ragConfig: ORTRagConfig
-        get() = _ragConfig
-        set(value) {
-            _ragConfig = value
-            ortRetriever?.ragConfig = _ragConfig
-        }
-
-    // Availability
-    var isTrainingAvailable : Boolean = false
-    var isGenerationAvailable : Boolean = false
-    var isRagAvailable : Boolean = false
-
-    // Callback properties
-    var generationCallback: GenerationCallback? = null
-    var trainingCallback: TrainingCallback? = null
-    var ragCallback : RagCallback? = null
-
-    // Training capabilities
-    var ortTrainerNative : ORTTrainerNative? = null
-
-    // Tokenizer capabilities
-    private var ortGenAITokenizer : ORTGenAITokenizer? = null
-    var ortTokenizerNative : ORTTokenizerNative? = null
-
-    // Inference capabilities
-    private var ortGenAiNative : ORTGenAINative? = null
-    var ortNativeInference : ORTGeneratorNative? = null
-
-    // Retriever capabilities
-    var ortRetriever : ORTRetriever? = null
-
-    // LLM state
-    var llmState : LLMState = LLMState.NotInitialized
-
-    private val coroutineScope = CoroutineScope(Dispatchers.Main + Job())
-
-    init {
-        llmState = LLMState.NotInitialized
-
-        if (initialModel != null) {
-            _modelName = initialModel
-            updatePaths()
-            Log.i(LOG_TAG, "Model set to '$_modelName'.")
-        }
-
-        if (_modelName.isEmpty()) {
-            val firstAvailable = availableModels.firstOrNull()
-            if (firstAvailable != null) {
-                _modelName = firstAvailable
-                updatePaths()
-                Log.i(LOG_TAG, "Default model set to first available: $_modelName")
-            }
-        }
-    }
-
-    private fun updatePaths() {
-        tokenizerConfigPath = "$cacheDir/$_modelName/tokenizer"
-        trainingConfigPath = "$cacheDir/$_modelName/train/training_config.json"
-        generationConfigPath = "$cacheDir/$_modelName/inference/generation_config.json"
-        embeddingConfigPath = "$cacheDir/$_modelName/embedding/rag_config.json"
-
-        // Check if training config exists before parsing
-        if (File(trainingConfigPath).exists()) {
-            trainingConfig = parseTrainingArguments(trainingConfigPath)
-            Log.d(LOG_TAG, "Training config loaded from: $trainingConfigPath")
-            isTrainingAvailable = true
-        } else {
-            Log.w(LOG_TAG, "Training config not found at: $trainingConfigPath")
-            isTrainingAvailable = false
-        }
-
-        // Check if generation config exists before parsing
-        if (File(generationConfigPath).exists()) {
-            generationConfig = parseGenerationArguments(generationConfigPath)
-            Log.d(LOG_TAG, "Generation config loaded from: $generationConfigPath")
-            isGenerationAvailable = true
-        } else {
-            Log.w(LOG_TAG, "Generation config not found at: $generationConfigPath")
-            isGenerationAvailable = false
-        }
-
-        // Check if embedding config exists before parsing
-        if (File(embeddingConfigPath).exists()) {
-            ragConfig = parseRagArguments(embeddingConfigPath)
-            Log.d(LOG_TAG, "RAG config loaded from: $embeddingConfigPath")
-            isRagAvailable = true
-        } else {
-            Log.w(LOG_TAG, "RAG config not found at: $embeddingConfigPath")
-            isRagAvailable = false
-        }
-    }
-
-    fun resetInference() {
-        // Destroy previous tokenizer session
-        ortTokenizerNative?.destroySession()
-        // Destroy previous inference session
-        ortNativeInference?.destroySession()
-
-        ortTokenizerNative = null
-        ortNativeInference = null
-
-        llmState = LLMState.NotInitialized
-    }
-
-    fun resetTraining() {
-        ortTokenizerNative?.destroySession()
-        ortTrainerNative?.destroySession(false)
-        ortTokenizerNative = null
-        ortTrainerNative = null
-
-        llmState = LLMState.NotInitialized
-    }
-
-    suspend private fun makeOrtTrainer(trainingArguments: ORTTrainingConfig? = null, dataPreprocessFunction: TaskPreprocessor? = null) : ORTTrainerNative {
-        if (ortTokenizerNative == null) {
-            Log.d(LOG_TAG, "Could not find the tokenizer. Initializing tokenizer...")
-            ortTokenizerNative = ORTTokenizerNative(tokenizerConfigPath)
-            ortTokenizerNative?.createTokenizerModel()
-        }
-
-        val trainArgs = trainingConfig.overrideConfig(trainingArguments)
-
-        val finalConfig = if (dataPreprocessFunction != null)
-            trainArgs.copy(customPreprocess = dataPreprocessFunction)
-        else
-            trainArgs
-
-        return ORTTrainerNative(
-            applicationContext,
-            cacheDir,
-            ortTokenizerNative!!,
-            finalConfig
-        )
-    }
-
-    private suspend fun makeOrtNativeInference(generationArgs : ORTGenerationConfig) : ORTGeneratorNative {
-        //if (ortTrainerNative == null) {
-        //    Log.e(LOG_TAG, "Could not find the train model. Make sure it is initialized before GenAI inference.")
-        //    return null
-        //}
-
-        if (ortTokenizerNative == null) {
-            Log.e(LOG_TAG, "Could not find the tokenizer. Initializing tokenizer...")
-            ortTokenizerNative = ORTTokenizerNative(tokenizerConfigPath)
-            ortTokenizerNative?.createTokenizerModel()
-        }
-
-        // We destroy trainer session before loading generation session, if it was active before
-        // Assuming the training session has been saved prior to this
-        ortTrainerNative?.destroySession(false)
-
-        val nativeInference = ORTGeneratorNative(cacheDir, ortTokenizerNative!!, generationConfig)
-        nativeInference.createInferenceModel()
-
-        return nativeInference
-    }
-
-    private suspend fun makeOrtRag(ortArgs : ORTRagConfig) : ORTRetriever {
-
-        // We destroy trainer session before loading generation session, if it was active before
-        // Assuming the training session has been saved prior to this
-        ortTrainerNative?.destroySession(false)
-
-        val retriever = ORTRetriever(cacheDir, applicationContext, ragConfig)
-        retriever.createEmbeddingModel()
-
-        return retriever
-    }
-
-    /* Inference methods */
-
-    suspend fun prepareRetriever(ragArgs : ORTRagConfig? = null): Job {
-        // Clean up the tokenizer and destroy session if there was previous training
-        // Takes less memory if we initialize the training session again with the checkpoint state
-
-        if (llmState == LLMState.ReadyTrain) {
-            ortTokenizerNative = null
-        }
-
-        // TODO: Override RAG config if needed
-        //val finalGenConfig = generationConfig.overrideConfig(generationArgs)
-
-        // If the model was in training state
-        if (llmState == LLMState.Training) {
-
-            coroutineScope.launch {
-                withContext(Dispatchers.Default) {
-
-                    // Release training session if there was any (no saving)
-                    ortTrainerNative?.destroySession(false)
-
-                    llmState = LLMState.ReadyGenerate
-                }
-            }.join()
-        }
-
-        return coroutineScope.launch {
-            try {
-                withContext(Dispatchers.Default) {
-                    ortRetriever = makeOrtRag(ragConfig)
-                }
-            } catch (e: Exception) {
-                Log.e(LOG_TAG, "Retriever session failed to create: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun prepareGeneration(generationArgs : ORTGenerationConfig? = null): Job {
-        // Clean up the tokenizer and destroy session if there was previous training
-        // Takes less memory if we initialize the training session again with the checkpoint state
-
-        if (llmState == LLMState.ReadyTrain) {
-            ortTokenizerNative = null
-        }
-
-        val finalGenConfig = generationConfig.overrideConfig(generationArgs)
-
-        // If the model was in training state
-        if (llmState == LLMState.Training) {
-
-            coroutineScope.launch {
-                withContext(Dispatchers.Default) {
-
-                    // Release training session if there was any (no saving)
-                    ortTrainerNative?.destroySession(false)
-
-                    llmState = LLMState.ReadyGenerate
-                }
-            }.join()
-        }
-
-        return coroutineScope.launch {
-            try {
-                withContext(Dispatchers.Default) {
-                    when (finalGenConfig.type) {
-                        // Deprecated
-                        //"gen_ai" -> {
-                        //    ortGenAiNative = makeOrtGenAI()
-                        //}
-                        "native" -> {
-                            ortNativeInference = makeOrtNativeInference(finalGenConfig)
-                        }
-                        else -> {
-                            Log.e(LOG_TAG, "Unknown generation type - ${finalGenConfig.type}")
-                        }
-                    }
-                }
-            } catch (e: Exception) {
-                Log.e(LOG_TAG, "Generation session failed to create: ${e.message}")
-            } finally {
-                llmState = LLMState.ReadyGenerate
-            }
-        }
-    }
-
-    suspend fun runGenerationStream(prompt: String, generationArgs: ORTGenerationConfig? = null) {
-        if (ortNativeInference == null) {
-            Log.e(LOG_TAG, "Model has not been initialized and cached yet.")
-            return
-        }
-
-        val finalGenConfig = generationConfig.overrideConfig(generationArgs)
-
-        llmState = LLMState.Generating
-
-        coroutineScope.launch {
-            try {
-                withContext(Dispatchers.Default) {
-                    when (finalGenConfig.type) {
-                        // Deprecated
-                        //"genai" -> ortGenAiNative!!.generateStream()
-                        "native" -> {
-                            ortNativeInference!!.generate(prompt, finalGenConfig, generationCallback)
-                        }
-
-                        else -> {
-                            Log.e(LOG_TAG, "Unknown generation type - ${finalGenConfig.type}")
-                        }
-                    }
-                }
-            } catch (e : Exception) {
-                Log.e(LOG_TAG, "Generation failed: ${e.message}")
-            } finally {
-                llmState = LLMState.ReadyGenerate
-            }
-        }
-    }
-
-    suspend fun runRetriever(prompt: String, ragArgs: ORTRagArguments? = null): Job {
-
-        val finalRagConfig = ragConfig.overwriteWith(ragArgs)
-
-        llmState = LLMState.Querying
-
-        return coroutineScope.launch {
-            try {
-                withContext(Dispatchers.Default) {
-                    ortRetriever?.query(prompt, finalRagConfig, ragCallback)
-                }
-            } catch (e : Exception) {
-                Log.e(LOG_TAG, "Query failed: ${e.message}")
-            } finally {
-                llmState = LLMState.ReadyGenerate
-            }
-        }
-    }
-
-    /* Training methods */
-
-    suspend fun prepareTraining(trainingArguments: ORTTrainingConfig? = null,  dataPreprocessFunction: TaskPreprocessor? = null) : Job {
-
-        if (llmState == LLMState.ReadyGenerate) {
-            coroutineScope.launch {
-                withContext(Dispatchers.Default) {
-
-                    when (generationConfig.type) {
-                        // Deprecated
-                        //"genai" -> ortGenAiNative?.destroySession()
-                        "native" -> ortNativeInference?.destroySession()
-                    }
-
-                    llmState = LLMState.NotInitialized
-                }
-            }.join()
-
-        }
-
-        val finalTrainConfig = trainingConfig.overrideConfig(trainingArguments);
-
-        return coroutineScope.launch {
-            withContext(Dispatchers.Default) {
-                ortTrainerNative = makeOrtTrainer(
-                    finalTrainConfig,
-                    dataPreprocessFunction
-                )
-                llmState = LLMState.ReadyTrain
-            }
-        }
-    }
-
-    suspend fun runTraining() : Job? {
-        if (llmState != LLMState.ReadyTrain && llmState != LLMState.Training) {
-            Log.e(LOG_TAG, "Model is not ready to train.")
-            return null
-        }
-
-        llmState = LLMState.Training
-
-        // Here we mark that there was training done on this model
-        return coroutineScope.launch {
-            withContext(Dispatchers.IO) {
-                ortTrainerNative?.startTraining(trainingCallback)
-            }
-            llmState = LLMState.ReadyTrain
-        }
-    }
-
-    suspend fun saveTraining(saveModel : Boolean) : Job? {
-        if (llmState != LLMState.ReadyTrain && llmState != LLMState.Training) {
-            Log.e(LOG_TAG, "Model is not ready to save.")
-            return null
-        }
-
-        llmState = LLMState.SavingModel
-
-        return coroutineScope.launch {
-            withContext(Dispatchers.IO) {
-                ortTrainerNative?.destroySession(saveModel)
-            }
-            llmState = LLMState.NotInitialized
-        }
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/RagRepository.kt b/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/RagRepository.kt
deleted file mode 100644
index d17288c..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/main/java/com/martinkorelic/ortmobile/repository/RagRepository.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package com.martinkorelic.ortmobile.repository
-
-import android.util.Log
-import com.martinkorelic.ortmobile.ORTRagArguments
-import com.martinkorelic.ortmobile.ORTRagConfig
-
-class RagRepository(private val llmRepository: LLMRepository) {
-
-    private val LOG_TAG = "RagRepository"
-
-    suspend fun initialize(
-        ragConfig: ORTRagConfig? = null,
-        ragCallback: RagCallback? = null
-    ) {
-        if (ragCallback != null) llmRepository.ragCallback = ragCallback
-
-        if (llmRepository.ortRetriever == null) {
-            llmRepository.ragCallback?.onModelLoadStart()
-            val job = llmRepository.prepareRetriever(ragConfig)
-            job.join()
-            llmRepository.ragCallback?.onModelLoadEnd()
-        }
-
-    }
-
-    suspend fun query(prompt : String, ragConfig: ORTRagArguments? = null, ragCallback: RagCallback? = null) {
-
-        if (llmRepository.ortRetriever == null) {
-            Log.e(LOG_TAG, "ORTRetriever is not currently set or does not exist.")
-            return
-        }
-
-        // Update RAG callback
-        if (ragCallback != null) llmRepository.ragCallback = ragCallback
-
-        // Run the retriever
-        val job = llmRepository.runRetriever(prompt, ragConfig)
-        job.join()
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/ORTransformersMobile/src/test/java/com/martinkorelic/ortmobile/ExampleUnitTest.kt b/android/ORTransformer/ORTransformersMobile/src/test/java/com/martinkorelic/ortmobile/ExampleUnitTest.kt
deleted file mode 100644
index ccbc9a6..0000000
--- a/android/ORTransformer/ORTransformersMobile/src/test/java/com/martinkorelic/ortmobile/ExampleUnitTest.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.martinkorelic.ortmobile
-
-import org.junit.Test
-
-import org.junit.Assert.*
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/build.gradle.kts b/android/ORTransformer/app/build.gradle.kts
deleted file mode 100644
index d2ed767..0000000
--- a/android/ORTransformer/app/build.gradle.kts
+++ /dev/null
@@ -1,92 +0,0 @@
-import org.jetbrains.kotlin.cli.jvm.main
-
-plugins {
-    alias(libs.plugins.android.application)
-    alias(libs.plugins.jetbrains.kotlin.android)
-}
-
-android {
-    namespace = "com.martinkorelic.orttransformer"
-    compileSdk = 34
-
-    defaultConfig {
-
-        applicationId = "com.martinkorelic.ortmobile"
-        minSdk = 24
-        targetSdk = 34
-        versionCode = 1
-        versionName = "1.0"
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-
-        vectorDrawables {
-            useSupportLibrary = true
-        }
-
-    }
-
-    buildTypes {
-        release {
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-
-    buildFeatures {
-        viewBinding = true
-        compose = true
-    }
-
-    composeOptions {
-        kotlinCompilerExtensionVersion = "1.5.1"
-    }
-    packaging {
-        resources {
-            excludes += "/META-INF/{AL2.0,LGPL2.1}"
-        }
-    }
-
-
-
-}
-
-dependencies {
-
-
-    implementation(project(":ORTransformersMobile"))
-    implementation(libs.androidx.lifecycle.runtime.ktx)
-    implementation(libs.androidx.ui)
-    implementation(libs.androidx.ui.graphics)
-
-    androidTestImplementation(libs.androidx.ui.test.junit4)
-    val composeBom = platform("androidx.compose:compose-bom:2024.10.00")
-    implementation(composeBom)
-    androidTestImplementation(composeBom)
-    implementation(libs.androidx.activity.compose)
-    implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.appcompat)
-
-    implementation(libs.material)
-    implementation(libs.androidx.constraintlayout)
-
-    // Compose
-    implementation(libs.androidx.material3)
-
-    implementation(libs.androidx.ui.tooling.preview)
-    debugImplementation(libs.androidx.ui.tooling)
-
-    testImplementation(libs.junit)
-    androidTestImplementation(libs.androidx.junit)
-    androidTestImplementation(libs.androidx.espresso.core)
-    debugImplementation(libs.androidx.ui.test.manifest)
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/androidTest/java/com/martinkorelic/orttransformer/ExampleInstrumentedTest.kt b/android/ORTransformer/app/src/androidTest/java/com/martinkorelic/orttransformer/ExampleInstrumentedTest.kt
deleted file mode 100644
index 4463cd8..0000000
--- a/android/ORTransformer/app/src/androidTest/java/com/martinkorelic/orttransformer/ExampleInstrumentedTest.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.martinkorelic.orttransformer
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("com.example.orttransformer", appContext.packageName)
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/AndroidManifest.xml b/android/ORTransformer/app/src/main/AndroidManifest.xml
deleted file mode 100644
index b921a69..0000000
--- a/android/ORTransformer/app/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
-
-    <application
-        android:allowBackup="true"
-        android:dataExtractionRules="@xml/data_extraction_rules"
-        android:fullBackupContent="@xml/backup_rules"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:largeHeap="true"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.ORTTransformer"
-        tools:targetApi="31">
-        <activity
-            android:name=".TrainingScreen"
-            android:exported="false"
-            android:label="@string/title_activity_training_screen"
-            android:theme="@style/Theme.ORTTransformer" />
-        <activity
-            android:name=".InferenceScreen"
-            android:exported="false"
-            android:label="@string/title_activity_inference_screen"
-            android:theme="@style/Theme.ORTTransformer" />
-        <activity
-            android:name=".MainActivity"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-
-</manifest>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/MainActivity.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/MainActivity.kt
deleted file mode 100644
index 08861c9..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/MainActivity.kt
+++ /dev/null
@@ -1,172 +0,0 @@
-package com.martinkorelic.orttransformer
-
-import android.os.Bundle
-import android.util.Log
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-
-import androidx.activity.enableEdgeToEdge
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.systemBars
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Tab
-import androidx.compose.material3.TabRow
-import androidx.compose.material3.TabRowDefaults
-import androidx.compose.material3.TabRowDefaults.tabIndicatorOffset
-import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import com.martinkorelic.orttransformer.databinding.ActivityMainBinding
-import com.martinkorelic.ortmobile.repository.InferenceRepository
-import com.martinkorelic.ortmobile.repository.LLMRepository
-import com.martinkorelic.ortmobile.repository.RagRepository
-import com.martinkorelic.ortmobile.repository.TrainingRepository
-import com.martinkorelic.orttransformer.ui.theme.AppTheme
-import com.martinkorelic.orttransformer.ui.theme.AppThemedContent
-import com.martinkorelic.orttransformer.viewmodels.ConfigurationViewModel
-import com.martinkorelic.orttransformer.viewmodels.InferenceViewModel
-import com.martinkorelic.orttransformer.viewmodels.TrainingViewModel
-import com.martinkorelic.orttransformer.views.ConfigurationScreen
-import com.martinkorelic.orttransformer.views.InferenceScreen
-import com.martinkorelic.orttransformer.views.TrainingScreen
-
-class MainActivity : ComponentActivity() {
-
-    private val LOG_TAG = "MainActivity"
-
-    private lateinit var binding: ActivityMainBinding
-
-    // Creating training and inference repository
-    // Pick and play
-    private lateinit var llmRepository : LLMRepository
-    private lateinit var inferenceRepository : InferenceRepository
-    private lateinit var trainingRepository : TrainingRepository
-    private lateinit var ragRepository: RagRepository
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        // To LLMRepository pass the application files directory to access models
-        llmRepository = LLMRepository(applicationContext, filesDir.absolutePath)
-        inferenceRepository = InferenceRepository(llmRepository)
-        trainingRepository = TrainingRepository(llmRepository)
-        ragRepository = RagRepository(llmRepository)
-
-        enableEdgeToEdge()
-
-        setContent {
-            // Change theme when needed
-            val currentTheme by remember { mutableStateOf(AppTheme.FRI) }
-
-            AppThemedContent(theme = currentTheme) {
-                Surface (
-                    modifier = Modifier
-                        .fillMaxSize(),
-                    color = MaterialTheme.colorScheme.background
-                ) {
-                    MainApp()
-                }
-            }
-        }
-    }
-
-    companion object {
-        // Used to load the 'ortmobile' library on application startup.
-        init {
-            System.loadLibrary("ortmobile")
-        }
-    }
-
-    @OptIn(ExperimentalMaterial3Api::class)
-    @Composable
-    fun MainApp() {
-        var selectedTab by remember { mutableStateOf(0) }
-        val tabs = listOf("Inference", "Training", "Configuration")
-
-        // Create ViewModels
-
-        val inferenceViewModel = remember { InferenceViewModel(llmRepository, inferenceRepository, ragRepository) }
-        val trainingViewModel = remember { TrainingViewModel(llmRepository, trainingRepository) }
-        val configurationViewModel = remember { ConfigurationViewModel(llmRepository) }
-
-        Column(modifier = Modifier
-            .fillMaxSize()) {
-            TopAppBar(
-                title = {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
-                        horizontalArrangement = Arrangement.SpaceBetween
-                    ) {
-                        Image(
-                            painter = painterResource(id = R.drawable.fri_logo),
-                            contentDescription = "App logo",
-                            modifier = Modifier
-                                .size(128.dp),
-                                //.size(48.dp)
-                        )
-                        Text(
-                            text = "ORTransformersMobile",
-                            //text = "Mobile Health Assistant",
-                            modifier = Modifier.fillMaxWidth(),
-                            textAlign = TextAlign.Center,
-                            style = MaterialTheme.typography.titleLarge,
-                            color = MaterialTheme.colorScheme.secondary
-                        )
-                    }
-
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.surface,
-                    titleContentColor = MaterialTheme.colorScheme.onSurface
-                )
-            )
-            TabRow(selectedTabIndex = selectedTab, contentColor = Color.White, containerColor = Color.White,
-                indicator = { tabPositions ->
-                    TabRowDefaults.Indicator(
-                        Modifier.tabIndicatorOffset(tabPositions[selectedTab]),
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                }) {
-                tabs.forEachIndexed { index, title ->
-                    Tab(
-                        selected = selectedTab == index,
-                        onClick = { selectedTab = index },
-                        text = { Text(title, color = MaterialTheme.colorScheme.primary) },
-                        selectedContentColor = MaterialTheme.colorScheme.primary,
-                        unselectedContentColor = MaterialTheme.colorScheme.primary
-                    )
-                }
-            }
-
-            when (selectedTab) {
-                0 -> InferenceScreen(viewModel = inferenceViewModel, configurationViewModel = configurationViewModel)
-                1 -> TrainingScreen(viewModel = trainingViewModel)
-                2 -> ConfigurationScreen(viewModel = configurationViewModel)
-            }
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Theme.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Theme.kt
deleted file mode 100644
index 318f0d3..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/ui/theme/Theme.kt
+++ /dev/null
@@ -1,143 +0,0 @@
-package com.martinkorelic.orttransformer.ui.theme
-
-import android.os.Build
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Shapes
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
-import androidx.compose.material3.*
-
-enum class AppTheme {
-    FRI,
-    BETTER
-}
-
-// Medical Theme Colors
-private val FriLightColors = lightColorScheme(
-    primary = Color(0xFFe03229),
-    onPrimary = Color.White,
-    primaryContainer = Color(0xFFE8F5F0),
-    onPrimaryContainer = Color(0xFF1B4A36),
-
-    secondary = Color(0xFF58595b),
-    onSecondary = Color.White,
-    secondaryContainer = Color(0xFFD1ECFF),
-    onSecondaryContainer = Color(0xFF001D36),
-
-    tertiary = Color(0xFF7B5A3C),          // Warm brown
-    onTertiary = Color.White,
-    tertiaryContainer = Color(0xFFFFDDBE),
-    onTertiaryContainer = Color(0xFF2D1600),
-
-    error = Color(0xFFB00020),
-    onError = Color.White,
-    errorContainer = Color(0xFFFDADAD),
-    onErrorContainer = Color(0xFF410E0B),
-
-    background = Color(0xFFFDFCFF),
-    onBackground = Color(0xFF1A1C19),
-    surface = Color(0xFFFDFCFF),
-    onSurface = Color(0xFF1A1C19),
-    surfaceVariant = Color(0xFFDDE5DA),
-    onSurfaceVariant = Color(0xFF414941),
-    outline = Color(0xFF717970),
-    outlineVariant = Color(0xFFC1C9BF)
-)
-
-private val BetterLightColors = lightColorScheme(
-    primary = Color(0xFF026fd0),           // Professional blue
-    onPrimary = Color.White,
-    primaryContainer = Color(0xFFD1E4FF),
-    onPrimaryContainer = Color(0xFF001D36),
-
-    secondary = Color(0xFFF9F9F9),         // Blue grey
-    onSecondary = Color.White,
-    secondaryContainer = Color(0xFFD7E3F7),
-    onSecondaryContainer = Color(0xFF101C2B),
-
-    tertiary = Color(0xFF6A4C93),          // Purple accent
-    onTertiary = Color.White,
-    tertiaryContainer = Color(0xFFEADDFF),
-    onTertiaryContainer = Color(0xFF21005D),
-
-    error = Color(0xFFD32F2F),
-    onError = Color.White,
-    errorContainer = Color(0xFFFFDAD6),
-    onErrorContainer = Color(0xFF410002),
-
-    background = Color(0xFFFEFBFF),
-    onBackground = Color(0xFF1B1B1F),
-    surface = Color(0xFFFEFBFF),
-    onSurface = Color(0xFF1B1B1F),
-    surfaceVariant = Color(0xFFE2E2EC),
-    onSurfaceVariant = Color(0xFF45464F),
-    outline = Color(0xFF767680),
-    outlineVariant = Color(0xFFC6C6D0)
-)
-
-// 5. Custom Typography per Theme
-@Composable
-private fun getTypography(theme: AppTheme): Typography {
-    return when (theme) {
-        AppTheme.FRI -> Typography(
-            headlineLarge = MaterialTheme.typography.headlineLarge.copy(
-                fontWeight = androidx.compose.ui.text.font.FontWeight.SemiBold
-            ),
-            titleMedium = MaterialTheme.typography.titleMedium.copy(
-                fontWeight = androidx.compose.ui.text.font.FontWeight.Medium
-            )
-        )
-        AppTheme.BETTER -> Typography(
-            headlineLarge = MaterialTheme.typography.headlineLarge.copy(
-                fontWeight = androidx.compose.ui.text.font.FontWeight.Bold
-            ),
-            titleMedium = MaterialTheme.typography.titleMedium.copy(
-                fontWeight = androidx.compose.ui.text.font.FontWeight.SemiBold
-            )
-        )
-    }
-}
-
-// 6. Custom Shapes per Theme
-@Composable
-private fun getShapes(theme: AppTheme): Shapes {
-    return when (theme) {
-        AppTheme.FRI -> Shapes(
-            small = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
-            medium = androidx.compose.foundation.shape.RoundedCornerShape(12.dp),
-            large = androidx.compose.foundation.shape.RoundedCornerShape(16.dp)
-        )
-        AppTheme.BETTER -> Shapes(
-            small = androidx.compose.foundation.shape.RoundedCornerShape(4.dp),
-            medium = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
-            large = androidx.compose.foundation.shape.RoundedCornerShape(12.dp)
-        )
-    }
-}
-
-// 4. Main Theme Composable
-@Composable
-fun AppThemedContent(
-    theme: AppTheme,
-    isDarkMode: Boolean = false,
-    content: @Composable () -> Unit
-) {
-    val colorScheme = when (theme) {
-        AppTheme.FRI -> FriLightColors
-        AppTheme.BETTER -> BetterLightColors
-    }
-
-    MaterialTheme(
-        colorScheme = colorScheme,
-        typography = getTypography(theme),
-        shapes = getShapes(theme),
-        content = content
-    )
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/ConfigurationViewModel.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/ConfigurationViewModel.kt
deleted file mode 100644
index b765022..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/ConfigurationViewModel.kt
+++ /dev/null
@@ -1,93 +0,0 @@
-package com.martinkorelic.orttransformer.viewmodels
-
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.lifecycle.ViewModel
-import com.martinkorelic.ortmobile.ORTGenerationConfig
-import com.martinkorelic.ortmobile.ORTRagConfig
-import com.martinkorelic.ortmobile.ORTTrainingConfig
-import com.martinkorelic.ortmobile.repository.LLMRepository
-
-class ConfigurationViewModel(private val llmRepository: LLMRepository) : ViewModel() {
-
-    private val _generationConfig = mutableStateOf(llmRepository.generationConfig)
-    val generationConfig: MutableState<ORTGenerationConfig> = _generationConfig
-
-    private val _trainingConfig = mutableStateOf(llmRepository.trainingConfig)
-    val trainingConfig: MutableState<ORTTrainingConfig> = _trainingConfig
-
-    private val _ragConfig = mutableStateOf(llmRepository.ragConfig)
-    val ragConfig: MutableState<ORTRagConfig> = _ragConfig
-
-    private val _ragEnabled = mutableStateOf(false)
-    val ragEnabled : MutableState<Boolean> = _ragEnabled
-
-    val availableModels = llmRepository.availableModels
-
-    // Add availability states
-    private val _isRagAvailable = mutableStateOf(llmRepository.isRagAvailable)
-    val isRagAvailable: MutableState<Boolean> = _isRagAvailable
-
-    private val _isTrainingAvailable = mutableStateOf(llmRepository.isTrainingAvailable)
-    val isTrainingAvailable: MutableState<Boolean> = _isTrainingAvailable
-
-    private val _isGenerationAvailable = mutableStateOf(llmRepository.isGenerationAvailable)
-    val isGenerationAvailable: MutableState<Boolean> = _isGenerationAvailable
-
-    init {
-        // Initialize availability and disable RAG if not available
-        updateAvailability()
-    }
-
-    private fun updateAvailability() {
-        _isRagAvailable.value = llmRepository.isRagAvailable
-        _isTrainingAvailable.value = llmRepository.isTrainingAvailable
-        _isGenerationAvailable.value = llmRepository.isGenerationAvailable
-
-        // Disable RAG if not available
-        if (!llmRepository.isRagAvailable) {
-            _ragEnabled.value = false
-        }
-    }
-
-    fun updateGenerationConfig(config: ORTGenerationConfig) {
-        _generationConfig.value = config
-        llmRepository.generationConfig = config // Persist to repository
-    }
-
-    fun updateTrainingConfig(config: ORTTrainingConfig) {
-        _trainingConfig.value = config
-        llmRepository.trainingConfig = config // Persist to repository
-    }
-
-    fun updateRagConfig(config: ORTRagConfig) {
-        _ragConfig.value = config
-        llmRepository.ragConfig = config // Persist to repository
-    }
-
-    fun updateRagEnabled(enabled: Boolean) {
-        _ragEnabled.value = enabled
-    }
-
-    fun onGenerationModelChanged(modelName: String) {
-        // Reload configuration from repository when model changes
-        llmRepository.modelName = modelName
-        val newConfig = llmRepository.generationConfig.copy(repoName = modelName)
-        _generationConfig.value = newConfig
-
-        val newRagConfig = llmRepository.ragConfig.copy(repoName = modelName)
-        _ragConfig.value = newRagConfig
-
-        updateAvailability()
-    }
-
-    fun onTrainingModelChanged(modelName: String) {
-        // Reload configuration from repository when model changes
-        llmRepository.modelName = modelName
-        val newConfig = llmRepository.trainingConfig.copy(repoName = modelName)
-        _trainingConfig.value = newConfig
-
-        updateAvailability()
-    }
-
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/InferenceViewModel.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/InferenceViewModel.kt
deleted file mode 100644
index 374b2b7..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/InferenceViewModel.kt
+++ /dev/null
@@ -1,287 +0,0 @@
-package com.martinkorelic.orttransformer.viewmodels
-
-import android.util.Log
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.martinkorelic.ortmobile.InferenceProgress
-import com.martinkorelic.ortmobile.repository.InferenceRepository
-import com.martinkorelic.ortmobile.RagResult
-import com.martinkorelic.ortmobile.entity.VectorEntityInterface
-import com.martinkorelic.ortmobile.repository.GenerationCallback
-import com.martinkorelic.ortmobile.repository.LLMRepository
-import com.martinkorelic.ortmobile.repository.RagCallback
-import com.martinkorelic.ortmobile.repository.RagRepository
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.launch
-
-interface Message {
-    val timestamp: Long
-    val id: String
-}
-
-// Helper function to generate unique IDs
-private fun generateId(): String = "msg_${System.currentTimeMillis()}_${kotlin.random.Random.nextInt(1000)}"
-
-data class ChatMessage(
-    val message: String,
-    val isUserMessage: Boolean,
-    override val timestamp: Long = System.currentTimeMillis(),
-    override val id: String = generateId()
-) : Message
-
-data class ChunkDetails(
-    val file : String,
-    val content : String,
-    val score : Double
-)
-
-data class RagMessage(
-    val documents : List<ChunkDetails>,
-    override val timestamp: Long = System.currentTimeMillis(),
-    override val id: String = generateId()
-) : Message
-
-enum class InferenceUiState {
-    LoadingModel,
-    LoadingRetriever,
-    FinishedLoadingModel,
-    Querying,
-    ReadyGenerate,
-    Generating,
-    Error
-}
-
-class InferenceViewModel(private val llmRepository: LLMRepository, private val inferenceRepository: InferenceRepository, private val ragRepository: RagRepository? = null) : ViewModel() {
-
-    private val LOG_TAG = "InferenceViewModel"
-
-    private val _inferenceState = MutableStateFlow(InferenceUiState.ReadyGenerate)
-    val inferenceState: StateFlow<InferenceUiState> = _inferenceState
-
-    private val _chatHistory = MutableStateFlow<List<Message>>(emptyList())
-    val chatHistory: StateFlow<List<Message>> = _chatHistory
-
-    private val _chatStream = MutableStateFlow<List<String>>(emptyList())
-    val chatStream: StateFlow<List<String>> = _chatStream
-
-    private val _isStreaming = MutableStateFlow(false)
-    val isStreaming: StateFlow<Boolean> = _isStreaming
-
-    private val _ttlmTime = MutableStateFlow(0.0)
-    val ttlmTime: StateFlow<Double> = _ttlmTime
-
-    private val _prefillTime = MutableStateFlow(0.0)
-    val prefillTime: StateFlow<Double> = _prefillTime
-
-    private val _generationTime = MutableStateFlow(0.0)
-    val generationTime: StateFlow<Double> = _generationTime
-
-    private val _queryTime = MutableStateFlow(0.0)
-    val queryTime: StateFlow<Double> = _queryTime
-
-    private val _embeddingTime = MutableStateFlow(0.0)
-    val embeddingTime: StateFlow<Double> = _embeddingTime
-
-    init {
-
-        // Generation callbacks
-        llmRepository.generationCallback = object : GenerationCallback {
-
-            override fun onModelLoadStart() {
-                Log.i(LOG_TAG,"Loading...")
-                _inferenceState.value = InferenceUiState.LoadingModel
-            }
-
-            override fun onModelLoadEnd() {
-                Log.i(LOG_TAG,"Finished loading...")
-                _inferenceState.value = InferenceUiState.ReadyGenerate
-            }
-
-            override fun onStartGeneration(inferenceProgress: InferenceProgress) {
-                _inferenceState.value = InferenceUiState.Generating
-            }
-
-            override fun onPartialResult(inferenceProgress: InferenceProgress) {
-                _isStreaming.value = true
-
-                if (llmRepository.ortTokenizerNative?.isSpecialToken(inferenceProgress.tokenId) == false)
-                    _chatStream.value += inferenceProgress.token
-
-                _ttlmTime.value = inferenceProgress.timeToLoadModelMs / 1000.0
-                _prefillTime.value = inferenceProgress.prefillTimeMs / 1000.0
-                _generationTime.value = inferenceProgress.avgTokensPerSecond
-            }
-
-            override fun onCompletion(inferenceProgress: InferenceProgress) {
-                _chatHistory.value += ChatMessage(message = _chatStream.value.joinToString(separator = ""), isUserMessage = false)
-                _chatStream.value = listOf()
-                _isStreaming.value = false
-                _inferenceState.value = InferenceUiState.ReadyGenerate
-            }
-
-            override fun onError(error: Throwable) {
-                _isStreaming.value = false
-                _inferenceState.value = InferenceUiState.Error
-                Log.e(LOG_TAG, "Generation error: ${error.message}")
-            }
-        }
-
-
-        // Rag repository callbacks if defined
-        llmRepository.ragCallback = object : RagCallback {
-            override fun onModelLoadStart() {
-                _inferenceState.value = InferenceUiState.LoadingRetriever
-            }
-
-            override fun onModelLoadEnd() {
-                _inferenceState.value = InferenceUiState.ReadyGenerate
-            }
-        }
-    }
-
-    fun reloadInferenceSession() {
-        // Reloads session with new configuration and model
-
-        viewModelScope.launch {
-            inferenceRepository.reloadSession()
-            _chatHistory.value = listOf()
-            _chatStream.value = listOf()
-        }
-    }
-
-    fun sendMessage(message: String, useRag : Boolean = false) {
-        viewModelScope.launch {
-
-            // Initialize RAG Repository if it hasn't been before
-            if (ragRepository != null
-                && llmRepository.ortRetriever == null
-                && useRag
-                && llmRepository.isRagAvailable) {
-                ragRepository.initialize()
-            }
-
-            // Query RAG repository if useRag is requested
-            if (ragRepository != null
-                && useRag
-                && llmRepository.ortRetriever != null) {
-
-                // Query the RAG repository and then on callback when results are delivered query with question and context
-                ragRepository.query(message, ragCallback = object : RagCallback {
-
-                    override fun onModelLoadStart() {
-                        _inferenceState.value = InferenceUiState.LoadingRetriever
-                    }
-
-                    override fun onModelLoadEnd() {
-                        _inferenceState.value = InferenceUiState.ReadyGenerate
-                    }
-
-                    override fun onQueryStart() {
-                        _inferenceState.value = InferenceUiState.Querying
-                    }
-
-                    override fun onQueryEnd() {
-                        _inferenceState.value = InferenceUiState.ReadyGenerate
-                    }
-
-                    override fun onQueryResults(queryResult: RagResult) {
-
-                        _embeddingTime.value = queryResult.embeddingTimeMs / 1000.0
-                        _queryTime.value = queryResult.queryTimeMs / 1000.0
-
-                        val augmentedMessage = insertContextIntoMessage(message, queryResult.documents)
-
-                        // Add user message to history
-                        _chatHistory.value += ChatMessage(message = message, isUserMessage = true)
-                        _isStreaming.value = true
-                        _chatStream.value = listOf()
-
-                        // Add Rag results to history
-                        _chatHistory.value += RagMessage(
-                            documents = queryResult.documents?.map { d -> ChunkDetails(
-                                content = d.first.content,
-                                file = d.first.document,
-                                score = d.second
-                            ) } ?: listOf()
-                        )
-
-                        // Generate with augmented message
-                        // TODO: Should have a cleaner approach
-                        viewModelScope.launch {
-                            inferenceRepository.generate(
-                                userMessage = augmentedMessage
-                            )
-                        }
-                    }
-                })
-
-                // Return @launch so we don't trigger normal generation
-                return@launch
-            }
-
-            // Add user message to history
-            _chatHistory.value += ChatMessage(message = message, isUserMessage = true)
-            _isStreaming.value = true
-            _chatStream.value = listOf()
-
-            // Generate message without RAG
-            inferenceRepository.generate(
-                userMessage = message
-            )
-        }
-    }
-
-    /**
-     * Custom function to insert context into the prompt.
-     */
-    fun insertContextIntoMessage(
-        prompt: String,
-        documents: List<Pair<VectorEntityInterface, Double>>?,
-        maxContextLength: Int = 2000,
-        contextTemplate: String = "\nContext: {context}\n\nQuestion: {question}"
-    ): String {
-        if (documents == null) return prompt
-
-        if (documents.isEmpty()) {
-            return prompt
-        }
-
-        // Sort documents by relevance score (higher scores first)
-        val sortedDocuments = documents.sortedByDescending { it.second }
-
-        // Build context string from documents
-        val contextBuilder = StringBuilder()
-        var currentLength = 0
-
-        for ((document, score) in sortedDocuments) {
-            val content = document.content.trim()
-
-            // Check if adding this document would exceed max length
-            val additionalLength = content.length + 2 // +2 for newlines
-            if (currentLength + additionalLength > maxContextLength) {
-                // Try to fit partial content if there's space
-                val remainingSpace = maxContextLength - currentLength
-                if (remainingSpace > 50) { // Only add if meaningful space remains
-                    val truncatedContent = content.take(remainingSpace - 3) + "..."
-                    contextBuilder.append(truncatedContent)
-                }
-                break
-            }
-
-            // Add document content
-            if (contextBuilder.isNotEmpty()) {
-                contextBuilder.append("\n\n")
-            }
-            contextBuilder.append(content)
-            currentLength += additionalLength
-        }
-
-        val contextText = contextBuilder.toString()
-
-        // Replace placeholders in template
-        return contextTemplate
-            .replace("{context}", contextText)
-            .replace("{question}", prompt)
-    }
-}
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/TrainingViewModel.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/TrainingViewModel.kt
deleted file mode 100644
index 6b784d2..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/viewmodels/TrainingViewModel.kt
+++ /dev/null
@@ -1,143 +0,0 @@
-package com.martinkorelic.orttransformer.viewmodels
-
-import android.util.Log
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.martinkorelic.ortmobile.TrainingProgress
-import com.martinkorelic.ortmobile.repository.LLMRepository
-import com.martinkorelic.ortmobile.repository.TrainingRepository
-import com.martinkorelic.ortmobile.repository.TrainingCallback
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.launch
-
-enum class TrainingUiState {
-    Training,
-    FinishedLoadingData,
-    LoadingModel,
-    FinishedLoadingModel,
-    LoadingData,
-    ReadyTrain,
-    SavingModel,
-    FinishedSavingModel,
-    MergingWeights,
-    FinishedMergingWeights,
-    Error
-}
-
-class TrainingViewModel(private val llmRepository: LLMRepository, private val trainingRepository: TrainingRepository) : ViewModel() {
-
-    private val LOG_TAG = "TrainingViewModel"
-
-    private val _trainingState = MutableStateFlow(TrainingUiState.ReadyTrain)
-    val trainingState: StateFlow<TrainingUiState> = _trainingState
-
-    private val _trainLoss = MutableStateFlow(-1.0f)
-    val trainLoss: StateFlow<Float> = _trainLoss
-
-    private val _currentStepDuration = MutableStateFlow(0L)
-    val currentStepDuration: StateFlow<Long> = _currentStepDuration
-
-    private val _averageStepDuration = MutableStateFlow(0L)
-    val averageStepDuration: StateFlow<Long> = _averageStepDuration
-
-    private val _totalTrainingTime = MutableStateFlow(0L)
-    val totalTrainingTime: StateFlow<Long> = _totalTrainingTime
-
-    private val _currentStep = MutableStateFlow(0)
-    val currentStep: StateFlow<Int> = _currentStep
-
-    private val _currentEpoch = MutableStateFlow(0)
-    val currentEpoch: StateFlow<Int> = _currentEpoch
-
-    private val _learningRate = MutableStateFlow(0F)
-    val learningRate: StateFlow<Float> = _learningRate
-
-    fun startTraining() {
-        viewModelScope.launch {
-            trainingRepository.performTraining(
-                trainingCallback = object : TrainingCallback {
-
-                    override fun onModelLoadStart() {
-                        _trainingState.value = TrainingUiState.LoadingModel
-                    }
-
-                    override fun onModelLoadEnd() {
-                        _trainingState.value = TrainingUiState.FinishedLoadingModel
-                    }
-
-                    override fun onDataLoadStart() {
-                        _trainingState.value = TrainingUiState.LoadingData
-                    }
-
-                    override fun onDataLoadEnd(totalSteps: Int, stepsPerEpoch: Int) {
-                        _trainingState.value = TrainingUiState.FinishedLoadingData
-                    }
-
-                    override fun onSaveModelStart(trainingProgress: TrainingProgress) {
-                        _trainingState.value = TrainingUiState.SavingModel
-                    }
-
-                    override fun onSaveModelEnd(trainingProgress: TrainingProgress) {
-                        _trainingState.value = TrainingUiState.FinishedSavingModel
-                    }
-
-                    override fun onStepStart(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Step start")
-                        _currentStep.value = trainingProgress.currentStep
-                        _currentEpoch.value = trainingProgress.currentEpoch
-                    }
-
-                    override fun onStepEnd(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Step end")
-                        _trainLoss.value = trainingProgress.stepLoss
-                        _currentStepDuration.value = trainingProgress.stepDurationMs
-                        _totalTrainingTime.value = trainingProgress.totalDurationMs
-                        _learningRate.value = trainingProgress.learningRate
-
-                        // Calculate average step duration
-                        if (trainingProgress.currentStep > 0) {
-                            _averageStepDuration.value = trainingProgress.totalDurationMs / (trainingProgress.currentStep + 1)
-                        }
-                    }
-
-                    override fun onEpochStart(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Epoch start")
-                        _trainingState.value = TrainingUiState.Training
-                        _currentEpoch.value = trainingProgress.currentEpoch
-                    }
-
-                    override fun onEpochEnd(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Epoch end")
-                    }
-
-                    override fun onMergeStart(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Merge start")
-                        _trainingState.value = TrainingUiState.MergingWeights
-                    }
-
-                    override fun onMergeEnd(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "Merge end")
-                        _trainingState.value = TrainingUiState.FinishedMergingWeights
-                    }
-
-                    override fun onCompletion(trainingProgress: TrainingProgress) {
-                        Log.d(LOG_TAG, "On completion")
-                        _trainingState.value = TrainingUiState.ReadyTrain
-                    }
-
-                    override fun onError(error: Throwable) {
-                        Log.d(LOG_TAG, "On Error", error)
-                        _trainingState.value = TrainingUiState.Error
-                    }
-                }
-            )
-        }
-    }
-
-    fun endTraining(saveModel: Boolean) {
-        viewModelScope.launch {
-            trainingRepository.endTraining(saveModel)
-        }
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/ConfigurationScreen.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/ConfigurationScreen.kt
deleted file mode 100644
index c83f913..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/ConfigurationScreen.kt
+++ /dev/null
@@ -1,1092 +0,0 @@
-package com.martinkorelic.orttransformer.views
-
-import android.widget.Toast
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material3.Card
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExposedDropdownMenuBox
-import androidx.compose.material3.ExposedDropdownMenuDefaults
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.OutlinedTextFieldDefaults
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Tab
-import androidx.compose.material3.TabRow
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.unit.dp
-import com.martinkorelic.ortmobile.DeviceOptions
-import com.martinkorelic.ortmobile.ORTRagConfig
-import com.martinkorelic.ortmobile.SamplingOptions
-import com.martinkorelic.ortmobile.SchedulerConfig
-import com.martinkorelic.orttransformer.viewmodels.ConfigurationViewModel
-
-
-// ConfigurationScreen.kt
-@Composable
-fun ConfigurationScreen(viewModel: ConfigurationViewModel) {
-    var selectedConfigTab by remember { mutableStateOf(0) }
-    val configTabs = listOf("Generation Config", "Training Config")
-
-    Column(modifier = Modifier
-        .fillMaxSize()
-        .padding(16.dp)) {
-        TabRow(selectedTabIndex = selectedConfigTab) {
-            configTabs.forEachIndexed { index, title ->
-                Tab(
-                    selected = selectedConfigTab == index,
-                    onClick = { selectedConfigTab = index },
-                    text = { Text(title) }
-                )
-            }
-        }
-
-        Spacer(modifier = Modifier.height(16.dp))
-
-        when (selectedConfigTab) {
-            0 -> GenerationConfigScreen(viewModel)
-            1 -> TrainingConfigScreen(viewModel)
-        }
-    }
-}
-
-@Composable
-fun GenerationConfigScreen(viewModel: ConfigurationViewModel) {
-    val config = viewModel.generationConfig.value
-    val ragConfig = viewModel.ragConfig.value
-    val availableModels = viewModel.availableModels
-    val ragEnabled = viewModel.ragEnabled.value
-    val isRagAvailable = viewModel.isRagAvailable.value
-
-    LazyColumn(
-        modifier = Modifier.fillMaxSize(),
-        verticalArrangement = Arrangement.spacedBy(12.dp)
-    ) {
-        item {
-            Card(modifier = Modifier.fillMaxWidth()) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Model Configuration",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-
-                    // Model Name Dropdown
-                    ModelDropdown(
-                        selectedModel = config.repoName,
-                        availableModels = availableModels,
-                        onModelSelected = { viewModel.onGenerationModelChanged(it) },
-                        label = "Model Name"
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    // Type Dropdown
-                    TypeDropdown(
-                        selectedType = config.type,
-                        onTypeSelected = {
-                            viewModel.updateGenerationConfig(config.copy(type = it))
-                        }
-                    )
-                }
-            }
-        }
-
-        item {
-            Card(modifier = Modifier.fillMaxWidth()) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Generation Settings",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-
-                    // Max Sequence Length
-                    IntegerField(
-                        value = config.maxSequenceLength,
-                        onValueChange = {
-                            viewModel.updateGenerationConfig(config.copy(maxSequenceLength = it))
-                        },
-                        label = "Max Sequence Length"
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    // Time Step Update
-                    IntegerField(
-                        value = config.timeStepUpdate,
-                        onValueChange = {
-                            viewModel.updateGenerationConfig(config.copy(timeStepUpdate = it))
-                        },
-                        label = "Time Step Update"
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    // System Prompt
-                    OutlinedTextField(
-                        value = config.systemPrompt ?: "",
-                        onValueChange = {
-                            viewModel.updateGenerationConfig(
-                                config.copy(systemPrompt = it.takeIf { it.isNotBlank() })
-                            )
-                        },
-                        label = { Text("System Prompt") },
-                        modifier = Modifier.fillMaxWidth(),
-                        minLines = 3
-                    )
-
-                    Spacer(modifier = Modifier.height(12.dp))
-
-                    // Checkboxes
-                    Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.SpaceBetween
-                    ) {
-                        CheckboxWithLabel(
-                            checked = config.trackMetrics,
-                            onCheckedChange = {
-                                viewModel.updateGenerationConfig(config.copy(trackMetrics = it))
-                            },
-                            label = "Track Metrics"
-                        )
-
-                        CheckboxWithLabel(
-                            checked = config.loadMergedWeights,
-                            onCheckedChange = {
-                                viewModel.updateGenerationConfig(config.copy(loadMergedWeights = it))
-                            },
-                            label = "Load Merged Weights"
-                        )
-                    }
-                }
-            }
-        }
-        
-        item { 
-           RagConfigurationCard(ragConfig = ragConfig, ragEnabled = ragEnabled && isRagAvailable, onRagEnabledChanged = { enabled ->
-               viewModel.updateRagEnabled(enabled)
-           }, onRagConfigChanged = { newConfig ->
-               viewModel.updateRagConfig(newConfig)
-           })
-        }
-
-        item {
-            SamplingOptionsCard(
-                sampling = config.sampling,
-                onSamplingChanged = {
-                    viewModel.updateGenerationConfig(config.copy(sampling = it))
-                }
-            )
-        }
-
-        item {
-            DeviceOptionsCard(
-                deviceOptions = config.deviceOptions,
-                onDeviceOptionsChanged = {
-                    viewModel.updateGenerationConfig(config.copy(deviceOptions = it))
-                },
-                isInference = true
-            )
-        }
-    }
-}
-
-@Composable
-fun TrainingConfigScreen(viewModel: ConfigurationViewModel) {
-    val config = viewModel.trainingConfig.value
-    val availableModels = viewModel.availableModels
-
-    LazyColumn(
-        modifier = Modifier.fillMaxSize(),
-        verticalArrangement = Arrangement.spacedBy(12.dp)
-    ) {
-        item {
-            Card(modifier = Modifier.fillMaxWidth()) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Model Configuration",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-
-                    // Model Name Dropdown
-                    ModelDropdown(
-                        selectedModel = config.repoName,
-                        availableModels = availableModels,
-                        onModelSelected = { viewModel.onTrainingModelChanged(it) },
-                        label = "Model Name"
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    // Task Name
-                    OutlinedTextField(
-                        value = config.taskName,
-                        onValueChange = {
-                            viewModel.updateTrainingConfig(config.copy(taskName = it))
-                        },
-                        label = { Text("Task Name") },
-                        modifier = Modifier.fillMaxWidth()
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    // Train File
-                    OutlinedTextField(
-                        value = config.datasetOptions.trainFile,
-                        onValueChange = {
-                            viewModel.updateTrainingConfig(
-                                config.copy(
-                                    datasetOptions = config.datasetOptions.copy(trainFile = it)
-                                )
-                            )
-                        },
-                        label = { Text("Train File") },
-                        modifier = Modifier.fillMaxWidth()
-                    )
-                }
-            }
-        }
-
-        item {
-            Card(modifier = Modifier.fillMaxWidth()) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Training Parameters",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        IntegerField(
-                            value = config.batchSize,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(config.copy(batchSize = it))
-                            },
-                            label = "Batch Size",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        IntegerField(
-                            value = config.numTrainEpochs,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(config.copy(numTrainEpochs = it))
-                            },
-                            label = "Epochs",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        IntegerField(
-                            value = config.datasetOptions.maxSequenceLength ?: 0,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(
-                                    config.copy(
-                                        datasetOptions = config.datasetOptions.copy(maxSequenceLength = it)
-                                    )
-                                )
-                            },
-                            label = "Max Seq Length",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        NullableIntegerField(
-                            value = config.maxSteps,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(config.copy(maxSteps = it))
-                            },
-                            label = "Max Steps",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        IntegerField(
-                            value = config.saveSteps,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(config.copy(saveSteps = it))
-                            },
-                            label = "Save Steps",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        IntegerField(
-                            value = config.gradAccumSteps,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(config.copy(gradAccumSteps = it))
-                            },
-                            label = "Grad Accum Steps",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-                }
-            }
-        }
-
-        item {
-            Card(modifier = Modifier.fillMaxWidth()) {
-                Column(modifier = Modifier.padding(16.dp)) {
-                    Text(
-                        text = "Dataset Configuration",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        IntegerField(
-                            value = config.datasetOptions.maxDatasetLength ?: 0,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(
-                                    config.copy(
-                                        datasetOptions = config.datasetOptions.copy(maxDatasetLength = it)
-                                    )
-                                )
-                            },
-                            label = "Max Dataset Length",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        IntegerField(
-                            value = config.datasetOptions.datasetBatchSize ?: 0,
-                            onValueChange = {
-                                viewModel.updateTrainingConfig(
-                                    config.copy(
-                                        datasetOptions = config.datasetOptions.copy(datasetBatchSize = it)
-                                    )
-                                )
-                            },
-                            label = "Dataset Batch Size",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-
-                    Spacer(modifier = Modifier.height(12.dp))
-
-                    // Checkboxes
-                    Column {
-                        CheckboxWithLabel(
-                            checked = config.datasetOptions.removeLongSamples,
-                            onCheckedChange = {
-                                viewModel.updateTrainingConfig(
-                                    config.copy(
-                                        datasetOptions = config.datasetOptions.copy(removeLongSamples = it)
-                                    )
-                                )
-                            },
-                            label = "Remove Long Samples"
-                        )
-
-                        CheckboxWithLabel(
-                            checked = config.mergeWeightsAtEnd,
-                            onCheckedChange = {
-                                viewModel.updateTrainingConfig(config.copy(mergeWeightsAtEnd = it))
-                            },
-                            label = "Merge Weights at End"
-                        )
-
-                        CheckboxWithLabel(
-                            checked = config.saveModelAtEnd,
-                            onCheckedChange = {
-                                viewModel.updateTrainingConfig(config.copy(saveModelAtEnd = it))
-                            },
-                            label = "Save Model at End"
-                        )
-                    }
-                }
-            }
-        }
-
-        item {
-            SchedulerConfigCard(
-                schedulerType = config.schedulerType,
-                schedulerConfig = config.schedulerConfig,
-                onSchedulerChanged = { type, schedulerConfig ->
-                    viewModel.updateTrainingConfig(
-                        config.copy(
-                            schedulerType = type,
-                            schedulerConfig = schedulerConfig
-                        )
-                    )
-                }
-            )
-        }
-
-        item {
-            DeviceOptionsCard(
-                deviceOptions = config.deviceOptions,
-                onDeviceOptionsChanged = {
-                    viewModel.updateTrainingConfig(config.copy(deviceOptions = it))
-                }
-            )
-        }
-    }
-}
-
-// Helper Composables
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun ModelDropdown(
-    selectedModel: String,
-    availableModels: List<String>,
-    onModelSelected: (String) -> Unit,
-    label: String,
-    modifier: Modifier = Modifier
-) {
-    var expanded by remember { mutableStateOf(false) }
-
-    ExposedDropdownMenuBox(
-        expanded = expanded,
-        onExpandedChange = { expanded = !expanded },
-        modifier = modifier
-    ) {
-        OutlinedTextField(
-            value = selectedModel,
-            onValueChange = {},
-            readOnly = true,
-            label = { Text(label) },
-            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
-            modifier = Modifier
-                .fillMaxWidth()
-                .menuAnchor()
-        )
-        ExposedDropdownMenu(
-            expanded = expanded,
-            onDismissRequest = { expanded = false }
-        ) {
-            availableModels.forEach { model ->
-                DropdownMenuItem(
-                    text = { Text(model) },
-                    onClick = {
-                        onModelSelected(model)
-                        expanded = false
-                    }
-                )
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun TypeDropdown(
-    selectedType: String,
-    onTypeSelected: (String) -> Unit
-) {
-    var expanded by remember { mutableStateOf(false) }
-    val types = listOf("native")
-
-    ExposedDropdownMenuBox(
-        expanded = expanded,
-        onExpandedChange = { expanded = !expanded }
-    ) {
-        OutlinedTextField(
-            value = selectedType,
-            onValueChange = {},
-            readOnly = true,
-            label = { Text("Type") },
-            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
-            modifier = Modifier
-                .fillMaxWidth()
-                .menuAnchor()
-        )
-        ExposedDropdownMenu(
-            expanded = expanded,
-            onDismissRequest = { expanded = false }
-        ) {
-            types.forEach { type ->
-                DropdownMenuItem(
-                    text = { Text(type) },
-                    onClick = {
-                        onTypeSelected(type)
-                        expanded = false
-                    }
-                )
-            }
-        }
-    }
-}
-
-@Composable
-fun IntegerField(
-    value: Int,
-    onValueChange: (Int) -> Unit,
-    label: String,
-    modifier: Modifier = Modifier,
-    enabled : Boolean = true
-) {
-    OutlinedTextField(
-        value = value.toString(),
-        onValueChange = { newValue ->
-            newValue.toIntOrNull()?.let { onValueChange(it) }
-        },
-        label = { Text(label) },
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-        modifier = modifier,
-        enabled = enabled
-    )
-}
-
-@Composable
-fun NullableIntegerField(
-    value: Int?,
-    onValueChange: (Int?) -> Unit,
-    label: String,
-    modifier: Modifier = Modifier
-) {
-    OutlinedTextField(
-        value = value?.toString() ?: "",
-        onValueChange = { newValue ->
-            if (newValue.isBlank()) {
-                onValueChange(null)
-            } else {
-                newValue.toIntOrNull()?.let { onValueChange(it) }
-            }
-        },
-        label = { Text(label) },
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-        modifier = modifier
-    )
-}
-
-@Composable
-fun FloatField(
-    value: Float,
-    onValueChange: (Float) -> Unit,
-    label: String,
-    modifier: Modifier = Modifier
-) {
-    OutlinedTextField(
-        value = value.toString(),
-        onValueChange = { newValue ->
-            newValue.toFloatOrNull()?.let { onValueChange(it) }
-        },
-        label = { Text(label) },
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-        modifier = modifier
-    )
-}
-
-@Composable
-fun CheckboxWithLabel(
-    checked: Boolean,
-    onCheckedChange: (Boolean) -> Unit,
-    label: String,
-    modifier: Modifier = Modifier
-) {
-    Row(
-        modifier = modifier,
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Checkbox(
-            checked = checked,
-            onCheckedChange = onCheckedChange
-        )
-        Spacer(modifier = Modifier.width(8.dp))
-        Text(text = label)
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun SamplingOptionsCard(
-    sampling: SamplingOptions,
-    onSamplingChanged: (SamplingOptions) -> Unit
-) {
-    Card(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(16.dp)) {
-            Text(
-                text = "Sampling Options",
-                style = MaterialTheme.typography.headlineSmall,
-                modifier = Modifier.padding(bottom = 12.dp)
-            )
-
-            // Method Dropdown
-            var methodExpanded by remember { mutableStateOf(false) }
-            val methods = listOf("greedy", "top_p", "top_k")
-
-            ExposedDropdownMenuBox(
-                expanded = methodExpanded,
-                onExpandedChange = { methodExpanded = !methodExpanded }
-            ) {
-                OutlinedTextField(
-                    value = sampling.method,
-                    onValueChange = {},
-                    readOnly = true,
-                    label = { Text("Sampling Method") },
-                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = methodExpanded) },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor()
-                )
-                ExposedDropdownMenu(
-                    expanded = methodExpanded,
-                    onDismissRequest = { methodExpanded = false }
-                ) {
-                    methods.forEach { method ->
-                        DropdownMenuItem(
-                            text = { Text(method) },
-                            onClick = {
-                                onSamplingChanged(sampling.copy(method = method))
-                                methodExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            Row(modifier = Modifier.fillMaxWidth()) {
-                FloatField(
-                    value = sampling.temperature,
-                    onValueChange = { onSamplingChanged(sampling.copy(temperature = it)) },
-                    label = "Temperature",
-                    modifier = Modifier.weight(1f)
-                )
-
-                Spacer(modifier = Modifier.width(8.dp))
-
-                FloatField(
-                    value = sampling.topP,
-                    onValueChange = { onSamplingChanged(sampling.copy(topP = it)) },
-                    label = "Top P",
-                    modifier = Modifier.weight(1f)
-                )
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            Row(modifier = Modifier.fillMaxWidth()) {
-                IntegerField(
-                    value = sampling.topK,
-                    onValueChange = { onSamplingChanged(sampling.copy(topK = it)) },
-                    label = "Top K",
-                    modifier = Modifier.weight(1f)
-                )
-
-                Spacer(modifier = Modifier.width(8.dp))
-
-                IntegerField(
-                    value = sampling.seed,
-                    onValueChange = { onSamplingChanged(sampling.copy(seed = it)) },
-                    label = "Seed",
-                    modifier = Modifier.weight(1f)
-                )
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun DeviceOptionsCard(
-    deviceOptions: DeviceOptions,
-    onDeviceOptionsChanged: (DeviceOptions) -> Unit,
-    isInference: Boolean = false
-) {
-    val context = LocalContext.current
-
-    Card(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(16.dp)) {
-            Text(
-                text = "Device Options",
-                style = MaterialTheme.typography.headlineSmall,
-                modifier = Modifier.padding(bottom = 12.dp)
-            )
-
-            // Execution Provider Dropdown
-            var providerExpanded by remember { mutableStateOf(false) }
-            val providers = listOf("cpu", "nnapi", "xnnpack")
-
-            ExposedDropdownMenuBox(
-                expanded = providerExpanded,
-                onExpandedChange = { providerExpanded = !providerExpanded }
-            ) {
-                OutlinedTextField(
-                    value = deviceOptions.executionProvider,
-                    onValueChange = {},
-                    readOnly = true,
-                    label = { Text("Execution Provider") },
-                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = providerExpanded) },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor()
-                )
-                ExposedDropdownMenu(
-                    expanded = providerExpanded,
-                    onDismissRequest = { providerExpanded = false }
-                ) {
-                    providers.forEach { provider ->
-                        DropdownMenuItem(
-                            text = { Text(provider) },
-                            onClick = {
-                                onDeviceOptionsChanged(deviceOptions.copy(executionProvider = provider))
-                                providerExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            // Core Config ID Dropdown (opt1, opt2, opt3)
-            var coreConfigExpanded by remember { mutableStateOf(false) }
-            val coreConfigs = listOf("opt1", "opt2", "opt3")
-
-            ExposedDropdownMenuBox(
-                expanded = coreConfigExpanded,
-                onExpandedChange = { coreConfigExpanded = !coreConfigExpanded }
-            ) {
-                OutlinedTextField(
-                    value = deviceOptions.coreConfigId,
-                    onValueChange = {},
-                    readOnly = true,
-                    label = { Text("Core Config ID") },
-                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = coreConfigExpanded) },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor()
-                )
-                ExposedDropdownMenu(
-                    expanded = coreConfigExpanded,
-                    onDismissRequest = { coreConfigExpanded = false }
-                ) {
-                    coreConfigs.forEach { config ->
-                        DropdownMenuItem(
-                            text = { Text(config) },
-                            onClick = {
-                                onDeviceOptionsChanged(deviceOptions.copy(coreConfigId = config))
-                                coreConfigExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            // Memory Config ID Dropdown (high_perf, low_mem)
-            var memoryConfigExpanded by remember { mutableStateOf(false) }
-            val memoryConfigs = listOf("high_perf", "low_mem")
-
-            ExposedDropdownMenuBox(
-                expanded = memoryConfigExpanded,
-                onExpandedChange = { memoryConfigExpanded = !memoryConfigExpanded }
-            ) {
-                OutlinedTextField(
-                    value = deviceOptions.memoryConfigId,
-                    onValueChange = {},
-                    readOnly = true,
-                    label = { Text("Memory Config ID") },
-                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = memoryConfigExpanded) },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor()
-                )
-                ExposedDropdownMenu(
-                    expanded = memoryConfigExpanded,
-                    onDismissRequest = { memoryConfigExpanded = false }
-                ) {
-                    memoryConfigs.forEach { config ->
-                        DropdownMenuItem(
-                            text = { Text(config) },
-                            onClick = {
-                                // Show warning toast if high_perf is selected in inference mode
-                                if (isInference && config == "low_mem") {
-                                    Toast.makeText(
-                                        context,
-                                        "Warning: Low memory option is very likely to cause a crash with inference!",
-                                        Toast.LENGTH_LONG
-                                    ).show()
-                                }
-                                onDeviceOptionsChanged(deviceOptions.copy(memoryConfigId = config))
-                                memoryConfigExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            CheckboxWithLabel(
-                checked = deviceOptions.enableProfiling,
-                onCheckedChange = {
-                    onDeviceOptionsChanged(deviceOptions.copy(enableProfiling = it))
-                },
-                label = "Enable Profiling"
-            )
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun RagConfigurationCard(
-    ragConfig: ORTRagConfig,
-    ragEnabled: Boolean,
-    onRagEnabledChanged: (Boolean) -> Unit,
-    onRagConfigChanged: (ORTRagConfig) -> Unit
-) {
-    Card(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(16.dp)) {
-            Text(
-                text = "RAG Configuration",
-                style = MaterialTheme.typography.headlineSmall,
-                modifier = Modifier.padding(bottom = 12.dp)
-            )
-
-            // Enable RAG Switch
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                Text(
-                    text = "Enable RAG",
-                    style = MaterialTheme.typography.bodyLarge
-                )
-                Switch(
-                    checked = ragEnabled,
-                    onCheckedChange = onRagEnabledChanged
-                )
-            }
-
-            Spacer(modifier = Modifier.height(12.dp))
-
-            // Search Type Dropdown
-            var searchTypeExpanded by remember { mutableStateOf(false) }
-            val searchTypes = listOf("semantic", "text")
-
-            ExposedDropdownMenuBox(
-                expanded = searchTypeExpanded,
-                onExpandedChange = {
-                    if (ragEnabled) searchTypeExpanded = !searchTypeExpanded
-                }
-            ) {
-                OutlinedTextField(
-                    value = ragConfig.searchType,
-                    onValueChange = {},
-                    readOnly = true,
-                    enabled = ragEnabled,
-                    label = { Text("Search Type") },
-                    trailingIcon = {
-                        ExposedDropdownMenuDefaults.TrailingIcon(
-                            expanded = searchTypeExpanded
-                        )
-                    },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor(),
-                    colors = OutlinedTextFieldDefaults.colors(
-                        disabledTextColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f),
-                        disabledBorderColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
-                        disabledLabelColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f)
-                    )
-                )
-                ExposedDropdownMenu(
-                    expanded = searchTypeExpanded,
-                    onDismissRequest = { searchTypeExpanded = false }
-                ) {
-                    searchTypes.forEach { searchType ->
-                        DropdownMenuItem(
-                            text = { Text(searchType) },
-                            onClick = {
-                                onRagConfigChanged(ragConfig.copy(searchType = searchType))
-                                searchTypeExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            // Top K Field
-            IntegerField(
-                value = ragConfig.topK,
-                onValueChange = { onRagConfigChanged(ragConfig.copy(topK = it)) },
-                label = "Top K Results",
-                enabled = ragEnabled,
-                modifier = Modifier.fillMaxWidth()
-            )
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun SchedulerConfigCard(
-    schedulerType: String,
-    schedulerConfig: SchedulerConfig,
-    onSchedulerChanged: (String, SchedulerConfig) -> Unit
-) {
-    Card(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(16.dp)) {
-            Text(
-                text = "Scheduler Configuration",
-                style = MaterialTheme.typography.headlineSmall,
-                modifier = Modifier.padding(bottom = 12.dp)
-            )
-
-            // Scheduler Type Dropdown
-            var typeExpanded by remember { mutableStateOf(false) }
-            val types = listOf("linear", "cosine")
-
-            ExposedDropdownMenuBox(
-                expanded = typeExpanded,
-                onExpandedChange = { typeExpanded = !typeExpanded }
-            ) {
-                OutlinedTextField(
-                    value = schedulerType,
-                    onValueChange = {},
-                    readOnly = true,
-                    label = { Text("Scheduler Type") },
-                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = typeExpanded) },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .menuAnchor()
-                )
-                ExposedDropdownMenu(
-                    expanded = typeExpanded,
-                    onDismissRequest = { typeExpanded = false }
-                ) {
-                    types.forEach { type ->
-                        DropdownMenuItem(
-                            text = { Text(type) },
-                            onClick = {
-                                val newConfig = when (type) {
-                                    "linear" -> SchedulerConfig.Linear()
-                                    "cosine" -> SchedulerConfig.Cosine()
-                                    else -> schedulerConfig
-                                }
-                                onSchedulerChanged(type, newConfig)
-                                typeExpanded = false
-                            }
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(12.dp))
-
-            when (schedulerConfig) {
-                is SchedulerConfig.Linear -> {
-                    Text(
-                        text = "Linear Scheduler",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 8.dp)
-                    )
-
-                    FloatField(
-                        value = schedulerConfig.learningRate,
-                        onValueChange = {
-                            onSchedulerChanged(schedulerType, schedulerConfig.copy(learningRate = it))
-                        },
-                        label = "Learning Rate",
-                        modifier = Modifier.fillMaxWidth()
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        FloatField(
-                            value = schedulerConfig.startFactor,
-                            onValueChange = {
-                                onSchedulerChanged(schedulerType, schedulerConfig.copy(startFactor = it))
-                            },
-                            label = "Start Factor",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        FloatField(
-                            value = schedulerConfig.endFactor,
-                            onValueChange = {
-                                onSchedulerChanged(schedulerType, schedulerConfig.copy(endFactor = it))
-                            },
-                            label = "End Factor",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-                }
-                is SchedulerConfig.Cosine -> {
-                    Text(
-                        text = "Cosine Scheduler",
-                        style = MaterialTheme.typography.headlineSmall,
-                        modifier = Modifier.padding(bottom = 8.dp)
-                    )
-
-                    FloatField(
-                        value = schedulerConfig.learningRate,
-                        onValueChange = {
-                            onSchedulerChanged(schedulerType, schedulerConfig.copy(learningRate = it))
-                        },
-                        label = "Learning Rate",
-                        modifier = Modifier.fillMaxWidth()
-                    )
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    Row(modifier = Modifier.fillMaxWidth()) {
-                        FloatField(
-                            value = schedulerConfig.minLearningRate,
-                            onValueChange = {
-                                onSchedulerChanged(schedulerType, schedulerConfig.copy(minLearningRate = it))
-                            },
-                            label = "Min Learning Rate",
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Spacer(modifier = Modifier.width(8.dp))
-
-                        IntegerField(
-                            value = schedulerConfig.warmupSteps,
-                            onValueChange = {
-                                onSchedulerChanged(schedulerType, schedulerConfig.copy(warmupSteps = it))
-                            },
-                            label = "Warmup Steps",
-                            modifier = Modifier.weight(1f)
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/InferenceScreen.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/InferenceScreen.kt
deleted file mode 100644
index f32bc23..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/InferenceScreen.kt
+++ /dev/null
@@ -1,529 +0,0 @@
-package com.martinkorelic.orttransformer.views
-
-import android.widget.Toast
-import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.KeyboardArrowDown
-import androidx.compose.material.icons.filled.KeyboardArrowUp
-import androidx.compose.material.icons.filled.Refresh
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.TextField
-import androidx.compose.material3.TextFieldDefaults
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.martinkorelic.orttransformer.viewmodels.ChatMessage
-import com.martinkorelic.orttransformer.viewmodels.ConfigurationViewModel
-import com.martinkorelic.orttransformer.viewmodels.InferenceUiState
-import com.martinkorelic.orttransformer.viewmodels.InferenceViewModel
-import com.martinkorelic.orttransformer.viewmodels.RagMessage
-
-
-@Composable
-fun InferenceScreen(viewModel: InferenceViewModel, configurationViewModel: ConfigurationViewModel) {
-    var chatInput by remember { mutableStateOf(TextFieldValue("")) }
-    val chatHistory by viewModel.chatHistory.collectAsState()
-    val chatStream by viewModel.chatStream.collectAsState()
-    val isStreaming by viewModel.isStreaming.collectAsState()
-    val inferenceState by viewModel.inferenceState.collectAsState()
-
-    val ttlmTime by viewModel.ttlmTime.collectAsState()
-    val prefillTime by viewModel.prefillTime.collectAsState()
-    val generationTime by viewModel.generationTime.collectAsState()
-    val queryTime by viewModel.queryTime.collectAsState()
-    val embeddingTime by viewModel.embeddingTime.collectAsState()
-
-    val ragEnabled = configurationViewModel.ragEnabled.value
-
-    val keyboardController = LocalSoftwareKeyboardController.current
-    val context = LocalContext.current
-
-    Column(modifier = Modifier
-        .fillMaxSize()
-        .background(Color.White)
-        .padding(16.dp)
-        ) {
-
-        Column (
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(bottom = 16.dp)
-        ) {
-            // Compact metrics display
-            CompactMetricsCard(
-                inferenceState = inferenceState,
-                ttlmTime = ttlmTime,
-                prefillTime = prefillTime,
-                generationTime = generationTime,
-                queryTime = queryTime,
-                embeddingTime = embeddingTime,
-                showRagMetrics = ragEnabled,
-                modifier = Modifier.padding(bottom = 16.dp)
-            )
-        }
-
-        LazyColumn(
-            modifier = Modifier.weight(1f),
-            contentPadding = PaddingValues(bottom = 16.dp)
-        ) {
-            items(chatHistory) { message ->
-                when (message) {
-                    is ChatMessage -> ChatBubble(message = message)
-                    is RagMessage -> RagSourcesCard(ragMessage = message)
-                }
-            }
-            // Show the current streaming message if available
-            if (isStreaming) {
-                chatStream.let { streamingMessage ->
-                    item {
-                        ChatBubble(message = ChatMessage(message = streamingMessage.joinToString(separator = ""), isUserMessage = false))
-                    }
-                }
-            }
-        }
-
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            TextField(
-                enabled = inferenceState == InferenceUiState.ReadyGenerate,
-                value = chatInput,
-                onValueChange = { chatInput = it },
-                modifier = Modifier.weight(1f),
-                placeholder = { Text("Enter message", color = MaterialTheme.colorScheme.primary) },
-                colors = TextFieldDefaults.colors(
-                    focusedTextColor = MaterialTheme.colorScheme.secondary,
-                    unfocusedTextColor = MaterialTheme.colorScheme.secondary,
-                    disabledTextColor = Color.Gray,
-                    focusedContainerColor = Color.White,
-                    unfocusedContainerColor = Color.White,
-                    disabledContainerColor = Color.White.copy(alpha = 0.7f),
-                    focusedIndicatorColor = MaterialTheme.colorScheme.primary,
-                    unfocusedIndicatorColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.7f),
-                    disabledIndicatorColor = Color.Gray,
-                    cursorColor = MaterialTheme.colorScheme.primary
-                )
-            )
-
-            Button(
-                enabled = inferenceState == InferenceUiState.ReadyGenerate,
-                onClick = {
-                    keyboardController?.hide()
-                    viewModel.sendMessage(chatInput.text, ragEnabled)
-                    chatInput = TextFieldValue("")
-                },
-                modifier = Modifier.padding(start = 8.dp),
-                colors = ButtonDefaults.buttonColors(
-                    containerColor = MaterialTheme.colorScheme.primary,
-                    contentColor = Color.White
-                )
-            ) {
-                Text("Send", color = Color.White)
-            }
-        }
-
-        Spacer(modifier = Modifier.height(8.dp))
-
-        // Second Row: Reload Button
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            horizontalArrangement = Arrangement.SpaceAround
-        ) {
-            // RAG Toggle Button
-            Button(
-                enabled = inferenceState == InferenceUiState.ReadyGenerate && configurationViewModel.isRagAvailable.value,
-                onClick = {
-                    configurationViewModel.updateRagEnabled(!ragEnabled)
-                },
-                modifier = Modifier.padding(start = 8.dp),
-                colors = ButtonDefaults.buttonColors(
-                    containerColor = if (ragEnabled && configurationViewModel.isRagAvailable.value) {
-                        MaterialTheme.colorScheme.primary
-                    } else {
-                        MaterialTheme.colorScheme.outline
-                    },
-                    contentColor = if (ragEnabled && configurationViewModel.isRagAvailable.value) {
-                        Color.White
-                    } else {
-                        MaterialTheme.colorScheme.onSurface
-                    },
-                    disabledContainerColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.12f),
-                    disabledContentColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f)
-                )
-            ) {
-                Text(
-                    text = if (ragEnabled) "RAG ON" else "RAG OFF",
-                    fontSize = 12.sp
-                )
-            }
-            Button(
-                enabled = inferenceState == InferenceUiState.ReadyGenerate,
-                onClick = {
-                    keyboardController?.hide()
-                    Toast.makeText(context, "Reloading model...", Toast.LENGTH_SHORT).show()
-                    viewModel.reloadInferenceSession()
-                    chatInput = TextFieldValue("")
-                },
-                colors = ButtonDefaults.buttonColors(
-                    containerColor = MaterialTheme.colorScheme.primary,
-                    contentColor = Color.White
-                )
-            ) {
-                Icon(
-                    Icons.Default.Refresh,
-                    contentDescription = "Reload",
-                    modifier = Modifier.size(16.dp)
-                )
-                Spacer(modifier = Modifier.width(4.dp))
-                Text("Reload")
-            }
-        }
-    }
-}
-
-@Composable
-fun ChatBubble(message: ChatMessage) {
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(8.dp)
-            //.align(if (message.isUserMessage) Alignment.End else Alignment.Start)
-    ) {
-        Surface(
-            modifier = Modifier
-                .padding(8.dp)
-                .border(
-                    width = 1.dp,
-                    color = MaterialTheme.colorScheme.primary, // Change to your desired border color
-                    shape = MaterialTheme.shapes.medium
-                ),
-            color = if (message.isUserMessage) Color.White else MaterialTheme.colorScheme.primary,
-
-            shape = MaterialTheme.shapes.medium
-        ) {
-            Text(
-                text = message.message,
-                color = if (message.isUserMessage) MaterialTheme.colorScheme.primary else Color.White,
-                fontSize = 16.sp,
-                textAlign = TextAlign.Start,
-                modifier = Modifier.padding(16.dp) // This padding applies to the text within the bubble
-            )
-        }
-    }
-}
-
-// Compact metrics card
-@Composable
-fun CompactMetricsCard(
-    inferenceState: InferenceUiState,
-    ttlmTime: Double,
-    prefillTime: Double,
-    generationTime: Double,
-    queryTime: Double,
-    embeddingTime: Double,
-    showRagMetrics: Boolean,
-    modifier: Modifier = Modifier
-) {
-    Surface(
-        modifier = modifier.fillMaxWidth(),
-        color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f),
-        shape = RoundedCornerShape(8.dp)
-    ) {
-        Column(
-            modifier = Modifier.padding(12.dp)
-        ) {
-            // Status row
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    text = "Status:",
-                    style = MaterialTheme.typography.labelMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-
-                StatusChip(inferenceState = inferenceState)
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            // Metrics in separate rows
-            CompactMetricItem(
-                label = "Model Load",
-                value = "%.2f s".format(ttlmTime)
-            )
-
-            CompactMetricItem(
-                label = "Prefill",
-                value = "%.2f s".format(prefillTime)
-            )
-
-            CompactMetricItem(
-                label = "Generation",
-                value = "%.2f tokens/s".format(generationTime)
-            )
-
-            // RAG metrics - only show when enabled
-            if (showRagMetrics) {
-                CompactMetricItem(
-                    label = "Embedding",
-                    value = "%.3f s".format(embeddingTime)
-                )
-                CompactMetricItem(
-                    label = "DB Query",
-                    value = "%.3f s".format(queryTime)
-                )
-            }
-        }
-    }
-}
-
-@Composable
-fun StatusChip(inferenceState: InferenceUiState) {
-    val (text, color) = when (inferenceState) {
-        InferenceUiState.LoadingModel -> "Loading Model" to MaterialTheme.colorScheme.tertiary
-        InferenceUiState.LoadingRetriever -> "Loading RAG" to MaterialTheme.colorScheme.tertiary
-        InferenceUiState.FinishedLoadingModel -> "Model Ready" to MaterialTheme.colorScheme.primary
-        InferenceUiState.Querying -> "DB Query" to MaterialTheme.colorScheme.secondary
-        InferenceUiState.ReadyGenerate -> "Ready" to Color(0xFF4CAF50)
-        InferenceUiState.Generating -> "Generating" to MaterialTheme.colorScheme.primary
-        InferenceUiState.Error -> "Error" to MaterialTheme.colorScheme.error
-    }
-
-    Surface(
-        color = color.copy(alpha = 0.1f),
-        shape = RoundedCornerShape(12.dp)
-    ) {
-        Text(
-            text = text,
-            style = MaterialTheme.typography.labelSmall,
-            color = color,
-            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
-        )
-    }
-}
-
-@Composable
-fun CompactMetricItem(
-    label: String,
-    value: String
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 2.dp),
-        horizontalArrangement = Arrangement.SpaceBetween
-    ) {
-        Text(
-            text = label,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.8f)
-        )
-        Text(
-            text = value,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurface,
-            fontWeight = FontWeight.Medium
-        )
-    }
-}
-
-@Composable
-fun RagSourcesCard(
-    ragMessage: RagMessage,
-    modifier: Modifier = Modifier
-) {
-    var expandedItems by remember { mutableStateOf(setOf<Int>()) }
-
-    Card(
-        modifier = modifier
-            .fillMaxWidth()
-            .padding(vertical = 4.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surface.copy(alpha = 0.5f)
-        ),
-        elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
-    ) {
-        Column(
-            modifier = Modifier.padding(12.dp)
-        ) {
-            // Header with icon
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.padding(6.dp)
-            ) {
-                Icon(
-                    Icons.Default.Search,
-                    contentDescription = "RAG Sources",
-                    tint = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.size(16.dp)
-                )
-
-                Spacer(modifier = Modifier.width(8.dp))
-
-                Text(
-                    text = "Reading from ${ragMessage.documents.size} sources...",
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSecondaryContainer,
-                    fontWeight = FontWeight.Medium
-                )
-            }
-
-            // Sources list
-            ragMessage.documents.forEachIndexed { index, chunk ->
-                val isExpanded = expandedItems.contains(index)
-
-                Surface(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(vertical = 6.dp)
-                        .clickable {
-                            expandedItems = if (isExpanded) {
-                                expandedItems - index
-                            } else {
-                                expandedItems + index
-                            }
-                        },
-                    color = MaterialTheme.colorScheme.surface.copy(alpha = 0.5f),
-                    shape = RoundedCornerShape(8.dp)
-                ) {
-                    Column(
-                        modifier = Modifier.padding(8.dp)
-                    ) {
-                        // File name and score
-                        Row(
-                            modifier = Modifier.fillMaxWidth(),
-                            horizontalArrangement = Arrangement.SpaceBetween,
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier.weight(1f)
-                            ) {
-                                Text(
-                                    text = "• ",
-                                    color = MaterialTheme.colorScheme.primary,
-                                    style = MaterialTheme.typography.bodyMedium
-                                )
-
-                                Text(
-                                    text = chunk.file,
-                                    style = MaterialTheme.typography.bodySmall,
-                                    color = MaterialTheme.colorScheme.onSurface,
-                                    maxLines = 1,
-                                    overflow = TextOverflow.Ellipsis,
-                                    modifier = Modifier.weight(1f)
-                                )
-                            }
-
-                            // Score badge
-                            Surface(
-                                color = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f),
-                                shape = RoundedCornerShape(12.dp)
-                            ) {
-                                Text(
-                                    text = "${(chunk.score * 100).toInt()}%",
-                                    style = MaterialTheme.typography.labelSmall,
-                                    color = MaterialTheme.colorScheme.primary,
-                                    modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp)
-                                )
-                            }
-
-                            // Expand/collapse icon
-                            Icon(
-                                if (isExpanded) Icons.Default.KeyboardArrowUp else Icons.Default.KeyboardArrowDown,
-                                contentDescription = if (isExpanded) "Collapse" else "Expand",
-                                tint = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f),
-                                modifier = Modifier.size(16.dp)
-                            )
-                        }
-
-                        // Expanded content
-                        if (isExpanded) {
-                            Spacer(modifier = Modifier.height(8.dp))
-
-                            Surface(
-                                color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f),
-                                shape = RoundedCornerShape(6.dp)
-                            ) {
-                                Column(
-                                    modifier = Modifier.padding(8.dp)
-                                ) {
-                                    Text(
-                                        text = "Content Preview:",
-                                        style = MaterialTheme.typography.labelMedium,
-                                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                        modifier = Modifier.padding(bottom = 4.dp)
-                                    )
-
-                                    Text(
-                                        text = chunk.content.take(200) + if (chunk.content.length > 200) "..." else "",
-                                        style = MaterialTheme.typography.bodySmall,
-                                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                        lineHeight = 16.sp
-                                    )
-
-                                    if (chunk.content.length > 200) {
-                                        Text(
-                                            text = "Tap to see full content",
-                                            style = MaterialTheme.typography.labelSmall,
-                                            color = MaterialTheme.colorScheme.primary,
-                                            modifier = Modifier.padding(top = 4.dp)
-                                        )
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                if (index < ragMessage.documents.size - 1) {
-                    Spacer(modifier = Modifier.height(4.dp))
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/TrainingScreen.kt b/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/TrainingScreen.kt
deleted file mode 100644
index b58cd0c..0000000
--- a/android/ORTransformer/app/src/main/java/com/martinkorelic/orttransformer/views/TrainingScreen.kt
+++ /dev/null
@@ -1,222 +0,0 @@
-package com.martinkorelic.orttransformer.views
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Delete
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Button
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedButton
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.material3.TextField
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.DialogProperties
-import com.martinkorelic.orttransformer.viewmodels.TrainingUiState
-import com.martinkorelic.orttransformer.viewmodels.TrainingViewModel
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-
-@Composable
-fun TrainingScreen(
-    viewModel: TrainingViewModel
-) {
-    val trainingState by viewModel.trainingState.collectAsState()
-    val trainLoss by viewModel.trainLoss.collectAsState()
-    val currentStepDuration by viewModel.currentStepDuration.collectAsState()
-    val averageStepDuration by viewModel.averageStepDuration.collectAsState()
-    val learningRate by viewModel.learningRate.collectAsState()
-    val currentStep by viewModel.currentStep.collectAsState()
-    val currentEpoch by viewModel.currentEpoch.collectAsState()
-
-    var trainingLog by remember { mutableStateOf("Training Loss Log:\n") }
-
-    // Update loss log when trainLoss changes
-    LaunchedEffect(trainLoss, currentStepDuration) {
-        if (currentStepDuration > 0f) {
-            val timestamp = SimpleDateFormat("HH:mm:ss", Locale.getDefault()).format(Date())
-            val stepDurationSec = currentStepDuration / 1000.0
-            trainingLog += "[$timestamp] Step $currentStep (Epoch $currentEpoch)\n"
-            trainingLog += "  Loss: ${String.format("%.6f", trainLoss)}\n"
-            trainingLog += "  Step Time: ${String.format("%.2f", stepDurationSec)}s\n"
-            trainingLog += "  LR: ${String.format("%.9f", learningRate)}\n"
-        }
-    }
-
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(16.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.spacedBy(16.dp)
-    ) {
-        // Training State Display
-        Text(
-            text = "Training Status: ${trainingState.name}",
-            style = MaterialTheme.typography.headlineSmall,
-            modifier = Modifier.padding(bottom = 8.dp)
-        )
-
-        // Loss Log Text Area
-        Card(
-            modifier = Modifier
-                .fillMaxWidth()
-                .weight(1f),
-            elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
-        ) {
-            Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(12.dp)
-            ) {
-                val scrollState = rememberScrollState()
-
-                // Auto-scroll to bottom when new content is added
-                LaunchedEffect(trainingLog) {
-                    scrollState.animateScrollTo(scrollState.maxValue)
-                }
-
-                Text(
-                    text = trainingLog,
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .verticalScroll(scrollState),
-                    style = MaterialTheme.typography.bodyMedium.copy(
-                        fontFamily = FontFamily.Monospace
-                    ),
-                    color = MaterialTheme.colorScheme.onSurface
-                )
-            }
-        }
-
-        // Current Loss Display
-        if (trainLoss > 0f) {
-            Card(
-                modifier = Modifier.fillMaxWidth(),
-                colors = CardDefaults.cardColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer
-                )
-            ) {
-                Column(
-                    modifier = Modifier.padding(12.dp)
-                ) {
-                    Text(
-                        text = "Current Loss: ${String.format("%.6f", trainLoss)}",
-                        style = MaterialTheme.typography.titleMedium,
-                        color = MaterialTheme.colorScheme.onPrimaryContainer
-                    )
-                    if (currentStepDuration > 0 && averageStepDuration > 0) {
-                        val currentStepSec = currentStepDuration / 1000.0
-                        val avgStepSec = averageStepDuration / 1000.0
-                        Row(
-                            modifier = Modifier.fillMaxWidth(),
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Text(
-                                text = "Last Step: ${String.format("%.2f", currentStepSec)}s",
-                                style = MaterialTheme.typography.bodyMedium,
-                                color = MaterialTheme.colorScheme.onPrimaryContainer
-                            )
-                            Text(
-                                text = "Avg Time: ${String.format("%.2f", avgStepSec)}s/step",
-                                style = MaterialTheme.typography.bodyMedium,
-                                color = MaterialTheme.colorScheme.onPrimaryContainer
-                            )
-                        }
-                    }
-                }
-            }
-        }
-
-        // Action Buttons
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            horizontalArrangement = Arrangement.spacedBy(12.dp)
-        ) {
-            // Start Training Button
-            Button(
-                onClick = { viewModel.startTraining() },
-                enabled = trainingState == TrainingUiState.ReadyTrain,
-                modifier = Modifier.weight(1f)
-            ) {
-                when (trainingState) {
-                    TrainingUiState.Training -> {
-                        CircularProgressIndicator(
-                            modifier = Modifier.size(16.dp),
-                            strokeWidth = 2.dp,
-                            color = MaterialTheme.colorScheme.onPrimary
-                        )
-                        Spacer(modifier = Modifier.width(8.dp))
-                        Text("Training...")
-                    }
-                    else -> {
-                        Text("Start Training")
-                    }
-                }
-            }
-
-            // Save Model Button
-            Button(
-                onClick = { viewModel.endTraining(true) },
-                enabled = trainingState == TrainingUiState.ReadyTrain,
-                modifier = Modifier.weight(1f)
-            ) {
-                when (trainingState) {
-                    TrainingUiState.SavingModel -> {
-                        CircularProgressIndicator(
-                            modifier = Modifier.size(16.dp),
-                            strokeWidth = 2.dp,
-                            color = MaterialTheme.colorScheme.onPrimary
-                        )
-                        Spacer(modifier = Modifier.width(8.dp))
-                        Text("Saving...")
-                    }
-                    else -> {
-                        Text("Save Model")
-                    }
-                }
-            }
-        }
-
-        // Clear Log Button
-        OutlinedButton(
-            onClick = { trainingLog = "Training Loss Log:\n" },
-            modifier = Modifier.fillMaxWidth()
-        ) {
-            Text("Clear Log")
-        }
-    }
-}
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/drawable/ic_launcher_background.xml b/android/ORTransformer/app/src/main/res/drawable/ic_launcher_background.xml
deleted file mode 100644
index 07d5da9..0000000
--- a/android/ORTransformer/app/src/main/res/drawable/ic_launcher_background.xml
+++ /dev/null
@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>
diff --git a/android/ORTransformer/app/src/main/res/drawable/ic_launcher_foreground.xml b/android/ORTransformer/app/src/main/res/drawable/ic_launcher_foreground.xml
deleted file mode 100644
index 2b068d1..0000000
--- a/android/ORTransformer/app/src/main/res/drawable/ic_launcher_foreground.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
deleted file mode 100644
index 6f3b755..0000000
--- a/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
deleted file mode 100644
index 6f3b755..0000000
--- a/android/ORTransformer/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher.webp
deleted file mode 100644
index c209e78..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp
deleted file mode 100644
index b2dfe3d..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher.webp
deleted file mode 100644
index 4f0f1d6..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp
deleted file mode 100644
index 62b611d..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher.webp
deleted file mode 100644
index 948a307..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
deleted file mode 100644
index 1b9a695..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp
deleted file mode 100644
index 28d4b77..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
deleted file mode 100644
index 9287f50..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
deleted file mode 100644
index aa7d642..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
deleted file mode 100644
index 9126ae3..0000000
Binary files a/android/ORTransformer/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp and /dev/null differ
diff --git a/android/ORTransformer/app/src/main/res/values-night/themes.xml b/android/ORTransformer/app/src/main/res/values-night/themes.xml
deleted file mode 100644
index e481cf5..0000000
--- a/android/ORTransformer/app/src/main/res/values-night/themes.xml
+++ /dev/null
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.ORTTransformer" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_200</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/black</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_200</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/values/colors.xml b/android/ORTransformer/app/src/main/res/values/colors.xml
deleted file mode 100644
index f8c6127..0000000
--- a/android/ORTransformer/app/src/main/res/values/colors.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="purple_200">#FFBB86FC</color>
-    <color name="purple_500">#FF6200EE</color>
-    <color name="purple_700">#FF3700B3</color>
-    <color name="teal_200">#FF03DAC5</color>
-    <color name="teal_700">#FF018786</color>
-    <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
-</resources>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/main/res/values/themes.xml b/android/ORTransformer/app/src/main/res/values/themes.xml
deleted file mode 100644
index 3bbb508..0000000
--- a/android/ORTransformer/app/src/main/res/values/themes.xml
+++ /dev/null
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.ORTTransformer" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_500</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/white</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_700</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
\ No newline at end of file
diff --git a/android/ORTransformer/app/src/test/java/com/martinkorelic/orttransformer/ExampleUnitTest.kt b/android/ORTransformer/app/src/test/java/com/martinkorelic/orttransformer/ExampleUnitTest.kt
deleted file mode 100644
index 8987cd5..0000000
--- a/android/ORTransformer/app/src/test/java/com/martinkorelic/orttransformer/ExampleUnitTest.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.martinkorelic.orttransformer
-
-import org.junit.Test
-
-import org.junit.Assert.*
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
\ No newline at end of file
diff --git a/artifact/merger.py b/artifact/merger.py
deleted file mode 100644
index 9f1d4ce..0000000
--- a/artifact/merger.py
+++ /dev/null
@@ -1,1167 +0,0 @@
-import onnx
-import numpy as np
-from onnx import StringStringEntryProto, helper, TensorProto
-import onnxruntime as ort
-
-def create_onnx_chunking_model(
-    output_path="onnx_chunking_model.onnx"
-):
-    """
-    Creates an ONNX model that performs only the chunking of the intermediate matrix.
-
-    Inputs:
-    - intermediate: float32 [N*rank_adapter, shared_rank]
-    - adapter_index: int64 scalar
-    - rank_adapter: int64 scalar
-    - shared_rank_val: int64 scalar (explicitly passed for model creation/testing)
-
-    Outputs:
-    - chunked_intermediate: float32 [rank_adapter, shared_rank]
-    """
-
-    # Inputs for the chunking model
-    inputs = [
-        helper.make_tensor_value_info("intermediate", TensorProto.FLOAT, ["N_times_rank_adapter", "shared_rank_val_dim"]),
-        helper.make_tensor_value_info("adapter_index", TensorProto.INT64, []),
-        helper.make_tensor_value_info("rank_adapter", TensorProto.INT64, []),
-        helper.make_tensor_value_info("shared_rank_val", TensorProto.INT64, []) # Added as explicit input
-    ]
-
-    # Output for the chunking model
-    outputs = [
-        helper.make_tensor_value_info("chunked_intermediate", TensorProto.FLOAT, ["rank_adapter_dim", "shared_rank_val_dim"])
-    ]
-
-    nodes = []
-
-    # Constants
-    nodes.append(
-        helper.make_node(
-            "Constant",
-            inputs=[],
-            outputs=["zero_scalar"],
-            value=helper.make_tensor("zero_scalar_tensor", TensorProto.INT64, [], [0])
-        )
-    )
-    nodes.append(
-        helper.make_node(
-            "Constant",
-            inputs=[],
-            outputs=["one_scalar"],
-            value=helper.make_tensor("one_scalar_tensor", TensorProto.INT64, [1], [1]) # For Reshape
-        )
-    )
-    nodes.append(
-        helper.make_node(
-            "Constant",
-            inputs=[],
-            outputs=["axes_slice"],
-            value=helper.make_tensor("axes_slice_tensor", TensorProto.INT64, [2], [0, 1])
-        )
-    )
-
-    # Compute slice_start: adapter_index * rank_adapter
-    nodes.append(
-        helper.make_node(
-            "Mul",
-            inputs=["adapter_index", "rank_adapter"],
-            outputs=["slice_start_val"],
-            name="compute_slice_start"
-        )
-    )
-
-    # Compute slice_end: slice_start + rank_adapter
-    nodes.append(
-        helper.make_node(
-            "Add",
-            inputs=["slice_start_val", "rank_adapter"],
-            outputs=["slice_end_val"],
-            name="compute_slice_end"
-        )
-    )
-
-    # Reshape scalar slice_start_val and slice_end_val to [1] for Concat
-    nodes.append(
-        helper.make_node(
-            "Reshape",
-            inputs=["slice_start_val", "one_scalar"],
-            outputs=["slice_start_reshaped"],
-            name="reshape_slice_start"
-        )
-    )
-    nodes.append(
-        helper.make_node(
-            "Reshape",
-            inputs=["slice_end_val", "one_scalar"],
-            outputs=["slice_end_reshaped"],
-            name="reshape_slice_end"
-        )
-    )
-
-    # Reshape zero_scalar to [1] for concat (to match slice_start_reshaped)
-    nodes.append(
-        helper.make_node(
-            "Reshape",
-            inputs=["zero_scalar", "one_scalar"],
-            outputs=["zero_scalar_reshaped"],
-            name="reshape_zero_scalar_for_concat"
-        )
-    )
-
-    # Reshape shared_rank_val (from input) to [1] for concat
-    nodes.append(
-        helper.make_node(
-            "Reshape",
-            inputs=["shared_rank_val", "one_scalar"],
-            outputs=["shared_rank_val_reshaped"],
-            name="reshape_shared_rank_val"
-        )
-    )
-
-
-    # slice_starts for the Slice op: [slice_start, 0]
-    nodes.append(
-        helper.make_node(
-            "Concat",
-            inputs=["slice_start_reshaped", "zero_scalar_reshaped"],
-            outputs=["slice_starts"],
-            axis=0,
-            name="concat_slice_starts"
-        )
-    )
-
-    # slice_ends for the Slice op: [slice_end, shared_rank_val]
-    nodes.append(
-        helper.make_node(
-            "Concat",
-            inputs=["slice_end_reshaped", "shared_rank_val_reshaped"],
-            outputs=["slice_ends"],
-            axis=0,
-            name="concat_slice_ends"
-        )
-    )
-
-    # Slice the intermediate matrix
-    nodes.append(
-        helper.make_node(
-            "Slice",
-            inputs=["intermediate", "slice_starts", "slice_ends", "axes_slice"],
-            outputs=["chunked_intermediate"],
-            name="slice_chunk"
-        )
-    )
-    # chunked_intermediate shape: [rank_adapter, shared_rank]
-
-    graph = helper.make_graph(
-        nodes=nodes,
-        name="Chunking_Model",
-        inputs=inputs,
-        outputs=outputs,
-        doc_string="Model for testing intermediate matrix chunking"
-    )
-
-    model = helper.make_model(
-        graph,
-        producer_name="Chunking_Model",
-        opset_imports=[helper.make_opsetid("", 11)]
-    )
-    onnx.checker.check_model(model)
-    onnx.save(model, output_path)
-    print(f"Chunking model saved to {output_path}")
-    return model
-
-def test_onnx_chunking_model(model_path="onnx_chunking_model.onnx"):
-    """Tests the ONNX chunking model with sample data."""
-    session = ort.InferenceSession(model_path)
-
-    test_configs = [
-        {"shared_rank": 32, "rank_adapter": 8, "N": 3, "adapter_index": 0}, # First chunk
-        {"shared_rank": 32, "rank_adapter": 8, "N": 3, "adapter_index": 1}, # Second chunk
-        {"shared_rank": 64, "rank_adapter": 16, "N": 3, "adapter_index": 2}, # Third chunk
-    ]
-
-    for i, config in enumerate(test_configs):
-        print(f"\nTest {i+1}: {config}")
-        shared_rank = config["shared_rank"]
-        rank_adapter = config["rank_adapter"]
-        N = config["N"]
-        adapter_index = config["adapter_index"]
-
-        # intermediate: [N * rank_adapter, shared_rank]
-        intermediate_np = np.random.rand(N * rank_adapter, shared_rank).astype(np.float32)
-        adapter_index_np = np.array(adapter_index, dtype=np.int64)
-        rank_adapter_np = np.array(rank_adapter, dtype=np.int64)
-        shared_rank_val_np = np.array(shared_rank, dtype=np.int64) # Explicitly pass shared_rank
-
-        inputs = {
-            "intermediate": intermediate_np,
-            "adapter_index": adapter_index_np,
-            "rank_adapter": rank_adapter_np,
-            "shared_rank_val": shared_rank_val_np
-        }
-
-        print(f"  Input 'intermediate' shape: {intermediate_np.shape}")
-        print(f"  Input 'adapter_index': {adapter_index_np}")
-        print(f"  Input 'rank_adapter': {rank_adapter_np}")
-        print(f"  Input 'shared_rank_val': {shared_rank_val_np}")
-
-        # Reference calculation in NumPy
-        expected_chunk = intermediate_np[
-            adapter_index * rank_adapter : (adapter_index + 1) * rank_adapter,
-            :
-        ]
-        print(f"  NumPy Expected chunk shape: {expected_chunk.shape}")
-
-        try:
-            onnx_outputs = session.run(None, inputs)
-            onnx_chunked_intermediate = onnx_outputs[0]
-            print(f"  ONNX Actual chunk shape: {onnx_chunked_intermediate.shape}")
-
-            # Verify shapes match
-            if onnx_chunked_intermediate.shape == expected_chunk.shape:
-                print(f"  ✓ Shape match!")
-            else:
-                print(f"  ✗ Shape MISMATCH! Expected {expected_chunk.shape}, got {onnx_chunked_intermediate.shape}")
-
-            # Verify content (allow for small float differences)
-            max_diff = np.max(np.abs(onnx_chunked_intermediate - expected_chunk))
-            print(f"  Max content difference: {max_diff}")
-            if max_diff < 1e-5: # Small tolerance for floating point
-                print(f"  ✓ Content match (within tolerance)!")
-            else:
-                print(f"  ✗ Content MISMATCH!")
-
-        except ort.OrtValue as e:
-            print(f"ONNX Runtime error during session.run: {e}")
-            print("This indicates an issue with the ONNX graph's slicing logic.")
-            return
-
-
-def create_lora_merger_model(output_path="lora_merger.onnx", quantized=True):
-    """
-    Creates an ONNX LoRA merger model:
-    - quantized == True:
-      merges LoRA weights with quantized base weights
-    - quantized == False:
-      merges LoRA weights with float32 base weights
-    Inputs:
-        - weight (uint8 if quantized else float32)
-        - scale (float32) [scalar]  (only if quantized)
-        - zero_point (uint8) [scalar] (only if quantized)
-        - lora_A (float32)
-        - lora_B (float32)
-        - alpha (float32) [scalar]
-    Outputs:
-        - merged_weight (uint8 if quantized else float32)
-        - scale (float32) [scalar]  (only if quantized)
-        - zero_point (uint8) [scalar] (only if quantized)
-    """
-    import onnx
-    from onnx import helper, TensorProto
-
-    inputs = []
-    outputs = []
-    nodes = []
-
-    if quantized:
-        # quantized inputs
-        inputs.append(helper.make_tensor_value_info("weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]))
-        inputs.append(helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []))
-        inputs.append(helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []))
-    else:
-        # float base weights
-        inputs.append(helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"]))
-
-    # LoRA inputs
-    inputs.append(helper.make_tensor_value_info("adapter_A", TensorProto.FLOAT, ["rank", "in_features"]))
-    inputs.append(helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]))
-    inputs.append(helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []))
-
-    if quantized:
-        outputs.append(helper.make_tensor_value_info("merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]))
-        outputs.append(helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, []))
-        outputs.append(helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []))
-    else:
-        outputs.append(helper.make_tensor_value_info("merged_weight", TensorProto.FLOAT, ["out_features", "in_features"]))
-
-    # 1. Dequantize if needed
-    if quantized:
-        nodes.append(helper.make_node(
-            "DequantizeLinear",
-            inputs=["weight_quantized", "x_scale", "x_zero_point"],
-            outputs=["base_weight_fp32"],
-            name="dequantize_base_weights"
-        ))
-        base_input = "base_weight_fp32"
-    else:
-        base_input = "weight"
-
-    # 2. LoRA delta
-    nodes.append(helper.make_node(
-        "MatMul",
-        inputs=["adapter_B", "adapter_A"],
-        outputs=["lora_delta"],
-        name="compute_lora_delta"
-    ))
-    nodes.append(helper.make_node(
-        "Mul",
-        inputs=["lora_delta", "alpha"],
-        outputs=["scaled_lora_delta"],
-        name="scale_lora_delta"
-    ))
-
-    # 3. Add
-    nodes.append(helper.make_node(
-        "Add",
-        inputs=[base_input, "scaled_lora_delta"],
-        outputs=["merged_weight_fp32"],
-        name="add_lora_delta"
-    ))
-
-    # 4. Requantize if needed
-    if quantized:
-        nodes.append(helper.make_node(
-            "DynamicQuantizeLinear",
-            inputs=["merged_weight_fp32"],
-            outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
-            name="quantize_merged"
-        ))
-    else:
-        # output is float, rename directly
-        nodes.append(helper.make_node(
-            "Identity",
-            inputs=["merged_weight_fp32"],
-            outputs=["merged_weight"],
-            name="identity_output"
-        ))
-
-    graph = helper.make_graph(
-        nodes=nodes,
-        name="LoRAMergerModel",
-        inputs=inputs,
-        outputs=outputs
-    )
-
-    model = helper.make_model(graph, producer_name="LoRAMerger", opset_imports=[helper.make_opsetid("", 11)])
-    onnx.checker.check_model(model)
-    onnx.save(model, output_path)
-    print(f"✅ LoRA merger model saved to {output_path} with quantized={quantized}")
-    return model
-
-def create_lora_merger_model_2(output_path="lora_merger.onnx", quantized_inputs=True, quantized_outputs=True):
-    """
-    Creates an ONNX LoRA merger model with configurable input/output quantization.
-    
-    Args:
-        output_path (str): Path where the ONNX model will be saved
-        quantized_inputs (bool): Whether the base weight inputs are quantized
-        quantized_outputs (bool): Whether the outputs should be quantized
-        
-    Returns:
-        onnx.ModelProto: The created ONNX model
-        
-    Input tensors (when quantized_inputs=True):
-        - weight_quantized: Base model weights in UINT8 quantized format
-        - x_scale: Scale factor for base weight quantization (FLOAT scalar)
-        - x_zero_point: Zero point for base weight quantization (UINT8 scalar)
-        
-    Input tensors (when quantized_inputs=False):
-        - weight: Base model weights in FLOAT format
-        
-    Common input tensors:
-        - adapter_A: LoRA A matrix (FLOAT [rank, in_features])
-        - adapter_B: LoRA B matrix (FLOAT [out_features, rank])
-        - alpha: Scaling factor for LoRA contribution (FLOAT scalar)
-        
-    Output tensors (when quantized_outputs=True):
-        - merged_weight_quantized: Final merged weights in UINT8 quantized format
-        - merged_scale: Scale factor for merged weight quantization (FLOAT scalar)
-        - merged_zero_point: Zero point for merged weight quantization (UINT8 scalar)
-        
-    Output tensors (when quantized_outputs=False):
-        - merged_weight: Final merged weights in FLOAT format
-    """
-    import onnx
-    from onnx import helper, TensorProto
-    from onnx.onnx_ml_pb2 import StringStringEntryProto
-
-    inputs = []
-    outputs = []
-    nodes = []
-
-    # Define inputs based on quantized_inputs flag
-    if quantized_inputs:
-        inputs.append(helper.make_tensor_value_info("weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]))
-        inputs.append(helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []))
-        inputs.append(helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []))
-    else:
-        inputs.append(helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"]))
-
-    # LoRA inputs (common for all configurations)
-    inputs.append(helper.make_tensor_value_info("adapter_A", TensorProto.FLOAT, ["rank", "in_features"]))
-    inputs.append(helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]))
-    inputs.append(helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []))
-
-    # Define outputs based on quantized_outputs flag
-    if quantized_outputs:
-        outputs.append(helper.make_tensor_value_info("merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]))
-        outputs.append(helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, []))
-        outputs.append(helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []))
-    else:
-        outputs.append(helper.make_tensor_value_info("merged_weight", TensorProto.FLOAT, ["out_features", "in_features"]))
-
-    # Step 1: Dequantize base weights if needed
-    if quantized_inputs:
-        nodes.append(helper.make_node(
-            "DequantizeLinear",
-            inputs=["weight_quantized", "x_scale", "x_zero_point"],
-            outputs=["base_weight_fp32"],
-            name="dequantize_base_weights"
-        ))
-        base_input = "base_weight_fp32"
-    else:
-        base_input = "weight"
-
-    # Step 2: Compute LoRA delta
-    nodes.append(helper.make_node(
-        "MatMul",
-        inputs=["adapter_B", "adapter_A"],
-        outputs=["lora_delta"],
-        name="compute_lora_delta"
-    ))
-    
-    # Step 3: Scale LoRA delta by alpha
-    nodes.append(helper.make_node(
-        "Mul",
-        inputs=["lora_delta", "alpha"],
-        outputs=["scaled_lora_delta"],
-        name="scale_lora_delta"
-    ))
-
-    # Step 4: Add LoRA delta to base weights
-    nodes.append(helper.make_node(
-        "Add",
-        inputs=[base_input, "scaled_lora_delta"],
-        outputs=["merged_weight_fp32"],
-        name="add_lora_delta"
-    ))
-
-    # Step 5: Handle output based on quantized_outputs flag
-    if quantized_outputs:
-        nodes.append(helper.make_node(
-            "DynamicQuantizeLinear",
-            inputs=["merged_weight_fp32"],
-            outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
-            name="quantize_merged"
-        ))
-    else:
-        # output is float, rename directly
-        nodes.append(helper.make_node(
-            "Identity",
-            inputs=["merged_weight_fp32"],
-            outputs=["merged_weight"],
-            name="identity_output"
-        ))
-
-    # Create the graph
-    graph = helper.make_graph(
-        nodes=nodes,
-        name="LoRAMergerModel",
-        inputs=inputs,
-        outputs=outputs,
-        doc_string=f"LoRA merger model for merging adapters (inputs: {'quantized' if quantized_inputs else 'float'}, outputs: {'quantized' if quantized_outputs else 'float'})."
-    )
-
-    # Create the model
-    model = helper.make_model(
-        graph, 
-        producer_name="LoRAMerger_v1.0", 
-        producer_version="1.0.0",
-        doc_string=f"LoRA (Low-Rank Adaptation) weight merger for PEFT models. Input quantization: {quantized_inputs}, Output quantization: {quantized_outputs}.",
-        model_version=1,
-        opset_imports=[helper.make_opsetid("", 11)]
-    )
-    
-    # Add quantization metadata to the model
-    metadata_entries = [
-        ("quantized_inputs", str(quantized_inputs).lower()),
-        ("quantized_outputs", str(quantized_outputs).lower()),
-        ("input_type", "quantized" if quantized_inputs else "float"),
-        ("output_type", "quantized" if quantized_outputs else "float")
-    ]
-    
-    for key, value in metadata_entries:
-        entry = StringStringEntryProto()
-        entry.key = key
-        entry.value = value
-        model.metadata_props.append(entry)
-
-    onnx.checker.check_model(model)
-    onnx.save(model, output_path)
-    
-    # Updated print statement to reflect the new flags
-    input_type = "quantized" if quantized_inputs else "float"
-    output_type = "quantized" if quantized_outputs else "float"
-    print(f"✅ LoRA merger model saved to {output_path} (inputs: {input_type}, outputs: {output_type})")
-    
-    return model
-
-def test_all_lora_merger_models(
-    quantized_model_path="lora_merger_quantized.onnx",
-    float_model_path="lora_merger_float.onnx"
-):
-    """
-    Tests both the quantized and float LoRA merger models on the same data.
-    """
-
-    # load both models
-    quantized_session = ort.InferenceSession(quantized_model_path)
-    float_session = ort.InferenceSession(float_model_path)
-
-    test_configs = [
-        {"out_features": 512, "in_features": 256, "lora_rank": 8},
-        {"out_features": 1024, "in_features": 1024, "lora_rank": 16},
-    ]
-
-    for i, config in enumerate(test_configs):
-        out_features = config["out_features"]
-        in_features = config["in_features"]
-        rank = config["lora_rank"]
-
-        print(f"\n======================")
-        print(f"[TEST CONFIG] {config}")
-        print(f"======================")
-
-        # Create a random float base weight
-        base_weight_fp32 = np.random.randn(out_features, in_features).astype(np.float32) * 0.1
-
-        # Quantize it for the quantized model
-        scale = np.float32((base_weight_fp32.max() - base_weight_fp32.min()) / 255.0)
-        zero_point = np.uint8(np.clip(np.round(-base_weight_fp32.min() / scale), 0, 255))
-        weight_quantized = np.clip(np.round(base_weight_fp32 / scale) + zero_point, 0, 255).astype(np.uint8)
-
-        # LoRA weights
-        lora_A = np.random.randn(rank, in_features).astype(np.float32) * 0.01
-        lora_B = np.random.randn(out_features, rank).astype(np.float32) * 0.01
-        alpha = np.float32(16.0)
-
-        # shared
-        expected = base_weight_fp32 + alpha * np.matmul(lora_B, lora_A)
-
-        # ---------------
-        # QUANTIZED MODEL
-        # ---------------
-        quant_inputs = {
-            "weight_quantized": weight_quantized,
-            "x_scale": np.array(scale, dtype=np.float32),
-            "x_zero_point": np.array(zero_point, dtype=np.uint8),
-            "adapter_A": lora_A,
-            "adapter_B": lora_B,
-            "alpha": np.array(alpha, dtype=np.float32),
-        }
-        q_outputs = quantized_session.run(
-            ["merged_weight_quantized", "merged_scale", "merged_zero_point"],
-            quant_inputs
-        )
-        merged_q, merged_q_scale, merged_q_zero = q_outputs
-
-        merged_q_dequant = (merged_q.astype(np.float32) - merged_q_zero) * merged_q_scale
-
-        diff_q = np.max(np.abs(merged_q_dequant - expected))
-        print(f"[QUANTIZED]")
-        print(f"  merged_q shape: {merged_q.shape}")
-        print(f"  max diff vs expected: {diff_q:.6f}")
-        if diff_q < 0.01:
-            print("  ✅ PASS")
-        else:
-            print("  ✗ FAIL")
-
-        # ---------------
-        # FLOAT MODEL
-        # ---------------
-        float_inputs = {
-            "weight": base_weight_fp32,
-            "adapter_A": lora_A,
-            "adapter_B": lora_B,
-            "alpha": np.array(alpha, dtype=np.float32),
-        }
-        f_outputs = float_session.run(["merged_weight"], float_inputs)
-        merged_f = f_outputs[0]
-        diff_f = np.max(np.abs(merged_f - expected))
-        print(f"[FLOAT]")
-        print(f"  merged_f shape: {merged_f.shape}")
-        print(f"  max diff vs expected: {diff_f:.6f}")
-        if diff_f < 1e-6:
-            print("  ✅ PASS")
-        else:
-            print("  ✗ FAIL")
-
-def create_mars_merger_model_2(output_path="mars_merger_model.onnx", quantized_inputs=True, quantized_outputs=True):
-    """
-    Creates a fixed ONNX model that merges PEFT (MARS) weights with base weights.
-    
-    MARS (Multi Adapter Rank Sharing) is a parameter-efficient fine-tuning method
-    that decomposes adapter weights into shared and adapter-specific components.
-    
-    The mathematical operation performed is:
-    merged_weight = base_weight + alpha * (adapter_B @ intermediate_chunk @ shared_A)
-    
-    Where:
-    - base_weight: Original model weights (quantized or float)
-    - adapter_B: Adapter-specific "B" matrix [out_features, rank]
-    - intermediate: Shared intermediate matrix [N*rank, shared_rank] containing chunks for N adapters
-    - intermediate_chunk: Slice of intermediate for current adapter [rank, shared_rank]
-    - shared_A: Shared "A" matrix [shared_rank, in_features]
-    - alpha: Scaling factor for the adapter contribution
-    
-    The matrix multiplication chain:
-    1. adapter_B [out_features, rank] @ intermediate_chunk [rank, shared_rank] 
-       → [out_features, shared_rank]
-    2. result @ shared_A [shared_rank, in_features] 
-       → [out_features, in_features]
-    3. Scale by alpha and add to base weights
-    
-    Args:
-        output_path (str): Path where the ONNX model will be saved
-        quantized_inputs (bool): Whether the base weight inputs are quantized
-        quantized_outputs (bool): Whether the outputs should be quantized
-        
-    Returns:
-        onnx.ModelProto: The created ONNX model
-        
-    Input tensors (when quantized_inputs=True):
-        - weight_quantized: Base model weights in UINT8 quantized format
-        - x_zero_point: Zero point for base weight quantization (UINT8 scalar)
-        - x_scale: Scale factor for base weight quantization (FLOAT scalar)
-        
-    Input tensors (when quantized_inputs=False):
-        - weight: Base model weights in FLOAT format
-        
-    Common input tensors:
-        - shared_A: Shared component matrix (FLOAT [shared_rank, in_features])
-        - intermediate: Combined intermediate matrix for all adapters (FLOAT [N*rank, shared_rank])
-        - adapter_B: Adapter-specific B matrix (FLOAT [out_features, rank])
-        - adapter_index: Index of the adapter to use (INT64 scalar)
-        - rank: Rank of the adapter (INT64 scalar)
-        - alpha: Scaling factor for adapter contribution (FLOAT scalar)
-        
-    Output tensors (when quantized_outputs=True):
-        - merged_weight_quantized: Final merged weights in UINT8 quantized format
-        - merged_zero_point: Zero point for merged weight quantization (UINT8 scalar)
-        - merged_scale: Scale factor for merged weight quantization (FLOAT scalar)
-        
-    Output tensors (when quantized_outputs=False):
-        - merged_weight: Final merged weights in FLOAT format
-    """
-    
-    # Define inputs based on quantized_inputs flag
-    if quantized_inputs:
-        inputs = [
-            helper.make_tensor_value_info("weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]),
-            helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []),
-            helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []),
-        ]
-    else:
-        inputs = [
-            helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"]),
-        ]
-
-    # Define outputs based on quantized_outputs flag
-    if quantized_outputs:
-        outputs = [
-            helper.make_tensor_value_info("merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]),
-            helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []),
-            helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, [])
-        ]
-    else:
-        outputs = [
-            helper.make_tensor_value_info("merged_weight", TensorProto.FLOAT, ["out_features", "in_features"]),
-        ]
-
-    # Common inputs regardless of quantization flags
-    common_inputs = [
-        helper.make_tensor_value_info("shared_A", TensorProto.FLOAT, ["shared_rank", "in_features"]),
-        helper.make_tensor_value_info("intermediate", TensorProto.FLOAT, ["n_times_rank", "shared_rank"]),
-        helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]),
-        helper.make_tensor_value_info("adapter_index", TensorProto.INT64, []),
-        helper.make_tensor_value_info("rank", TensorProto.INT64, []),
-        helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []),
-    ]
-    inputs.extend(common_inputs)
-
-    nodes = []
-
-    # Step 1: get base_weight_fp32
-    if quantized_inputs:
-        nodes.append(
-            helper.make_node(
-                "DequantizeLinear",
-                inputs=["weight_quantized", "x_scale", "x_zero_point"],
-                outputs=["base_weight_fp32"],
-                name="dequantize_base_weights"
-            )
-        )
-    else:
-        # just rename directly
-        nodes.append(
-            helper.make_node(
-                "Identity",
-                inputs=["weight"],
-                outputs=["base_weight_fp32"],
-                name="pass_through_base_weight"
-            )
-        )
-
-    # Step 2: calculate slice boundaries
-    nodes.append(
-        helper.make_node("Mul", ["adapter_index", "rank"], ["slice_start"], name="compute_slice_start")
-    )
-    nodes.append(
-        helper.make_node("Add", ["slice_start", "rank"], ["slice_end"], name="compute_slice_end")
-    )
-    nodes.append(
-        helper.make_node("Unsqueeze", ["slice_start"], ["slice_start_1d"], axes=[0], name="unsqueeze_slice_start")
-    )
-    nodes.append(
-        helper.make_node("Unsqueeze", ["slice_end"], ["slice_end_1d"], axes=[0], name="unsqueeze_slice_end")
-    )
-    nodes.append(
-        helper.make_node(
-            "Constant", [], ["axes_0"],
-            value=helper.make_tensor("axes_0_tensor", TensorProto.INT64, [1], [0])
-        )
-    )
-    nodes.append(
-        helper.make_node(
-            "Slice", ["intermediate", "slice_start_1d", "slice_end_1d", "axes_0"],
-            ["chunked_intermediate"], name="slice_intermediate"
-        )
-    )
-
-    # Step 3: adapter_B @ chunked_intermediate
-    nodes.append(
-        helper.make_node("MatMul", ["adapter_B", "chunked_intermediate"], ["adapter_times_chunk"], name="adapter_chunk_matmul")
-    )
-
-    # Step 4: (adapter_B @ chunked) @ shared_A
-    nodes.append(
-        helper.make_node("MatMul", ["adapter_times_chunk", "shared_A"], ["lora_delta_prealpha"], name="final_matmul")
-    )
-
-    # Step 5: alpha scaling
-    nodes.append(
-        helper.make_node("Mul", ["lora_delta_prealpha", "alpha"], ["lora_delta"], name="scale_alpha")
-    )
-
-    # Step 6: add LoRA delta
-    nodes.append(
-        helper.make_node("Add", ["base_weight_fp32", "lora_delta"], ["merged_weight_fp32"], name="add_delta")
-    )
-
-    # Step 7: handle output based on quantized_outputs flag
-    if quantized_outputs:
-        nodes.append(
-            helper.make_node(
-                "DynamicQuantizeLinear",
-                inputs=["merged_weight_fp32"],
-                outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
-                name="quantize_merged"
-            )
-        )
-    else:
-        # just output the floating-point
-        nodes.append(
-            helper.make_node(
-                "Identity",
-                inputs=["merged_weight_fp32"],
-                outputs=["merged_weight"],
-                name="identity_output"
-            )
-        )
-
-    # put together the graph
-    graph = helper.make_graph(
-        nodes=nodes,
-        name="MARS Merger",
-        inputs=inputs,
-        outputs=outputs,
-        doc_string=f"MARS merger model for merging adapters (inputs: {'quantized' if quantized_inputs else 'float'}, outputs: {'quantized' if quantized_outputs else 'float'})."
-    )
-
-    model = helper.make_model(
-        graph,
-        producer_name="MARS_Merger_v1.0",
-        producer_version="1.0.0",
-        doc_string=f"MARS (Multi-Adapter Rank Sharing) weight merger for PEFT models. Input quantization: {quantized_inputs}, Output quantization: {quantized_outputs}.",
-        model_version=1,
-        domain="com.martinkorelic.mars",
-        opset_imports=[helper.make_opsetid("", 11)]
-    )
-    
-    metadata_entries = [
-        ("quantized_inputs", str(quantized_inputs).lower()),
-        ("quantized_outputs", str(quantized_outputs).lower()),
-        ("input_type", "quantized" if quantized_inputs else "float"),
-        ("output_type", "quantized" if quantized_outputs else "float")
-    ]
-    
-    for key, value in metadata_entries:
-        entry = StringStringEntryProto()
-        entry.key = key
-        entry.value = value
-        model.metadata_props.append(entry)
-
-    onnx.checker.check_model(model)
-    onnx.save(model, output_path)
-    
-    # Updated print statement to reflect the new flags
-    input_type = "quantized" if quantized_inputs else "float"
-    output_type = "quantized" if quantized_outputs else "float"
-    print(f"MARS merger model saved to {output_path} (inputs: {input_type}, outputs: {output_type})")
-    
-    return model
-
-def create_mars_merger_model(output_path="mars_merger_model.onnx", quantized=True):
-    """
-    Creates a fixed ONNX model that merges PEFT (MARS) weights with quantized base weights.
-    
-    MARS (Multi Adapter Rank Sharing) is a parameter-efficient fine-tuning method
-    that decomposes adapter weights into shared and adapter-specific components.
-    
-    The mathematical operation performed is:
-    merged_weight = base_weight + alpha * (adapter_B @ intermediate_chunk @ shared_A)
-    
-    Where:
-    - base_weight: Original model weights (quantized)
-    - adapter_B: Adapter-specific "B" matrix [out_features, rank]
-    - intermediate: Shared intermediate matrix [N*rank, shared_rank] containing chunks for N adapters
-    - intermediate_chunk: Slice of intermediate for current adapter [rank, shared_rank]
-    - shared_A: Shared "A" matrix [shared_rank, in_features]
-    - alpha: Scaling factor for the adapter contribution
-    
-    The matrix multiplication chain:
-    1. adapter_B [out_features, rank] @ intermediate_chunk [rank, shared_rank] 
-       → [out_features, shared_rank]
-    2. result @ shared_A [shared_rank, in_features] 
-       → [out_features, in_features]
-    3. Scale by alpha and add to base weights
-    
-    Args:
-        output_path (str): Path where the ONNX model will be saved
-        
-    Returns:
-        onnx.ModelProto: The created ONNX model
-        
-    Input tensors:
-        - weight_quantized: Base model weights in UINT8 quantized format
-        - x_zero_point: Zero point for base weight quantization (UINT8 scalar)
-        - x_scale: Scale factor for base weight quantization (FLOAT scalar)
-        - shared_A: Shared component matrix (FLOAT [shared_rank, in_features])
-        - intermediate: Combined intermediate matrix for all adapters (FLOAT [N*rank, shared_rank])
-        - adapter_B: Adapter-specific B matrix (FLOAT [out_features, rank])
-        - adapter_index: Index of the adapter to use (INT64 scalar)
-        - rank: Rank of the adapter (INT64 scalar)
-        - alpha: Scaling factor for adapter contribution (FLOAT scalar)
-        
-    Output tensors:
-        - merged_weight_quantized: Final merged weights in UINT8 quantized format
-        - merged_zero_point: Zero point for merged weight quantization (UINT8 scalar)
-        - merged_scale: Scale factor for merged weight quantization (FLOAT scalar)
-    """
-    
-    # Dynamic inputs depending on quantized or not
-    if quantized:
-        inputs = [
-            helper.make_tensor_value_info("weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]),
-            helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []),
-            helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []),
-        ]
-        outputs = [
-            helper.make_tensor_value_info("merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]),
-            helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []),
-            helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, [])
-        ]
-    else:
-        inputs = [
-            helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"]),
-        ]
-        outputs = [
-            helper.make_tensor_value_info("merged_weight", TensorProto.FLOAT, ["out_features", "in_features"]),
-        ]
-
-    # common inputs regardless of quantized or not
-    common_inputs = [
-        helper.make_tensor_value_info("shared_A", TensorProto.FLOAT, ["shared_rank", "in_features"]),
-        helper.make_tensor_value_info("intermediate", TensorProto.FLOAT, ["n_times_rank", "shared_rank"]),
-        helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]),
-        helper.make_tensor_value_info("adapter_index", TensorProto.INT64, []),
-        helper.make_tensor_value_info("rank", TensorProto.INT64, []),
-        helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []),
-    ]
-    inputs.extend(common_inputs)
-
-    nodes = []
-
-    # Step 1: get base_weight_fp32
-    if quantized:
-        nodes.append(
-            helper.make_node(
-                "DequantizeLinear",
-                inputs=["weight_quantized", "x_scale", "x_zero_point"],
-                outputs=["base_weight_fp32"],
-                name="dequantize_base_weights"
-            )
-        )
-    else:
-        # just rename directly
-        nodes.append(
-            helper.make_node(
-                "Identity",
-                inputs=["weight"],
-                outputs=["base_weight_fp32"],
-                name="pass_through_base_weight"
-            )
-        )
-
-    # Step 2: calculate slice boundaries
-    nodes.append(
-        helper.make_node("Mul", ["adapter_index", "rank"], ["slice_start"], name="compute_slice_start")
-    )
-    nodes.append(
-        helper.make_node("Add", ["slice_start", "rank"], ["slice_end"], name="compute_slice_end")
-    )
-    nodes.append(
-        helper.make_node("Unsqueeze", ["slice_start"], ["slice_start_1d"], axes=[0], name="unsqueeze_slice_start")
-    )
-    nodes.append(
-        helper.make_node("Unsqueeze", ["slice_end"], ["slice_end_1d"], axes=[0], name="unsqueeze_slice_end")
-    )
-    nodes.append(
-        helper.make_node(
-            "Constant", [], ["axes_0"],
-            value=helper.make_tensor("axes_0_tensor", TensorProto.INT64, [1], [0])
-        )
-    )
-    nodes.append(
-        helper.make_node(
-            "Slice", ["intermediate", "slice_start_1d", "slice_end_1d", "axes_0"],
-            ["chunked_intermediate"], name="slice_intermediate"
-        )
-    )
-
-    # Step 3: adapter_B @ chunked_intermediate
-    nodes.append(
-        helper.make_node("MatMul", ["adapter_B", "chunked_intermediate"], ["adapter_times_chunk"], name="adapter_chunk_matmul")
-    )
-
-    # Step 4: (adapter_B @ chunked) @ shared_A
-    nodes.append(
-        helper.make_node("MatMul", ["adapter_times_chunk", "shared_A"], ["lora_delta_prealpha"], name="final_matmul")
-    )
-
-    # Step 5: alpha scaling
-    nodes.append(
-        helper.make_node("Mul", ["lora_delta_prealpha", "alpha"], ["lora_delta"], name="scale_alpha")
-    )
-
-    # Step 6: add LoRA delta
-    nodes.append(
-        helper.make_node("Add", ["base_weight_fp32", "lora_delta"], ["merged_weight_fp32"], name="add_delta")
-    )
-
-    # Step 7: quantization if requested
-    if quantized:
-        nodes.append(
-            helper.make_node(
-                "DynamicQuantizeLinear",
-                inputs=["merged_weight_fp32"],
-                outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
-                name="quantize_merged"
-            )
-        )
-    else:
-        # just output the floating-point
-        nodes.append(
-            helper.make_node(
-                "Identity",
-                inputs=["merged_weight_fp32"],
-                outputs=["merged_weight"],
-                name="identity_output"
-            )
-        )
-
-    # put together the graph
-    graph = helper.make_graph(
-        nodes=nodes,
-        name="MARS Merger",
-        inputs=inputs,
-        outputs=outputs,
-        doc_string="MARS merger model for merging adapters (quantized or float)."
-    )
-
-    model = helper.make_model(
-        graph,
-        producer_name="MARS_Merger_v1.0",
-        producer_version="1.0.0",
-        doc_string="MARS (Multi-Adapter Rank Sharing) weight merger for PEFT models.",
-        model_version=1,
-        domain="com.martinkorelic.mars",
-        opset_imports=[helper.make_opsetid("", 11)]
-    )
-
-    onnx.checker.check_model(model)
-    onnx.save(model, output_path)
-    if quantized:
-        print(f"Quantized MARS merger model saved to {output_path}")
-    else:
-        print(f"MARS merger model saved to {output_path}")
-    return model
-
-def test_mars_merger_model(
-    quantized_model_path="mars_merger_fixed.onnx",
-    nonquantized_model_path="mars_merger_nonquant.onnx"
-):
-    """
-    Test both the quantized and non-quantized Mars merger models with sample data.
-    """
-
-    q_session = ort.InferenceSession(quantized_model_path)
-    nq_session = ort.InferenceSession(nonquantized_model_path)
-
-    test_configs = [
-        {"out_features": 512, "in_features": 256, "shared_rank": 4, "rank": 8, "N": 3},
-        {"out_features": 256, "in_features": 128, "shared_rank": 2, "rank": 4, "N": 5},
-    ]
-
-    for i, config in enumerate(test_configs):
-        print(f"\n=== Test {i+1}: {config} ===")
-
-        of = config["out_features"]
-        inf = config["in_features"]
-        shared_rank = config["shared_rank"]
-        rank = config["rank"]
-        N = config["N"]
-
-        # Generate base weight and quantize it with better precision
-        base_weight_fp32 = np.random.randn(of, inf).astype(np.float32) * 0.1
-
-        # --- QUANTIZED TEST ---
-        print("\n[ Quantized model test ]")
-
-        weight_min = float(base_weight_fp32.min())
-        weight_max = float(base_weight_fp32.max())
-        if weight_max - weight_min == 0:
-            weight_max = weight_min + 1e-6
-
-        scale = np.float32((weight_max - weight_min) / 255.0)
-        zero_point = np.uint8(np.clip(np.round(-weight_min / scale), 0, 255))
-
-        weight_quantized = np.clip(np.round(base_weight_fp32 / scale) + zero_point, 0, 255).astype(np.uint8)
-
-        inputs_q = {
-            "weight_quantized": weight_quantized,
-            "x_zero_point": np.array(zero_point, dtype=np.uint8),
-            "x_scale": np.array(scale, dtype=np.float32),
-            "shared_A": np.random.randn(shared_rank, inf).astype(np.float32) * 0.01,
-            "intermediate": np.random.randn(N * rank, shared_rank).astype(np.float32) * 0.01,
-            "adapter_B": np.random.randn(of, rank).astype(np.float32) * 0.01,
-            "alpha": np.array(16.0, dtype=np.float32),
-            "adapter_index": np.array(1, dtype=np.int64),
-            "rank": np.array(rank, dtype=np.int64)
-        }
-
-        # reuse
-        shared_A = inputs_q["shared_A"]
-        intermediate = inputs_q["intermediate"]
-        adapter_B = inputs_q["adapter_B"]
-        alpha = inputs_q["alpha"]
-        adapter_index = inputs_q["adapter_index"]
-
-        try:
-            outputs_q = q_session.run(None, inputs_q)
-            merged_weight_quantized, merged_scale, merged_zero_point = outputs_q[0], outputs_q[2], outputs_q[1]
-
-            # dequantize
-            merged_dequantized = (merged_weight_quantized.astype(np.float32) - merged_zero_point) * merged_scale
-
-            # reference
-            chunk_start = adapter_index * rank
-            chunk_end = (adapter_index + 1) * rank
-            chunked_intermediate = intermediate[chunk_start:chunk_end, :]
-            delta = adapter_B @ chunked_intermediate @ shared_A * alpha
-            expected = base_weight_fp32 + delta
-
-            max_diff = np.max(np.abs(expected - merged_dequantized))
-            rel_error = max_diff / (np.max(np.abs(expected)) + 1e-8)
-
-            print(f"  Quantized max diff: {max_diff:.6f}, relative error: {rel_error:.6f}")
-            if rel_error < 0.1:
-                print("  ✓ Quantized test passed")
-            else:
-                print("  ✗ Quantized test failed")
-        except Exception as e:
-            print(f"  ✗ Quantized test error: {e}")
-
-        # --- NON-QUANTIZED TEST ---
-        print("\n[ Non-quantized model test ]")
-
-        inputs_nq = {
-            "weight": base_weight_fp32,
-            "shared_A": shared_A,
-            "intermediate": intermediate,
-            "adapter_B": adapter_B,
-            "alpha": np.array(alpha, dtype=np.float32),
-            "adapter_index": np.array(adapter_index, dtype=np.int64),
-            "rank": np.array(rank, dtype=np.int64),
-        }
-
-        try:
-            outputs_nq = nq_session.run(None, inputs_nq)
-            merged_fp32 = outputs_nq[0]
-
-            # expected
-            chunk_start = adapter_index * rank
-            chunk_end = (adapter_index + 1) * rank
-            chunked_intermediate = intermediate[chunk_start:chunk_end, :]
-            delta = adapter_B @ chunked_intermediate @ shared_A * alpha
-            expected = base_weight_fp32 + delta
-
-            max_diff = np.max(np.abs(expected - merged_fp32))
-            rel_error = max_diff / (np.max(np.abs(expected)) + 1e-8)
-
-            print(f"  Non-quantized max diff: {max_diff:.6f}, relative error: {rel_error:.6f}")
-            if rel_error < 1e-4:
-                print("  ✓ Non-quantized test passed")
-            else:
-                print("  ✗ Non-quantized test failed")
-        except Exception as e:
-            print(f"  ✗ Non-quantized test error: {e}")
-
-    return
-
-if __name__ == "__main__":
-
-    print("Creating basic LoRA merger model with dynamic shapes...")
-    create_lora_merger_model("lora_qmerger_model.onnx", quantized=True)
-    create_lora_merger_model("lora_merger_model.onnx", quantized=False)
-
-    print("\nTesting basic LoRA merger model...")
-    test_all_lora_merger_models(
-        quantized_model_path="lora_qmerger_model.onnx",
-        float_model_path="lora_merger_model.onnx"
-    )
-
-    # Create the basic LoRA merger model
-    print("Creating basic MARS merger model with dynamic shapes...")
-    basic_model = create_mars_merger_model(
-        output_path="mars_qmerger_model.onnx",
-        quantized=True
-    )
-    basic_model = create_mars_merger_model(
-        output_path="mars_merger_model.onnx",
-        quantized=False
-    )
-    
-    # Test the basic model
-    print("\nTesting basic MARS merger model...")
-    test_results = test_mars_merger_model("mars_qmerger_model.onnx", "mars_merger_model.onnx")
\ No newline at end of file
diff --git a/config.py b/config.py
deleted file mode 100644
index 2d79fd9..0000000
--- a/config.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-HF_TOKEN = os.environ.get('HF_TOKEN')
-
-# Azure OpenAI Configuration
-AZURE_OPENAI_ENDPOINT = os.environ.get('AZURE_OPENAI_ENDPOINT')
-AZURE_OPENAI_API_KEY = os.environ.get('AZURE_OPENAI_API_KEY')
-AZURE_DEPLOYMENT_NAME = os.environ.get('AZURE_DEPLOYMENT_NAME')
-AZURE_MODEL_NAME = os.environ.get('AZURE_MODEL_NAME')
-AZURE_API_VERSION = os.environ.get('AZURE_API_VERSION')
-
-#### EXPERIMENT CONFIG ####
-
-TASK_EPOCHS = {
-    "boolq": 2,
-    "logiqa": 3,
-    "arc_e": 4,
-    "winogrande": 4,
-    "arc_c": 4,
-    "hellaswag": 1,
-    "mini_personalqa": 6
-}
-
-BATCH_SIZE = 32
-PER_DEVICE_BATCH_SIZE = 6
-GRADIENT_ACCUMULATION = 2
-
-EXPERIMENT_RANKS = [2, 8, 32]
\ No newline at end of file
diff --git a/config.yml b/config/config.yml
similarity index 97%
rename from config.yml
rename to config/config.yml
index 9effb2e..b425c0b 100644
--- a/config.yml
+++ b/config/config.yml
@@ -179,7 +179,10 @@ ARTIFACT_BUILDER:
   test_eval: false
 
   inference_export_config:
-    # Whether to include trainable weights as model input
+    # Weight-handoff mode. Only "external_initializer" is supported in v1 (dual-engine, no graph
+    # rewrite); "model_input" (the legacy weight_input path) and "adapter" are fail-closed stubs.
+    handoff_mode: external_initializer
+    # Whether to include trainable weights as model input (legacy toggle for handoff_mode: model_input)
     weight_input : false
     # Whether to include the model metadata
     include_metadata: true
diff --git a/database/json2entity.py b/database/json2entity.py
deleted file mode 100644
index acb4bed..0000000
--- a/database/json2entity.py
+++ /dev/null
@@ -1,168 +0,0 @@
-import json
-
-def extract_uids_from_objectbox_json(json_file_path):
-    """
-    Extract UIDs from ObjectBox default.json file and generate Python entity code
-    """
-    with open(json_file_path, 'r') as f:
-        data = json.load(f)
-    
-    python_code = []
-    
-    for entity in data.get('entities', []):
-        # Extract entity info
-        entity_id_uid = entity['id']  # Format: "ID:UID"
-        entity_id, entity_uid = entity_id_uid.split(':')
-        entity_name = entity['name']
-        
-        # Extract dimensions from entity name (e.g., VectorEntity384 -> 384)
-        dimensions = ''.join(filter(str.isdigit, entity_name))
-        
-        # Start entity definition
-        python_code.append(f"@Entity(uid={entity_uid})")
-        python_code.append(f"class {entity_name}:")
-        
-        # Extract property UIDs
-        for prop in entity.get('properties', []):
-            prop_id_uid = prop['id']  # Format: "ID:UID"
-            prop_id, prop_uid = prop_id_uid.split(':')
-            prop_name = prop['name']
-            
-            # Generate property definition based on name
-            if prop_name == 'id':
-                python_code.append(f"    {prop_name} = Id(id={prop_id}, uid={prop_uid})")
-            elif prop_name == 'embedding':
-                # Check if property has indexId (HnswIndex)
-                if 'indexId' in prop:
-                    python_code.append(f"    {prop_name} = Float32Vector(id={prop_id}, uid={prop_uid}, index=HnswIndex(dimensions={dimensions}, distance_type=VectorDistanceType.COSINE))")
-                else:
-                    python_code.append(f"    {prop_name} = Float32Vector(id={prop_id}, uid={prop_uid})")
-            elif prop_name == 'timestamp':
-                python_code.append(f"    {prop_name} = Property(int, id={prop_id}, uid={prop_uid})")
-            elif prop_name == 'content':
-                # Always add index for content field
-                if 'indexId' in prop:
-                    index_id, index_uid = prop['indexId'].split(':')
-                    python_code.append(f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE, uid={index_uid}))")
-                else:
-                    python_code.append(f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE))")
-            else:
-                # Other string properties (name, document, metadata)
-                if 'indexId' in prop:
-                    index_id, index_uid = prop['indexId'].split(':')
-                    python_code.append(f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE, uid={index_uid}))")
-                else:
-                    python_code.append(f"    {prop_name} = String(id={prop_id}, uid={prop_uid})")
-        
-        python_code.append("")  # Empty line between entities
-    
-    return "\n".join(python_code)
-
-def extract_uids_for_kotlin(json_file_path):
-    """
-    Extract UIDs and generate Kotlin @Uid annotations
-    """
-    with open(json_file_path, 'r') as f:
-        data = json.load(f)
-    
-    kotlin_annotations = []
-    
-    for entity in data.get('entities', []):
-        entity_id_uid = entity['id']
-        entity_id, entity_uid = entity_id_uid.split(':')
-        entity_name = entity['name']
-        
-        # Extract dimensions from entity name
-        dimensions = ''.join(filter(str.isdigit, entity_name))
-        
-        kotlin_annotations.append(f"// {entity_name}")
-        kotlin_annotations.append(f"@Entity")
-        kotlin_annotations.append(f"@Uid({entity_uid})")
-        kotlin_annotations.append(f"data class {entity_name}(")
-        
-        for prop in entity.get('properties', []):
-            prop_id_uid = prop['id']
-            prop_id, prop_uid = prop_id_uid.split(':')
-            prop_name = prop['name']
-            
-            if prop_name == 'id':
-                kotlin_annotations.append(f"    @Id @Uid({prop_uid}) override var {prop_name}: Long = 0,")
-            elif prop_name == 'embedding':
-                kotlin_annotations.append(f"    @HnswIndex(dimensions = {dimensions}, distanceType = VectorDistanceType.COSINE)")
-                kotlin_annotations.append(f"    @Uid({prop_uid}) override var {prop_name}: FloatArray = floatArrayOf(),")
-            elif prop_name == 'content':
-                # Always add @Index for content field
-                kotlin_annotations.append(f"    @Index @Uid({prop_uid}) override var {prop_name}: String = \"\",")
-            else:
-                if prop_name == 'timestamp':
-                    kotlin_annotations.append(f"    @Uid({prop_uid}) override var {prop_name}: Long = System.currentTimeMillis(),")
-                else:
-                    kotlin_annotations.append(f"    @Uid({prop_uid}) override var {prop_name}: String = \"\",")
-        
-        kotlin_annotations.append(")")
-        kotlin_annotations.append("")
-    
-    return "\n".join(kotlin_annotations)
-
-def create_filtered_json_model(json_file_path, entity_names_to_include, output_path="objectbox-model/default.json"):
-    """
-    Create a filtered ObjectBox JSON model that only includes specified entities
-    while preserving their original IDs and UIDs
-    """
-    import os
-    
-    with open(json_file_path, 'r') as f:
-        data = json.load(f)
-    
-    # Filter entities to only include specified ones
-    filtered_entities = []
-    for entity in data.get('entities', []):
-        if entity['name'] in entity_names_to_include:
-            filtered_entities.append(entity)
-    
-    # Create filtered model
-    filtered_data = data.copy()
-    filtered_data['entities'] = filtered_entities
-    
-    # Update lastEntityId to the highest ID among included entities
-    if filtered_entities:
-        last_entity = max(filtered_entities, key=lambda e: int(e['id'].split(':')[0]))
-        filtered_data['lastEntityId'] = last_entity['id']
-    
-    # Ensure output directory exists
-    os.makedirs(os.path.dirname(output_path), exist_ok=True)
-    
-    # Write filtered model
-    with open(output_path, 'w') as f:
-        json.dump(filtered_data, f, indent=2)
-    
-    print(f"✅ Filtered ObjectBox model saved to '{output_path}'")
-    print(f"📋 Included entities: {entity_names_to_include}")
-    
-    return output_path
-
-# Example usage:
-if __name__ == "__main__":
-    # Replace with your actual path
-    json_path = "database/default.json"
-    
-    print("=== PYTHON ENTITIES ===")
-    python_entities = extract_uids_from_objectbox_json(json_path)
-    print(python_entities)
-    
-    print("\n=== KOTLIN ANNOTATIONS ===")
-    print(extract_uids_for_kotlin(json_path))
-
-    # Save Python entities to file
-    with open("vector_entity.py", "w") as f:
-        f.write("from objectbox.model import *\n")
-        f.write("from objectbox.model.properties import Index, IndexType\n\n")
-        f.write("# Auto-generated ObjectBox entities with UIDs from Kotlin\n")
-        f.write("# Generated from: " + json_path + "\n\n")
-        f.write(python_entities)
-    
-    print(f"\n✅ Python entities saved to 'vector_entity.py'")
-    
-    # Create filtered model for Python (example: only include VectorEntity384)
-    entities_to_use = ["VectorEntity384"]  # Modify this list as needed
-    create_filtered_json_model(json_path, entities_to_use)
\ No newline at end of file
diff --git a/docs/ANDROID_CACHE_FORMAT.md b/docs/ANDROID_CACHE_FORMAT.md
new file mode 100644
index 0000000..b7989e7
--- /dev/null
+++ b/docs/ANDROID_CACHE_FORMAT.md
@@ -0,0 +1,89 @@
+# Android cache format
+
+Where an installed model lives on device, and the rules the SDK follows when writing to it. The package
+*schema* is in [MODEL_FORMAT.md](MODEL_FORMAT.md); the Hub side is in
+[HUB_PACKAGE_FORMAT.md](HUB_PACKAGE_FORMAT.md).
+
+## Layout
+
+The cache root defaults to `context.filesDir`. One directory per model, named by
+[`sanitize_repo_id`](HUB_PACKAGE_FORMAT.md#sanitize_repo_id):
+
+```
+<cacheDir>/
+├── org__Tiny-Model/
+│   ├── mobiletransformers_manifest.json
+│   ├── checksums.json                    # the installed variant's digests
+│   ├── tokenizer/                        # flattened from shared/tokenizer (+ chat_template.jinja)
+│   ├── inference/
+│   │   ├── model.onnx, model.onnx_data
+│   │   ├── generation_config.json
+│   │   ├── genai_config.json             # present iff the GenAI engine is supported
+│   │   ├── weight_handoff_map.json
+│   │   ├── <tensor>.bin, <tensor>.bin.sha256
+│   │   └── merger_*.onnx
+│   ├── train/                            # present iff the training feature was installed
+│   │   ├── training_model.onnx, eval_model.onnx, optimizer_model.onnx
+│   │   ├── training_config.json, trainable_parameters.json
+│   │   ├── checkpoint/
+│   │   └── training_state.json           # written by the trainer, not the installer
+│   └── embedding/                        # present iff the RAG feature was installed
+└── .staging/, .download/                 # transient; removed on success
+```
+
+**The variant is flattened away.** On the Hub a package holds several variants; on device exactly one is
+installed, so `variants/<id>/inference/` becomes `inference/`. The installed variant id is recoverable
+from the manifest that ships alongside it.
+
+This is the layout `LLMRepository` already probed before packages existed, which is why installation is
+a pure file operation and the runtime needed no changes to consume Hub models.
+
+## Install is crash-safe
+
+`ModelPackageInstaller` (Kotlin) and `hub/pull.py::install_package` (Python) follow the same sequence:
+
+1. Build the complete new tree in a staging directory (`.staging/<sanitized>` / `.partial/<sanitized>`).
+2. Rename any **existing** install aside to `.retired-<sanitized>-<n>`.
+3. Rename the staged tree into place.
+4. Delete the retired tree.
+
+If step 3 fails, the retired tree is renamed back — a failed update is a no-op, not data loss. The
+ordering matters because a model directory can hold locally trained state (`train/checkpoint`,
+`training_state.json`) that exists nowhere else: deleting the live tree before the replacement is in
+place would destroy it if the process died in between.
+
+Staging directories are always fully removed on success, so `.staging/`/`.download/`/`.retired-*` are
+never part of a healthy cache.
+
+## Reading the cache
+
+`CacheIndex.list(cacheDir)` enumerates installed models with their base model id, size and whether a
+manifest is present — the backing for a package-management UI. It reads only the manifest and the
+directory tree; it never loads a model.
+
+## Writes after install
+
+Only two things modify a model directory after installation:
+
+| Writer | Writes | When |
+| --- | --- | --- |
+| `ORTTrainerNative` | `train/checkpoint`, `train/training_state.json`, `train/training_logs.json` | during/after training |
+| `weight_merger.cpp` | `inference/<tensor>.bin` + `.bin.sha256` | on merge |
+
+The merger overwrites tensors **in place** in `inference/`, atomically (write to a temp file, fsync,
+rename) with a refreshed checksum sidecar. There is no separate `merged/` directory — the inference
+graph references those exact filenames via `weight_handoff_map.json`, so a merge is complete the moment
+the renames land. See [MODEL_FORMAT.md](MODEL_FORMAT.md#checksum-precedence-the-sidecar-wins) for which
+checksum wins afterwards.
+
+## Failure modes
+
+All fail closed:
+
+| Situation | Behaviour |
+| --- | --- |
+| No `weight_handoff_map.json` | nothing was merged — load the base weights (not an error) |
+| Map present, a `.bin` missing or checksum mismatched | `MissingArtifactException` naming the tensor |
+| Merged tensor's dtype/shape/size disagrees with the map | native session creation fails; no fallback to base weights |
+| Partial merge | the merge reports failure; the package is not presented as trained |
+| Requested variant incompatible with the device | `NoCompatibleVariantException` before downloading |
diff --git a/docs/ANDROID_SDK.md b/docs/ANDROID_SDK.md
new file mode 100644
index 0000000..e20cba6
--- /dev/null
+++ b/docs/ANDROID_SDK.md
@@ -0,0 +1,266 @@
+# Android SDK
+
+The `mobiletransformers-android` AAR: load an exported package on a device, generate, fine-tune it with
+LoRA, merge the result back into the inference graph, and query a local RAG store — all on device, with
+no server round trip.
+
+This page is the **consumer's** view. For what a package contains see
+[MODEL_FORMAT.md](MODEL_FORMAT.md); for how one is produced see [EXPORT.md](EXPORT.md); for the exact
+Kotlin signatures see [PUBLIC_API.md](PUBLIC_API.md).
+
+## Requirements
+
+| | |
+| --- | --- |
+| `minSdk` | 24 |
+| `compileSdk` | 34 |
+| ABI | **`arm64-v8a` only** |
+| Storage | the package, uncompressed — a 135M int4 package is ~1.3 GB with the training stage |
+
+**arm64-v8a is the only shipped ABI in v1.** The AAR carries a >1 GB ONNX Runtime `.so` plus the GenAI
+runtime, and the x86_64 builds of ONNX Runtime and tokenizers-cpp do not exist in this project. The
+build refuses to publish an ABI whose native inputs are missing rather than shipping a variant that
+fails at `System.loadLibrary`, so **the library does not run on an x86_64 emulator** — development
+needs a physical arm64 device.
+
+## Install
+
+The AAR is not on Maven Central yet. Publish it locally and consume it from there:
+
+```bash
+make publish-local      # -> ~/.m2/repository/com/martinkorelic/mobiletransformers/
+```
+
+```kotlin
+// settings.gradle.kts
+dependencyResolutionManagement {
+    repositories {
+        mavenLocal()
+        google()
+        mavenCentral()
+    }
+}
+```
+
+```kotlin
+// app/build.gradle.kts
+dependencies {
+    implementation("com.martinkorelic.mobiletransformers:mobiletransformers-android:<version>")
+}
+
+android {
+    defaultConfig {
+        ndk { abiFilters += listOf("arm64-v8a") }
+    }
+}
+```
+
+A worked example lives in [`examples/consumer-app/`](https://github.com/martinkorelic/mobiletransformers/tree/main/examples/consumer-app), which is built against
+mavenLocal by `make consumer-app` — the proof that the published artifact is actually consumable from
+outside this repo.
+
+> **Licence.** The project is currently **CC-BY-NC-4.0**, which does not permit commercial use. This
+> is a known blocker for distributing the AAR; see [RELEASE_CHECKLIST.md](RELEASE_CHECKLIST.md).
+
+## Loading a model
+
+`fromPretrained` is the single entry point. It resolves an installed package, or pulls and atomically
+installs one if it is absent, then loads the features you ask for.
+
+```kotlin
+val model = MobileTransformers.fromPretrained(
+    context = context,
+    repoId  = "HuggingFaceTB/SmolLM2-135M-Instruct",
+)
+
+val result = model.generate("The capital of France is", GenerationConfig(maxNewTokens = 32))
+println(result.text)
+
+model.close()   // releases the native session; not optional
+```
+
+`close()` frees native handles. It is idempotent, but skipping it leaks a session — the library holds
+**one native session at a time** and a leaked one blocks the next `train`/`generate`.
+
+### Features
+
+A package ships stages; you declare which you need, and a stage that is not installed fails closed
+rather than degrading:
+
+```kotlin
+val model = MobileTransformers.fromPretrained(
+    context, repoId,
+    features = setOf(ModelFeature.Inference, ModelFeature.Training),
+)
+```
+
+| feature | needs | gives you |
+| --- | --- | --- |
+| `Inference` | `inference/` | `generate` |
+| `Training` | `train/` | `train`, `merge`, `trainingJob` |
+| `Rag` | `embedding/` | `ingest`, `retrieve`, `generateWithRag` |
+| `GenAI` | `inference/genai_config.json` | selects the GenAI engine (see below) |
+
+Asking for a missing feature raises `FeatureNotInstalledException`, naming what *is* installed.
+
+### Asking the package what it can do
+
+`model.capabilities` is a `RuntimeCapabilities`, computed from the artifacts actually installed. It is
+the honest answer to "what can I offer the user", and the sample app's whole navigation derives from
+it — a UI built on it cannot claim a capability the package lacks, or withhold one it has.
+
+| property | type | means |
+| --- | --- | --- |
+| `supportsTraining` / `supportsMerge` / `supportsRag` / `supportsEmbedding` | `Boolean` | the corresponding stage is installed |
+| `supportsClassification` | `Boolean` | it is a classifier **and** its labels are named. See below |
+| `isClassifier` | `Boolean` | the graph is a classification graph, labels or not |
+| `isEncoderOnly` | `Boolean` | no generative head at all — `generate` will not work |
+| `task` | `PackageTask` | the exported task, incl. `inferenceGraphPrecision` and `labelCount` |
+| `graphPrecision` | `String?` | the **measured** precision of the inference graph |
+| `peftMethods` / `primaryPeftMethod` | `Set<String>` / `String?` | what the package was exported with (`lora`, `lora-xs`, `mars`) |
+| `trainingParameterCount` | `Long` | trainable parameters, from the training config |
+| `toolCalling` / `supportsToolCalling` | `ToolCallSupport` / `Boolean` | whether the package declares a tool-call format |
+| `engine` / `availableEngines` | `InferenceEngine` | resolved engine, and what could be selected |
+| `supportsScheduledTraining` | `Boolean` | WorkManager-backed scheduling is usable |
+
+`supportsClassification` is deliberately **not** `isClassifier`. A classification graph whose labels
+are unknown runs fine and answers `LABEL_3`, which is a number in a costume — so
+`supportsClassification` additionally requires `task.labelCount > 0`. Gate a Classify UI on it.
+
+`graphPrecision` reports what the graph *is*, not what the variant is called. A variant named
+`cpu-int4` legitimately ships an fp32 inference graph; this is the field that tells you so.
+
+## Classification
+
+```kotlin
+if (model.capabilities.supportsClassification) {
+    val result = model.classify("this sentence is grammatical", topK = 5)
+    println("${result.best?.label} ${result.best?.score}")
+}
+```
+
+Asking a decoder to classify **throws** rather than reading generation logits as class scores, which
+would be a confident wrong answer instead of an error. `topK` bounds `result.top`; the full ranking is
+always in `result.scores`.
+
+Prefer showing the distribution over the single top label: a classifier that is 34%/33%/33% has told
+you nothing, and a top label hides that completely.
+
+## Engines
+
+Two inference engines run over the **same** `inference/` directory:
+
+```kotlin
+MobileTransformers.fromPretrained(context, repoId, engine = InferenceEngine.NATIVE)  // default
+MobileTransformers.fromPretrained(context, repoId, engine = InferenceEngine.GENAI)
+```
+
+- **`NATIVE`** — the project's own C++ decode loop over ONNX Runtime. Always available; the floor.
+- **`GENAI`** — onnxruntime-genai. Requires `genai_config.json` in the package.
+
+**Naming an engine is binding.** If you pass `InferenceEngine.GENAI` and it cannot load, you get an
+`EngineUnavailableException` — the library does **not** quietly hand you Native instead. Silent
+substitution is how a cross-engine parity test once compared Native with Native and passed. Pass
+`engine = null` to opt into automatic selection, where falling back to Native *is* the intended
+behaviour.
+
+Check what you actually got with `model.engine`.
+
+## Training and merging
+
+```kotlin
+model.train(
+    DatasetConfig(trainFile = "my_data", task = "cola", maxSequenceLength = 64),
+    TrainConfig(maxSteps = 100, batchSize = 2),
+)
+model.merge()                                   // folds the adapter into the inference weights
+val after = model.generate(prompt, GenerationConfig(maxNewTokens = 32, loadMerged = true))
+```
+
+Two things worth knowing before you build on this:
+
+1. **The caller supplies the data and names the preprocessor.** Packages ship model artifacts, not
+   training sets. `DatasetConfig.trainFile` resolves to `<cacheDir>/<repo>/train/<trainFile>.jsonl`
+   and `task` selects the parser that reads it.
+2. **`merge()` rewrites the package in place.** The per-tensor `.bin` files under `inference/` are
+   overwritten with merged weights. This is deliberate — it is what makes the merged model loadable by
+   the ordinary path — but it means a package is no longer pristine afterwards. Re-install it if you
+   need the original weights back.
+
+On-device training can only re-run within the PEFT topology the package was exported with; asking for a
+different method raises `PeftMismatchException`.
+
+## RAG
+
+```kotlin
+model.ingest(path = "/sdcard/…/notes.md", config = RagConfig())
+val hits   = model.retrieve("query", RagConfig())          // search alone, nothing generated
+val answer = model.generateWithRag("query", RagConfig(), GenerationConfig(maxNewTokens = 64))
+```
+
+`retrieve` is a first-class operation, not only a step inside `generateWithRag`. It needs
+`supportsEmbedding` and nothing else, so it works on a **pure encoder** package that cannot generate at
+all. It is also the only way to judge retrieval on its own: inside a grounded answer, bad retrieval and
+a model ignoring good retrieval are indistinguishable.
+
+`generateWithRag` returns a `GroundedResult` whose `prompt` is the text that was actually assembled —
+without it a bad grounded answer is undebuggable. It takes the same optional `GenerateCallback` as
+`generate`, and a UI should pass one: the grounded path is the slowest thing here, and its first
+callback event is what tells you retrieval is over.
+
+Backed by ObjectBox HNSW with cosine distance. The encoder's output dimension must be one the on-device
+store can index (64/128/256/384/512/768/1024/1536) — the exporter fails closed rather than shipping an
+unusable `embedding/` stage. See [RAG.md](RAG.md).
+
+## Generation results
+
+`GenerationResult` carries more than `text`:
+
+| field | means |
+| --- | --- |
+| `text` | the generated continuation |
+| `promptTokenCount` | how many tokens the prompt consumed |
+| `contextLimit` | the model's context window |
+
+The pair is what lets a UI say "you have used 400 of 2048 tokens" *before* generation truncates
+something. Read them rather than estimating from character counts.
+
+## Tool calls
+
+A package that declares a tool-call format (`capabilities.supportsToolCalling`) can emit a structured
+call instead of prose. The result is a `ToolCallResult`:
+
+- `ToolCallResult.NoCall` — the model answered normally. **This is the common case**, and it is a
+  distinct type rather than a null so a caller cannot forget to handle it.
+- a parsed call — validated against your `ActionSpec` allowlist before anything runs.
+
+`ActionSpec.requiredPermissions` and `IntendedAction.requiredPermissions` declare what an action needs.
+Today every showcased action is install-time, because intent-based actions delegate the sensitive work
+to the target app, which enforces its own permissions behind its own UI. The runtime-request path
+exists for when an action needs one.
+
+Nothing executes without an explicit accept. That is the design, not a sample-app convention.
+
+## Errors
+
+Everything the library raises descends from `MobileTransformersException`, and every failure path is
+fail-closed — there are no silent fallbacks that leave you with a working-looking object doing something
+other than what you asked.
+
+| exception | means |
+| --- | --- |
+| `ModelNotInstalledException` | package absent and no pull configured |
+| `MissingArtifactException` | a required file is missing from the installed package |
+| `FeatureNotInstalledException` | you asked for a stage the package does not carry |
+| `EngineUnavailableException` | the engine you **named** could not load |
+| `PeftMismatchException` | requested PEFT differs from the exported topology |
+
+## Memory
+
+A 135M int4 package peaks around **800 MB RSS** during generation on a Galaxy S21 FE, on either engine.
+Budget for the package on disk *and* that resident peak.
+
+An opt-in `mmap` path zero-copies the trainable tensors instead of reading them into allocator buffers.
+It is **off by default** and currently covers only the trainable split (~8% of weight bytes), which
+measured a ~6% peak reduction — real, but below the 15% the memory gate targets. Treat it as an
+optimisation, not a memory strategy.
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
new file mode 100644
index 0000000..e418b5c
--- /dev/null
+++ b/docs/ARCHITECTURE.md
@@ -0,0 +1,181 @@
+# Architecture
+
+MobileTransformers has two halves that meet at **one on-disk contract**:
+
+- a **host (Python) exporter** that turns an HF model into a device-ready package, and
+- an **Android SDK (Kotlin + C++)** that installs that package, trains against it, merges the result
+  back into it, and generates from it.
+
+Nothing crosses that boundary except files. There is no RPC, no shared process, and no code sharing —
+which is why the file formats ([MODEL_FORMAT.md](MODEL_FORMAT.md),
+[HUB_PACKAGE_FORMAT.md](HUB_PACKAGE_FORMAT.md)) are specified as carefully as they are.
+
+```
+   HOST (Python)                          HUB                    DEVICE (Android)
+┌──────────────────────┐          ┌────────────────┐      ┌────────────────────────────┐
+│ export.pipeline      │  push    │ model package  │ pull │ HubDownloader              │
+│  ├ inference stage   ├─────────►│  manifest      ├─────►│  └ VariantSelector         │
+│  ├ training stage    │          │  variants/     │      │ ModelPackageInstaller      │
+│  └ embedding stage   │          │  shared/       │      │        │                   │
+└──────────┬───────────┘          └────────────────┘      │        ▼                   │
+           │                                              │ MobileTransformers         │
+           │ weight_handoff_map.json                      │  .fromPretrained           │
+           └──────────── the contract ────────────────────┤        │                   │
+                                                          │        ▼                   │
+                                                          │ MobileTransformerModel     │
+                                                          │  train ─► merge ─► generate│
+                                                          └────────────────────────────┘
+```
+
+## The three registries
+
+Closed-set behaviour is resolved from **data**, never from string comparisons. Adding a model, PEFT
+method or merger is a registry row, not a new `if` branch — and a CI guard (`make guard`) fails the
+build if a dispatch literal reappears.
+
+| Registry | Keyed by | Answers |
+| --- | --- | --- |
+| `config/registry/architecture.py` | `config.architectures[0]` | which Optimum `OnnxConfig`, which inference builder, target modules, attention-module name |
+| `config/registry/peft.py` | `PEFTMethod` | which PEFT config class, the adapter component schema (the codec's tensor order), the merger variant, the adapter-mapping builder |
+| `config/registry/merger.py` | `(PEFTMethod, quant_in, quant_out)` | the resolved `MergerVariant` + the merger ONNX filename |
+
+The resolved `MergerVariant` is written into the package, so the device selects its merger session from
+a typed tag rather than re-deriving one.
+
+## Enums cross three languages
+
+`config/constants.py` is the single source of truth. `codegen/enums.py` generates `schemas/enums.json`
+and checks the Kotlin mirrors under `constants/`; the C++ mirror
+(`cpp/constants/merger_variant.h`) is covered by the host googletest suite. `make parity` fails on any
+drift, so a wire value cannot change in one language only.
+
+## Host: the export pipeline
+
+`export_package` resolves a side-effect-free `ExportPlan` (what `--dry-run` prints), then builds the
+selected **stages** into a staging tree and hands the reshape + manifest to `assemble_package`:
+
+| Stage | Profile | Produces |
+| --- | --- | --- |
+| `inference` | `export` (optimum-onnx, py3.12) | normalized `model.onnx` (+ `model.onnx_data`), `generation_config.json`, `genai_config.json`, `optimum_config.json`, tokenizer, an empty handoff map |
+| `training` | `ort-training-local` (py3.12) | training/eval/optimizer graphs, `checkpoint/`, `trainable_parameters.json`, and the **real** handoff map (the trainable split) |
+| `embedding` | `export` | the RAG embedding subtree |
+
+The two profiles are declared **conflicting** in `pyproject.toml` and cannot co-install, so a full
+package is produced by two runs into the same `--output`; re-assembly preserves the stages already
+present. Stage selection is automatic by request + importable dependencies, overridable with `--stages`,
+and a skipped stage is logged rather than silently dropped.
+
+## Device: engines
+
+`ModelRuntime` is the engine interface. Two implementations read the **same** `inference/` directory:
+
+| Engine | Backing | Notes |
+| --- | --- | --- |
+| `NATIVE` | ONNX Runtime **training** build, `cpp/` | the guaranteed floor; owns training, merging and the KV-cached generation loop |
+| `GENAI` | `onnxruntime-genai` | opt-in; requires `genai_config.json` in the package |
+
+`ModelRuntimeFactory.selectEngine` is pure and reads `ORTGenerationConfig.engine`; `.create` performs
+the availability probe and falls back to Native transparently. Callers never branch on engine, and both
+engines drive identical callback sequences.
+
+**The two runtimes coexist by soname separation.** GenAI needs stock ORT ≥1.26 while the native trainer
+is built against ORT-training 1.23, and the GenAI AAR ships no ORT of its own — it `dlopen`s the app's.
+Shipping a distinct-soname `libort_gen.so` and repointing GenAI's `dlopen` at it lets both load in one
+process. Each ORT exports only a handful of symbols (hidden visibility) and GenAI resolves via `dlsym`
+on its own handle, so there is no interposition; the distinct soname is essential, since a shared one
+makes the linker dedupe them.
+
+## Device: train → merge → generate
+
+1. **Train.** `ORTTrainerNative` runs the ORT training loop against `train/`. Checkpoints are
+   `train/checkpoint` + `training_state.json`; cancellation is cooperative (`cancelRequested` checked
+   at the step/epoch loop tops) so the existing save path still runs.
+2. **Merge.** `weight_merger.cpp` reads the handoff map, runs the resolved merger graph per trainable
+   layer, and writes each merged tensor's **raw bytes** over the exact `<name>.bin` the inference graph
+   references — atomically, with a refreshed `.sha256` sidecar. A partial merge fails the whole
+   operation rather than reporting success.
+3. **Generate.** `HandoffPrecondition` gates the load (map present, every `.bin` present, checksums
+   match) *before* the session is created; `session_cache.h` then loads those raw bytes as external
+   initializers using the map's per-role dtype/shape. Any failure aborts session creation instead of
+   quietly falling back to the frozen base weights.
+
+The invariant throughout: **a wrong model is worse than no model.** Every gate on this path fails
+closed, because a silently-unmerged model still generates fluent text and looks healthy.
+
+## Native dependencies
+
+**A `git clone` cannot build the Android SDK.** Roughly 180 MB of prebuilt binaries and vendored
+headers are gitignored — they are the only thing the clone does not bring, and everything else
+(`build/`, `.venv*`, `.gradle`, `.cxx`) is recreatable.
+
+| what | where | size |
+| --- | --- | --- |
+| ONNX Runtime, GenAI, tokenizers, protobuf | `MobileTransformers/src/main/jniLibs/arm64-v8a/` (8 files) | 116 MB |
+| the GenAI Android AAR | `MobileTransformers/src/main/aarLibs/onnxruntime-genai.aar` | 40 MB |
+| protobuf headers/sources | `MobileTransformers/src/main/cpp/includes/{google,protobuf}` | 24 MB |
+| the source-built ORT-training wheel | `third_party/wheels/onnxruntime_training-…-cp312-linux_x86_64.whl` | 632 MB |
+
+```bash
+make doctor                                  # what is missing, and the command that fixes each
+make fetch-native-deps                       # the Android natives
+TRAINING=1 scripts/fetch_native_deps.sh      # those plus the ORT-training wheel (632 MB)
+SYMBOLS=1  scripts/fetch_native_deps.sh      # plus the unstripped debug symbols (260 MB)
+```
+
+[`third_party/android/manifest.json`](https://github.com/martinkorelic/mobiletransformers/blob/main/third_party/android/manifest.json) is the source of truth:
+one entry per artifact with its destination, size, **sha256** and provenance.
+`scripts/fetch_native_deps.sh` reads it, verifies the archive hash, unpacks, then verifies every file
+individually. It refuses rather than half-populating — a partly-filled `jniLibs/` fails the link
+naming a missing *symbol*, not a missing file.
+
+The training wheel is fetched separately (`TRAINING=1`) because only the export host needs it. It is
+`cp312` + `linux_x86_64`, so **macOS and Windows cannot run the training side** without rebuilding it
+(`third_party/onnxruntime/BUILD.md`). Everything else — every host gate, every Android build,
+inference export, PEFT materialization, federated — works anywhere, and `make check` does **not**
+need the wheel: the Makefile runs `uv run --frozen` precisely so a missing local wheel cannot break
+an unrelated target.
+
+### Why two ONNX Runtimes ship side by side
+
+GenAI 0.14 needs stock ORT ≥ 1.26; the Native/training path needs the source-built ORT-training 1.23.
+Both would otherwise carry the soname `libonnxruntime.so`, the linker dedups them, and GenAI silently
+gets the training build — observed as a SIGABRT.
+
+The resolution is a distinct name, not a version bump: stock ORT 1.27 ships as `libort_gen.so` with a
+**raw-patched SONAME** (not `patchelf`, which corrupts `verneed`), and the genai `.so`'s `dlopen`
+target is raw-patched to match. Training ORT keeps `libonnxruntime.so`. This is safe because each ORT
+exports only a handful of symbols under hidden visibility and GenAI resolves through `dlsym` on its
+own handle, so there is no interposition. Reproducible via
+`spikes/genai_external_swap/setup_ort_separation.sh`.
+
+### arm64-v8a only
+
+`jniLibs/x86_64/` never had `libonnxruntime.so` or the tokenizer archives — absent here *and*
+upstream — so `libmobiletransformers.so` has never existed for that ABI. It was dropped from
+`abiFilters` rather than advertising an ABI that dies at `System.loadLibrary`. Restoring it means
+building ORT-training and tokenizers-cpp for x86_64 first. **There is no x86_64 emulator path.**
+
+The shipped binaries are stripped. AGP strips native libraries at packaging anyway, and to the same
+bytes as `llvm-strip --strip-all`, so unstripped prebuilts cost clone size and never APK size. The
+unstripped originals exist only in the debug-symbols bundle and cannot be regenerated without a full
+ORT source build.
+
+## Concurrency
+
+One native session at a time. `LLMRepository` holds a `Mutex` across session create/teardown for the
+training, generation and retrieval paths — the ORT handles are not safe to swap concurrently. The lock
+is *not* held across a full training run or generation loop, so a long job never blocks release.
+
+## Testing
+
+| Layer | Harness | Runs |
+| --- | --- | --- |
+| Python | pytest (`make check`) | every PR |
+| Kotlin | JUnit + Robolectric (`make test-jvm`) | every PR |
+| C++ | googletest, ORT-free headers (`make test-cpp`) | every PR |
+| Guards | `make guard` — secret reads, dispatch literals | every PR |
+| Android assemble | Gradle + NDK | self-skips without the vendored native libs |
+| Device | `androidTest` | manual: `make device-package` → `make device-test` |
+
+Everything that can be tested without a device is; the instrumented classes all `assumeTrue` on a
+pushed package, so they skip rather than fail when one is absent.
diff --git a/docs/CATALOG.md b/docs/CATALOG.md
new file mode 100644
index 0000000..ae59117
--- /dev/null
+++ b/docs/CATALOG.md
@@ -0,0 +1,101 @@
+# The model catalog
+
+Six packages, published under [`mobiletransformers`](https://huggingface.co/mobiletransformers) on
+the Hugging Face Hub. These are the entries the sample app's **Models ▸ Catalog** tab offers, and
+they are what the app is meant to be tried with.
+
+Every one ships **both an inference and a training stage**. That is a hard requirement of
+`scripts/publish_catalog.sh`, asserted rather than assumed: a shelf entry that cannot be fine-tuned
+demonstrates half the framework.
+
+## What is published
+
+| model | task | inference | total | features | PEFT |
+| --- | --- | --- | --- | --- | --- |
+| [SmolLM2-135M-Instruct](https://huggingface.co/mobiletransformers/SmolLM2-135M-Instruct) | text-generation | 663 MB | 935 MB | inference, train, rag | LoRA |
+| [functiongemma-270m-it](https://huggingface.co/mobiletransformers/functiongemma-270m-it) | text-generation | 3557 MB | 3875 MB | inference, train | LoRA |
+| [gemma-3-270m-it](https://huggingface.co/mobiletransformers/gemma-3-270m-it) | text-generation | 1814 MB | 2131 MB | inference, train | **MARS** |
+| [Qwen2.5-0.5B-Instruct](https://huggingface.co/mobiletransformers/Qwen2.5-0.5B-Instruct) | text-generation | 2554 MB | 3212 MB | inference, train, rag | LoRA |
+| [all-MiniLM-L6-v2](https://huggingface.co/mobiletransformers/all-MiniLM-L6-v2) | text-classification | 94 MB | 214 MB | inference, train, rag | LoRA |
+| [distilbert-sst2-english](https://huggingface.co/mobiletransformers/distilbert-sst2-english) | text-classification | 270 MB | 361 MB | inference, train | LoRA |
+
+Sizes are **measured** off each pushed package's manifest — the sum of `fileSizes` — not estimated.
+"inference" is the group a plain install downloads; asking for `train` or `rag` adds to it. The `rag`
+group is ~91 MB on every decoder above, because it is the same all-MiniLM-L6-v2 embedder each time.
+
+`mobiletransformers/functiongemma-270m-it` is public. The other five are **private**; making them
+public is a deliberate separate step. Set `HF_TOKEN` to reach them (see
+[`.env.example`](https://github.com/martinkorelic/mobiletransformers/blob/main/.env.example)).
+
+## Which one to start with
+
+**SmolLM2-135M-Instruct.** Smallest useful chat model here, fastest to pull, fastest to train, and
+the model every parity check in this repo is measured against.
+
+- **Chat quality, and the memory ceiling** → Qwen2.5-0.5B-Instruct. Roughly four times the size and
+  noticeably more fluent; a few tokens per second on a mid-range phone, which is the honest cost.
+- **Tool calls** → functiongemma-270m-it. Turns an instruction into a structured call that the app's
+  allowlist validates before anything runs.
+- **Classify** → distilbert-sst2-english. The only entry with *trained* labels
+  (`NEGATIVE`/`POSITIVE`), so the Classify screen says something meaningful on the first tap.
+- **MARS** → gemma-3-270m-it. Multi-Adapter Rank Sharing is this project's own method: layers share
+  a down-projection instead of each carrying its own, so the trainable parameter count grows with
+  rank rather than with depth — 279,936 parameters against a 268M backbone. It is the only entry that
+  is not LoRA, and the reason the shelf has more than one Gemma-3 on it.
+- **Retrieval alone, and the smallest training run** → all-MiniLM-L6-v2. An encoder, so the drawer
+  hides Chat for it; see the note below.
+
+## Two things about the encoders that read as bugs and are not
+
+**all-MiniLM-L6-v2 is exported as `text-classification`, not `feature-extraction`.** That is what
+makes an encoder trainable at all: `TaskSpec.default_stages` emits a training stage exactly when the
+task is trainable, and `FEATURE_EXTRACTION` is declared `trainable=False`, so exporting it the
+"natural" way yields an inference-only package. Task auto-selection never picks `text-classification`
+— it has to be named.
+
+**So its classification head is randomly initialised, and its labels are `LABEL_0`/`LABEL_1`.** The
+head does not exist in a sentence-encoder checkpoint; it is precisely the part fine-tuning learns. The
+pretrained *backbone* is what must survive, and that is what the export-time parameter budget checks.
+Because the labels are meaningless, `supportsClassification` is false and the app hides Classify for
+this package. That is correct and self-consistent — DistilBERT is the entry to use when you want a
+classifier that already works.
+
+## Reproducing the shelf
+
+```bash
+make publish-catalog                          # export + gate-check + push all six
+ONLY=smollm2 PUSH=0 scripts/publish_catalog.sh    # one entry, no upload
+KEEP=1 scripts/publish_catalog.sh                 # skip re-export where a package already exists
+```
+
+Needs `HF_TOKEN_ORG` in `.env` — a token with `repo.write` on the target org. A fine-grained personal
+token scoped to one repo returns `RepositoryNotFoundError` for every other, and the Hub returns that
+identically for "does not exist" and "you cannot see it", so a permissions problem reads as a typo.
+See [`.env.example`](https://github.com/martinkorelic/mobiletransformers/blob/main/.env.example).
+
+The script keeps the per-model task and engine flags, which are not obvious and fail late when wrong:
+
+- `--task text-classification` is what makes an encoder trainable (above).
+- `--genai` is **decoder-only**, and off for Gemma-3 even though it is a decoder: Gemma-3 exports
+  through optimum rather than the GenAI builder, so the package declares native only. A
+  classification or feature-extraction graph has no KV cache at all, and the export refuses to write
+  a `genai_config.json` describing a cache the graph does not have.
+- `--peft` is a property of the package, not a runtime choice: the topology is baked into the
+  training graph, so a device can only select what the export built.
+
+The app's copy of this table lives in
+`MobileTransformersApp/src/main/assets/model_catalog.json`. Adding a model there is editing JSON — no
+code. Keep the two in step: the app claims sizes and features per entry, and a catalog that disagrees
+with what was pushed is worse than no catalog.
+
+## Measured on device
+
+Not yet recorded for this release. Tokens/second per package needs a real device run; see
+[`RELEASE_CHECKLIST.md`](RELEASE_CHECKLIST.md). Numbers are deliberately absent rather than estimated
+— a throughput figure nobody measured is the kind of claim this project's gates exist to prevent.
+
+## Related
+
+- [SHOWCASE.md](SHOWCASE.md) — a tour of the app, and which package each capability needs
+- [HUB_PACKAGE_FORMAT.md](HUB_PACKAGE_FORMAT.md) — what is actually in one of these repos
+- [EXPORT.md](EXPORT.md) — producing your own
diff --git a/docs/COMPATIBILITY_MATRIX.md b/docs/COMPATIBILITY_MATRIX.md
new file mode 100644
index 0000000..7e0a8f9
--- /dev/null
+++ b/docs/COMPATIBILITY_MATRIX.md
@@ -0,0 +1,21 @@
+# Compatibility Matrix
+
+> **Generated** — rendered from `model_support_matrix.json`. Do not hand-edit. Regenerate with `mobiletransformers support-matrix --md docs/COMPATIBILITY_MATRIX.md` under the `export` profile (live detection needs transformers + optimum).
+
+- Generated at: `2026-07-14T00:00:00Z`
+- Toolchain: optimumOnnxVersion=0.1.0, transformersVersion=4.46.2
+
+## Axes (enumerated from the registries/enums — not hand-maintained)
+
+- **PEFT method:** lora, lora-xs, mars, all, nolora
+- **Quantization:** QInt8, QUInt8, int4
+- **Merger variant:** lora, lora_q, mars_q
+- **Engine:** native, genai (native is the guaranteed path; genai is opt-in)
+- **Status pipeline (each implies all earlier ones):** Optimum export → Package → Train artifacts → Android inference → Android training → RAG
+
+| Model | Type | Task | Optimum export | Package | Train artifacts | Android inference | Android training | RAG | Evidence / blockers |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| `HuggingFaceTB/SmolLM2-135M` | llama | text-generation-with-past | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ | no android probe recorded for android_inference_ready |
+| `Qwen/Qwen2-0.5B` | qwen2 | text-generation-with-past | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ | no android probe recorded for android_inference_ready |
+| `sentence-transformers/all-MiniLM-L6-v2` | bert | feature-extraction | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | MARS/PEFT target modules not verified for this architecture |
+
diff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.md
new file mode 100644
index 0000000..3c71b38
--- /dev/null
+++ b/docs/CONFIGURATION.md
@@ -0,0 +1,130 @@
+# Configuration
+
+MobileTransformers configuration is a **typed, closed-set** contract. Every closed string set is an enum
+mirrored 1:1 between Python and Kotlin; every cross-boundary config is a Pydantic v2 model with a generated
+JSON schema; and every extension point (PEFT method, architecture, merger) is a registry entry. This page is
+sourced from the config contract owner, `src/mobiletransformers/config/`.
+
+## Enum vocabulary (Python ↔ Kotlin mirrors)
+
+The enums in `config/constants.py` are the single Python source of truth for every closed string set. Each
+has a hand-written Kotlin `enum class` mirror, and `python -m mobiletransformers.codegen.enums --check` is the
+CI parity gate that fails on drift. The **wire value** (right column) is the on-disk / JSON string.
+
+| Enum | Values (wire) |
+| --- | --- |
+| `SamplingMethod` | `greedy`, `top_k`, `top_p` |
+| `SchedulerType` | `linear`, `cosine` |
+| `ExecutionProvider` | `cpu`, `xnnpack`, `nnapi` |
+| `CoreConfigId` | `opt1`, `opt2`, `opt3` |
+| `MemoryConfigId` | `low_mem`, `high_perf` — see [Memory profiles](#memory-profiles) |
+| `SearchType` | `semantic`, `text` |
+| `QuantizationType` | `QInt8`, `QUInt8`, `int4` |
+| `PEFTMethod` | `lora`, `lora-xs`, `mars`, `all`, `nolora` |
+| `TaskType` | `text-generation`, `feature-extraction` |
+| `HandoffMode` | `external_initializer` (v1), `model_input`, `adapter` |
+| `MergerVariant` | `lora`, `lora_q`, `mars_q` (device-resolved, not a user choice) |
+
+`ExportFrontend` (`optimum-onnx`, `torch.onnx`) is build-time/Python-only — Android never sees it, so it has
+no Kotlin mirror and no parity obligation.
+
+## Memory profiles
+
+`MemoryConfigId` selects ORT session options in `session_cache.h`:
+
+| value | session options | default for |
+| --- | --- | --- |
+| `high_perf` | `EnableMemPattern()` + `EnableCpuMemArena()` | inference, retrieval |
+| `low_mem` | `DisableMemPattern()` + `DisableCpuMemArena()` | **training** |
+
+**Training defaults to `low_mem` and this is not a conservative guess.** The memory-pattern planner
+pre-allocates the whole backward activation plan, and the CPU arena grows to the run's peak and never
+returns it. Measured on an S21 FE (5.5 GB RAM): FunctionGemma-270M — 268,098,176 parameters, ~1.07 GB
+of fp32 weights, a 368,640-parameter LoRA — reached **2.35 GB RSS + 1.02 GB swap** under `high_perf`
+and was killed by `lmkd`; the identical run completes under `low_mem`.
+
+The failure has no error to catch. Android sends **SIGKILL**, so the app disappears with no exception,
+no `finally` and no checkpoint — which is why the default matters more than it would elsewhere.
+
+Three sites set it and all three must agree, because each is a separate way to get `high_perf` back:
+
+- `ORTTrainingConfig.deviceOptions` — the engine-level default;
+- `parseTrainingArguments` in `FileUtil.kt` — **the one that decides real runs**, because exported
+  `training_config.json` files carry no `deviceOptions` section at all, so its fallback *is* the
+  setting;
+- `config.TrainConfig.device` — what an app passes.
+
+`TrainingMemoryProfileTest` pins all three, that the public default survives the mapping to the engine
+config, that an explicit `high_perf` in a package config is still honoured, and that inference is
+unaffected.
+
+If your app holds one `DeviceConfig` and fans it across every config, **exclude the training memory
+profile** — otherwise the first visit to a device-settings screen silently restores `high_perf` for
+training. The sample app's `AppConfig.updateDevice` shows the shape.
+
+## Cross-boundary config models
+
+The Pydantic v2 models in `config/models.py` define the three on-disk configs the device reads
+(`training_config.json`, `generation_config.json`, `rag_config.json`). They share a base with
+`populate_by_name=True`, `extra="ignore"`, `use_enum_values=True`:
+
+- **`extra="ignore"`** (not `forbid`) — readers tolerate unknown fields so additive minor schema bumps stay
+  non-breaking.
+- Field names are snake_case in Python; the **wire/JSON name is the camelCase `alias`** (e.g. `maxSequenceLength`).
+- Cross-boundary models carry `schemaVersion` / `minReaderVersion` and fail closed on an unsupported major.
+
+`GenerationConfig` (`generation_config.json`):
+
+| Field (wire) | Default | Type |
+| --- | --- | --- |
+| `maxSequenceLength` | `128` | int |
+| `sampling` | `SamplingConfig()` | `{ method, temperature, topK, topP, seed }` |
+| `deviceOptions` | `DeviceOptions()` | `{ enableProfiling, coreConfigId, memoryConfigId, executionProvider }` |
+
+`TrainingConfig` (`training_config.json`):
+
+| Field (wire) | Default | Type |
+| --- | --- | --- |
+| `peftMethod` | `lora` | `PEFTMethod` |
+| `rank` | `8` | int |
+| `alpha` | `16` | int |
+| `maxSteps` | `10` | int |
+| `scheduler` | `LinearScheduler()` | discriminated on `schedulerType` (`linear` → start/end factor; `cosine` → minLearningRate/warmupSteps) |
+| `quantization` | `QuantizationOptions()` | weight type + symmetry/subgraph flags |
+
+`RagConfig` (`rag_config.json`):
+
+| Field (wire) | Default | Type |
+| --- | --- | --- |
+| `searchType` | `semantic` | `SearchType` |
+| `topK` | `5` | int |
+| `embeddingDim` | `384` | int |
+
+The set of models that emit a checked-in schema is `CROSS_BOUNDARY_MODELS`; `schemas/*.schema.json` are
+regenerated from these by the codegen module and validated for drift in CI. Devices enforce the contract by
+**typed fail-closed parsing**, not runtime schema validation.
+
+## Registries — the public extension points
+
+Adding support for a new PEFT method, model architecture, or merger is a **registry entry**, not new dispatch
+code. The registries live in `config/registry/`:
+
+- **`peft.py` — `PEFT_REGISTRY`** (`PEFTMethod` → `PEFTMethodSpec`). A spec declares the `config_class` (lazy
+  dotted path), the `component_schema` (ordered `AdapterComponent`s — the **source of truth for tensor naming**
+  consumed by `TrainableTensorCodec`), and the fp/quantized merger variants. To add a method: add a
+  `PEFTMethod` enum member + one `PEFT_REGISTRY` row.
+- **`architecture.py` — `ARCHITECTURE_REGISTRY`**. Maps a model architecture to its export config and the
+  attention-module naming used by the weight-handoff name rewrite. To add an architecture: add a registry
+  entry (no KV-cache-specific dispatch to touch).
+- **`merger.py` — `MERGER_REGISTRY`** + `resolve_merger`/`build_merger_model`. Maps a resolved `MergerVariant`
+  to the ONNX-graph merger builder. The variant is **derived** on device from adapter shape + quantization,
+  not chosen by the user.
+
+Lookups fail closed: an unknown method/architecture/merger raises a typed error naming the offender rather
+than silently falling back.
+
+## Precedence
+
+Runtime settings resolve with the precedence **CLI > environment > YAML (`config/config.yml`) > model
+default** (`config/settings.py` / `resolve()`). Secrets never live in `constants.py`; they belong in
+`config/settings.py`.
diff --git a/docs/COOKBOOK.md b/docs/COOKBOOK.md
new file mode 100644
index 0000000..7d67810
--- /dev/null
+++ b/docs/COOKBOOK.md
@@ -0,0 +1,357 @@
+# Cookbook
+
+Copy-pasteable Kotlin for each thing the SDK does. Every snippet uses **only the public facade** —
+`MobileTransformers`, `MobileTransformerModel`, and the `config/` types. No `ORT*`, `*Native` or
+`*Repository` type appears here, and none should appear in your app either.
+
+Each recipe mirrors a screen in the sample app (`MobileTransformersApp`), so the documentation and the
+worked example cannot describe different APIs. The screen is named under each heading.
+
+> **Device reality.** arm64-v8a only; there is no x86_64 emulator build. Most calls below do nothing
+> until a package is installed, so start with the first recipe.
+
+---
+
+## 1. Pull a model from the Hub, with progress
+
+*Sample app: Models screen.*
+
+`fromPretrained` installs the package when it is missing, then loads it. Download progress is reported
+through `DownloadProgress`; `fraction` is `null` until the download plan is known, which is the honest
+state for "total not yet resolved".
+
+```kotlin
+val model = MobileTransformers.fromPretrained(
+    context = context,
+    repoId = "HuggingFaceTB/SmolLM2-135M-Instruct",
+    features = setOf(ModelFeature.Inference),
+    onDownloadProgress = { progress ->
+        Log.i("pull", "${progress.filesDone}/${progress.filesTotal} ${progress.path}")
+    },
+)
+```
+
+Ask for a feature only if you need it. Requesting one the package does not ship fails closed with
+`FeatureNotInstalledException` at construction rather than at first use.
+
+### Private or gated repos
+
+Pass a `HubConfig`. Without one the pull is anonymous, and a private repo fails with a 401 that looks
+like any other network error:
+
+```kotlin
+val model = MobileTransformers.fromPretrained(
+    context = context,
+    repoId = "your-org/your-private-package",
+    hubConfig = HubConfig(token = yourToken),
+)
+```
+
+**Where `yourToken` comes from is your app's decision, and it matters.** A production app should obtain
+one at runtime — from the user, or from a backend that authenticates them — and never store it in the
+APK. The sample app takes the development shortcut instead, and says so: its `build.gradle.kts` reads
+the `HF_TOKEN` environment variable at build time into `BuildConfig.HF_TOKEN`.
+
+```bash
+HF_TOKEN=hf_xxx ./gradlew :MobileTransformersApp:assembleDebug
+# or, without exporting it:
+./gradlew :MobileTransformersApp:assembleDebug -PmtHubToken=hf_xxx
+```
+
+A token compiled into an APK is **extractable** — `strings` over the dex is enough. That is acceptable
+for reaching your own private repo on your own device, and not acceptable for anything you distribute.
+
+### What is already installed?
+
+```kotlin
+MobileTransformers.installed(context).forEach { pkg ->
+    Log.i("cache", "${pkg.sanitizedRepoId} ${pkg.sizeBytes / (1024 * 1024)} MB ${pkg.variantIds}")
+}
+```
+
+---
+
+## 2. Generate, with streaming
+
+*Sample app: Chat screen.*
+
+```kotlin
+val result = model.generate(
+    prompt = "The capital of France is",
+    config = GenerationConfig(
+        maxNewTokens = 64,
+        sampling = SamplingConfig(method = SamplingMethod.GREEDY),
+    ),
+    callback = object : GenerateCallback {
+        override fun onPartialResult(progress: GenerateProgress) {
+            print(progress.token)          // token-by-token, in order
+        }
+    },
+)
+Log.i("gen", "${result.tokenCount} tokens at ${result.avgTokensPerSecond} tok/s")
+```
+
+---
+
+## 3. Choose an engine
+
+*Sample app: Chat screen, engine picker.*
+
+`Native` is the guaranteed floor. `GenAI` is selectable only when **all three** hold: the installed
+package ships `inference/genai_config.json`, its manifest variant declares `genai` in
+`supportedEngines`, and the device's GenAI probe succeeds. Ask, rather than guessing:
+
+```kotlin
+if (InferenceEngine.GENAI in model.capabilities.availableEngines) {
+    // reload with the other engine; the engine is fixed at load time
+    val genai = MobileTransformers.fromPretrained(
+        context = context,
+        repoId = repoId,
+        engine = InferenceEngine.GENAI,
+    )
+}
+```
+
+Naming an engine you cannot have raises `EngineUnavailableException` instead of quietly giving you
+Native. Silent substitution is what made an earlier engine-parity test compare Native with Native and
+pass.
+
+**Most packages are Native-only, including ones that ship a `genai_config.json`.** Gemma-3 packages
+(FunctionGemma among them) are exported through optimum's `main_export` rather than the vendored
+GenAI builder, so their manifests declare `supportedEngines: ["native"]` even though optimum writes a
+`genai_config.json` beside the graph. `availableEngines` applies the manifest condition too, so it and
+the loader always agree — check it and offer only what it contains.
+
+---
+
+## 4. Fine-tune on device, then merge
+
+*Sample app: Train screen.*
+
+Use `trainingJob()` when you want status, events, cancellation or resume; `train()` is the one-shot
+convenience.
+
+```kotlin
+val job = model.trainingJob()
+
+launch { job.status.collect { status -> Log.i("train", status.toString()) } }
+
+job.start(
+    dataset = DatasetConfig(trainFile = "my_data", task = "mobile_actions", maxSequenceLength = 160),
+    config = TrainConfig(
+        maxSteps = 120,
+        batchSize = 2,
+        learningRate = 5e-4f,
+        // The optimizer steps on `globalStep % gradientAccumulationSteps == 0`. At the default of 4
+        // a short bounded run can finish, report success, and apply no update at all.
+        gradientAccumulationSteps = 1,
+        mergeAtEnd = true,
+    ),
+)
+```
+
+Two things worth knowing before you size a run:
+
+* **`maxSteps` is an upper bound.** Training also stops at the end of the epoch, so `rows / batchSize`
+  wins when it is smaller — a run asking for 120 steps over 108 rows at batch 2 takes 54.
+* **Cancelling is resumable.** `job.cancel(saveCheckpoint = true)` sets a cooperative flag; the loop
+  breaks at the next step boundary and writes a checkpoint, and `job.canResume` then reads `true`.
+
+### Memory: training defaults to `low_mem`, and you should leave it there
+
+`TrainConfig().device.memoryConfigId` is `MemoryConfigId.LOW_MEM`, unlike `GenerationConfig`'s
+`HIGH_PERF`. That is not a conservative guess — `HIGH_PERF` enables ORT's memory-pattern planner and
+CPU arena, which on a *training* session pre-allocates the whole backward activation plan and holds
+its peak for the life of the run. Measured on a 5.5 GB phone, FunctionGemma-270M (~1.07 GB of fp32
+weights, a 368,640-parameter LoRA) reached **2.35 GB RSS + 1.02 GB swap** under `HIGH_PERF` and was
+killed by the system; under `LOW_MEM` the same run completes.
+
+There is no exception to catch when that happens: Android sends **SIGKILL**, so the process vanishes
+with no error, no `finally` and no checkpoint. If you override this, do it knowing that is the failure
+mode:
+
+```kotlin
+// Only if you have measured that it fits.
+TrainConfig(device = DeviceConfig(memoryConfigId = MemoryConfigId.HIGH_PERF))
+```
+
+Inference keeps `HIGH_PERF`: a forward-only session benefits from the arena and builds no backward
+plan. If you fan one `DeviceConfig` across every config in your app, exclude the training memory
+profile — the sample app's `AppConfig.updateDevice` shows the shape.
+
+### Train while charging
+
+```kotlin
+TrainingScheduler.schedule(
+    context = context,
+    repoId = model.repoId,
+    dataset = DatasetConfig(trainFile = "my_data", task = "cola"),
+    training = TrainConfig(maxSteps = 500),
+    config = TrainingScheduleConfig(
+        // "Not before", NOT an appointment — see below.
+        initialDelayMinutes = 240,
+    ),
+)
+```
+
+Each chunk re-enters the WorkManager queue, so unplugging pauses the run rather than failing it.
+
+**On start times.** `initialDelayMinutes` maps to WorkManager's `setInitialDelay`, which is the only
+start-time control Android gives deferrable work, and it is a **floor**: the system batches, and Doze
+can hold a job well past it. An exact wall-clock start would need
+`AlarmManager.setExactAndAllowWhileIdle` and the `SCHEDULE_EXACT_ALARM` permission, which Play
+restricts to alarm clocks and calendar reminders — a background trainer is neither. The constraints
+(`requiresCharging`, `requiresBatteryNotLow`) are the real gate; the delay only moves the earliest
+moment they are consulted. It applies to the first chunk only, so a multi-chunk run is not re-delayed
+at every boundary.
+
+---
+
+## 5. Ground answers in your own documents
+
+*Sample app: Chat screen, RAG toggle.*
+
+```kotlin
+model.ingest(path = "/sdcard/Download/notes.md", config = RagConfig())
+
+val grounded = model.generateWithRag(
+    query = "what did I write about batching?",
+    rag = RagConfig(topK = 5, minScore = 0.2),
+    generation = GenerationConfig(maxNewTokens = 200),
+    promptStrategy = PromptAssembler.DEFAULT,
+    // Optional, and worth passing in any UI: a grounded turn does an embedding pass, a vector search
+    // and then a long decode, so without this the screen shows nothing until all three are done.
+    callback = object : GenerateCallback {
+        override fun onPartialResult(progress: GenerateProgress) = append(progress.token)
+    },
+)
+
+Log.i("rag", grounded.text)
+// `title` is the ingested file the passage came from; several matches can share one.
+grounded.matches.forEach { Log.i("rag", "${it.score} ${it.title} ${it.text}") }
+Log.i("rag", "asked: ${grounded.prompt}")   // the assembled prompt, for when the answer is wrong
+```
+
+Leave the embedding identity unset unless you mean to override the package: it is read from
+`embedding/rag_config.json`, written by the exporter from the encoder it actually shipped.
+
+---
+
+## 6. Tool calls: instruction → validated call → dry-run intent
+
+*Sample app: Tool calls screen.*
+
+Your app declares the actions. **A model selects an action; it cannot name an intent** — the intent
+string comes from your `ActionSpec` — so the reachable set of intents is fixed when you write this list.
+
+```kotlin
+val validator = FunctionCallValidator(
+    listOf(
+        ActionSpec(
+            actionName = "set_alarm",
+            parameters = mapOf("time" to "string"),
+            allowedIntent = "android.intent.action.SET_ALARM",
+            validationRules = mapOf("time" to "HH:mm"),
+        ),
+    ),
+)
+
+when (val result = model.generateToolCall("wake me at 07:30", validator)) {
+    is ToolCallResult.Accepted -> {
+        val intended = result.dryRun()
+        Log.i("tool", "${intended.intent.action} willExecute=${intended.willExecute}")  // false
+    }
+    is ToolCallResult.Rejected -> Log.i("tool", "refused: ${result.reason}")
+    is ToolCallResult.NoCall -> Log.i("tool", "answered in prose: ${result.raw}")
+}
+```
+
+**Three outcomes, and the third is not a refusal.** `NoCall` means the model answered in words rather
+than attempting a call — nothing was permitted or denied. Reporting that as `Rejected` (which this API
+used to do, with `reason = "no tool call found in the model's output"`) tells a user their allowlist
+blocked something when it did not, and it hides format mismatches: a parser reading the wrong dialect
+produces `NoCall` for *every* well-formed call.
+
+That distinction is what makes this usable as your only chat path: declare the tools on every turn and
+let the outcome decide how the turn renders, instead of asking the user to predict, before sending,
+whether their message is a tool call.
+
+`Rejected` is a value, not an exception: refusing untrusted output is the expected path. Nothing here
+executes — `IntentBinder` holds no `Context` and has no `startActivity` call site, so firing the intent
+is your deliberate act with your own `Context`.
+
+### Dialects: check what the model speaks
+
+**Not every model emits JSON.** FunctionGemma emits
+`<start_function_call>call:name{key:<escape>value<escape>}<end_function_call>`, and handing that to a
+JSON reader yields `NoCall` for calls that are perfectly well formed. The dialect is detected from the
+package's own chat template:
+
+```kotlin
+if (model.capabilities.supportsToolCalling) {
+    Log.i("tool", "grammar: ${model.capabilities.toolCalling.dialect}")  // FUNCTION_GEMMA | JSON
+}
+```
+
+`generateToolCall` defaults its parser from that, and `ToolPromptBuilder` renders the declarations —
+and the turn structure — in the matching grammar. Pass `parser =` only if you know better than the
+package does.
+
+`supportsToolCalling` being false does not forbid tool calls: a model fine-tuned on this repo's
+`mobile_actions` corpus learns the JSON shape without its template ever mentioning tools. It means
+only that the model has no grammar of its own, so an app should not advertise the capability.
+
+Build the training set from the same declaration so the corpus and the boundary are provably one value:
+
+```bash
+mobiletransformers agent-dataset --source generated \
+  --allowlist build/agent/action_schema.json --output build/user
+```
+
+> **Status, 2026-08-15.** The on-device gate for this recipe (`ToolCallDeviceTest`) **passes** — 2
+> tests / 0 failures / 754 s on an S21 FE, `steps=108 lossDrop=99.5%`. The repeated-newline failure
+> this note used to describe was the merge-transpose defect, fixed 2026-08-14: the model had learned
+> the task all along and the merge was corrupting the result on the way out. FunctionGemma has since
+> been observed emitting a well-formed call in its own grammar on the same device.
+
+---
+
+## 7. One federated round
+
+*Sample app: Federated screen.*
+
+Federation is **off by default** (`BuildConfig.FEDERATION_ENABLED`). The round returns bytes and accepts
+bytes; the transport is yours, which is what lets the whole loop run against a local `federated serve`.
+
+```kotlin
+val result = model.federatedRound(
+    config = FederatedConfig(
+        gatewayUrl = "https://gateway.example",
+        clientAuthToken = token,
+        consent = FederatedConsent(
+            granted = true,
+            policyVersion = "1.0",
+            grantedAtEpochMs = System.currentTimeMillis(),
+        ),
+    ),
+    globalRecord = previousAggregate,   // null for round 0
+    roundNumber = 1,
+    localTraining = { round -> model.train(dataset, TrainConfig(maxSteps = 20)) },
+)
+
+upload(result.update)                    // result.payloadBytes is what federation costs per round
+```
+
+Consent, TLS and auth are checked before any tensor is read, and the refusal names the missing
+protection. Only adapter factors and aggregate metrics ever leave the device — never your examples.
+
+---
+
+## 8. Close it
+
+```kotlin
+model.close()
+```
+
+A model owns native sessions. Load once and share the handle; loading the same package twice opens two
+sessions over one set of weights.
diff --git a/docs/EXPORT.md b/docs/EXPORT.md
new file mode 100644
index 0000000..e21b0ca
--- /dev/null
+++ b/docs/EXPORT.md
@@ -0,0 +1,186 @@
+# Export
+
+One command turns a Hugging Face model into a device-ready MobileTransformers package. This page is
+sourced from the export CLI and the dependency profiles declared in `pyproject.toml`.
+
+## One-command export
+
+```bash
+mobiletransformers export --model <hf-repo-id> --output build/package
+```
+
+Common flags (see `mobiletransformers export --help`):
+
+| Flag | Default | Meaning |
+| --- | --- | --- |
+| `--model` | *(required)* | HF repo id to export. |
+| `--output` | *(required)* | Output package directory. |
+| `--task` | auto | Optimum task; auto-selected from the model when omitted. |
+| `--peft` | `lora` | `lora` \| `lora-xs` \| `mars` \| `mars-opt0..mars-opt4`. |
+| `--rank` | `8` | LoRA/MARS rank. |
+| `--peft-target` | *(registry)* | Comma-separated modules PEFT adapts, e.g. `q_proj,v_proj`. Omit to use the architecture registry's row for the model — see below. |
+| `--quant` | `int4` | `qint8` \| `int4` \| `fp16`. |
+| `--variant` | `cpu-<quant>` | Variant id in the package manifest. |
+| `--include-rag` | off | Also emit the embedding/RAG variant subtree. |
+| `--embedding-model` | — | Embedding model id (with `--include-rag`). |
+| `--genai` | off | Declare GenAI engine support for the variant (Native is always supported). |
+| `--stages` | auto | Comma-separated `inference,training,embedding`; default is auto by profile. |
+| `--config` | — | YAML supplying defaults for any flag not passed (CLI > YAML > default). |
+| `--validate` | off | Validate the written package against the manifest contract before returning. |
+| `--dry-run` | off | Resolve + print the plan and a manifest skeleton; write nothing. |
+
+### `--config`
+
+Any knob above except `--validate`/`--dry-run` may come from YAML instead of the command line —
+including `--model` and `--output`. Explicit flags always win; unknown keys are rejected rather than
+ignored.
+
+```yaml
+# export.yml — either an `export:` block or a flat mapping
+export:
+  model: HuggingFaceTB/SmolLM2-135M-Instruct
+  output: build/pkg
+  peft: mars
+  rank: 16
+  quant: int4
+  genai: true
+```
+
+```bash
+mobiletransformers export --config export.yml            # everything from YAML
+mobiletransformers export --config export.yml --rank 32  # ...with rank overridden
+```
+
+### Which modules PEFT adapts (`--peft-target`)
+
+By default this is **per model, from the architecture registry**
+(`src/mobiletransformers/config/registry/architecture.py`) — one `target_modules` row per
+architecture. That is the place to edit to support a new model or change a family's defaults, and it
+applies everywhere without a caller having to remember a flag:
+
+```python
+"LlamaForCausalLM": ArchitectureSpec("LlamaForCausalLM", ..., ("q_proj", "v_proj")),
+"DistilBertForSequenceClassification": ArchitectureSpec(..., ("q_lin", "v_lin")),
+```
+
+Override per run when you want something else:
+
+```bash
+mobiletransformers export --model <id> --output build/pkg --peft-target q_proj,k_proj,v_proj,o_proj
+```
+
+or in YAML as `peft_target: q_proj,v_proj`.
+
+> **Changed 2026-08-09.** The default used to be a hardcoded `q_proj,k_proj` that ignored the registry
+> and could not express an encoder's `query`/`value` at all. Decoder exports now adapt **Wq and Wv**
+> (the LoRA convention) rather than Wq/Wk. Pass `--peft-target q_proj,k_proj` to reproduce the old
+> behaviour.
+
+### `--validate`
+
+Re-reads the package just written and runs the full manifest validation over it (every declared file
+resolves, the variant subtrees exist, the weight-handoff reference is present). A package that does not
+validate fails the command, rather than being discovered later on a device. The same check is available
+standalone:
+
+```bash
+mobiletransformers validate --package build/pkg
+```
+
+`--dry-run` needs no heavy dependencies — it resolves the export plan and prints the
+`mobiletransformers_manifest.json` skeleton, so you can inspect variant selection and the download plan
+before committing to a full export.
+
+## What the package contains
+
+The output is a single Hub-shaped package (one tree, variants declare their engines), verified against
+the manifest/cache contract and the Hub package format:
+
+- `mobiletransformers_manifest.json` — schema-versioned manifest (`sha256` + `fileSizes` +
+  `downloadPlan`, per-variant `checksums.json`).
+- A flat `inference/` layout: `model.onnx` + `frozen_base.onnx.data` (immutable quantized base) +
+  per-tensor `<name>.bin` (+ `.sha256`) trainable external initializers, beside
+  `generation_config.json` / `genai_config.json` / `weight_handoff_map.json`.
+- `weight_handoff_map.json` — the single source of tensor identity for on-device merge
+  (`src/mobiletransformers/artifacts/handoff_map.py`).
+
+## Profiles (dependency isolation)
+
+The `onnxruntime`-bearing profiles collide on the `onnxruntime` import and must **never** co-install;
+each `make setup*` target syncs its own environment:
+
+| Target | Profile | Notes |
+| --- | --- | --- |
+| `make setup` | core + `dev` | No onnxruntime provider. Python 3.10-clean. |
+| `make setup-export` | `export` extra | `optimum-onnx[onnxruntime]`; needs Python ≥ 3.11. |
+| `make setup-train` | `ort-training-local` group | Source-built ORT-training wheel; **cp312 + Linux only**. |
+| `make setup-genai` | `genai-smoke` group | `onnxruntime-genai`; needs Python ≥ 3.11. |
+
+## Real vs. dry-run export
+
+- **Dry-run** (`--dry-run`) runs anywhere the core package installs — no model download, no heavy deps.
+- **Real full export** exercises the optimum inference-graph export (`export` profile) and, for training
+  artifacts, the source-built ORT-training toolchain (`ort-training-local`, cp312/Linux). It is
+  **environment-gated**: `mobiletransformers export` (without `--dry-run`) raises a clear message until
+  run under those profiles.
+
+## Per-task flag rules
+
+Two flags are decided by the task, not by preference, and getting either wrong fails late — or, worse,
+silently produces a package that is missing half of what you wanted.
+
+**`--task text-classification` is what makes an encoder trainable at all.** `TaskSpec.default_stages`
+emits a training stage exactly when the task is `trainable`, and `FEATURE_EXTRACTION` is declared
+`trainable=False`. So exporting an encoder the "natural" way yields an **inference-only** package, with
+no error — it did exactly what you asked. Task auto-selection never picks `text-classification`; it has
+to be named.
+
+The consequence for a sentence encoder is that its classification head is randomly initialised, with
+`LABEL_0`/`LABEL_1` labels, because no such head exists in the checkpoint. That is correct: the head is
+the part fine-tuning learns, and the pretrained *backbone* is what must survive — which is what the
+export-time parameter budget checks.
+
+**`--genai` is decoder-only.** A classification or feature-extraction graph has no KV cache, and the
+export refuses to write a `genai_config.json` describing a cache the graph does not have. This is a
+fail-closed refusal rather than a silent omission, because a `genai_config.json` advertising
+`past_key_values.N` inputs the graph lacks produces a device-side failure far from the export.
+
+## Publish
+
+```bash
+mobiletransformers push --package build/package --repo <org/name>
+```
+
+The push wraps `huggingface_hub.upload_folder`, validates the package + renders a model card before
+uploading (`--dry-run` validates + renders the card without uploading). See also
+`mobiletransformers pull --repo-id <org/name>` and `install-package` for the consumer side.
+
+### Publishing the whole shelf
+
+```bash
+make publish-catalog                              # export + gate-check + push every entry
+ONLY=smollm2 PUSH=0 scripts/publish_catalog.sh    # one entry, no upload
+KEEP=1 scripts/publish_catalog.sh                 # skip re-export where a package already exists
+```
+
+`scripts/publish_catalog.sh` holds the per-model task and engine flags above as data, so they cannot be
+mistyped per run. It also does two things worth knowing about:
+
+**It gate-checks that every entry ships a `train` group** and refuses otherwise. A shelf entry that
+cannot be fine-tuned demonstrates half the framework, so this is asserted rather than assumed.
+
+**It performs the two-profile dance.** The inference export needs the `export` extra; the training
+stage needs the source-built `ort-training-local` wheel; the two collide on the `onnxruntime` import
+and must never co-install. `uv run --group ort-training-local` alone does **not** displace the stock
+onnxruntime the export profile just installed — the training wheel provides a distribution of the same
+name, so the resolver considers the requirement satisfied and the training import then dies with
+`ImportError: cannot import name 'PropagateCastOpsStrategy'`. An explicit `uv sync
+--reinstall-package` followed by `uv run --no-sync` is what actually works.
+
+It needs `HF_TOKEN_ORG` in `.env` — a token with `repo.write` on the target org. A fine-grained
+personal token scoped to one repo returns `RepositoryNotFoundError` for every other repo, and the Hub
+returns that identically for "does not exist" and "you cannot see it", so a permissions problem reads
+as a typo. See [`.env.example`](https://github.com/martinkorelic/mobiletransformers/blob/main/.env.example) and [CATALOG.md](CATALOG.md).
+
+> The script leaves the tree on the training profile. Reset with
+> `uv sync --frozen --group dev --python 3.10` before running `make check`.
diff --git a/docs/FEDERATED.md b/docs/FEDERATED.md
new file mode 100644
index 0000000..fb4ce86
--- /dev/null
+++ b/docs/FEDERATED.md
@@ -0,0 +1,74 @@
+# Federated adapters
+
+Federated fine-tuning exchanges **adapter tensors only** — never base weights — between clients and a
+server that averages them. Status: the record codec and aggregation are implemented and tested; the
+Flower simulation is a manual leg, and the Android gateway is not started.
+
+## Why Flower is not a dependency
+
+`flwr[simulation]` pulls Ray, pyarrow and a protobuf line that conflicts with this repo's: adding it
+downgraded protobuf 7→6 and rich/typer repo-wide, and bumped mypy 1.11→1.19 (which broke the type gate).
+So it stays **out of `uv.lock`**, exactly like the source-built ORT-training wheel:
+
+```bash
+pip install "flwr[simulation]"     # out-of-band, into the environment you run the sim from
+```
+
+Everything except the simulation driver works without it — deliberately, so the parts that matter are
+CI-covered rather than gated behind an optional install.
+
+## The record
+
+One round's contribution is a `FederatedAdapterRecord`: a header plus tightly-packed tensor payloads.
+
+```
+uint32 LE header length | JSON header | payload (tensors in codec order)
+```
+
+The tensor order is **not invented here** — it comes from `TrainableTensorCodec` /
+`weight_handoff_map.json` ([MODEL_FORMAT.md](MODEL_FORMAT.md)), so a record and the package it was
+trained against agree by construction. The byte layout is pinned by a committed golden
+(`tests/federated/fixtures/federated_record.golden.bin`); regenerate with
+`python -m tests.federated.gen_serialization_golden`.
+
+`deserialize` is fail-closed on untrusted input: the schema is version-gated (`check_compat`) *before*
+any offset is used, and every tensor's `byteOffset`/`byteLength` is bounds-checked and cross-checked
+against its declared dtype × shape.
+
+## Aggregation
+
+`federated_average` is a weighted mean by `numExamples`, in codec order. Dropped clients (`None`
+entries) are skipped and the round still completes over the survivors; it fails closed when no client
+survived, when survivors disagree on tensor count, or when total weight is zero.
+
+`aggregate_round` is the whole server side of a round minus the messaging: aggregate → wrap in a record
+→ write `global_adapter_round<N>.mtfed`. It is pure, so round semantics are unit-tested without Flower.
+
+## Running a simulation
+
+```bash
+mobiletransformers federated simulate \
+  --package <installed-package-dir> \
+  --output  build/federated \
+  --clients 4 --rounds 3 --local-max-steps 2
+```
+
+Requires `flwr` (above) **and** the ORT-training runtime for real client fitting. Each round writes one
+`global_adapter_round<N>.mtfed` into `--output`; the command fails if a run produces none.
+
+Only `fedavg` is supported in v1 — another strategy is rejected rather than silently falling back.
+
+## Open items
+
+- The real N-client simulation with ORT `fit` and an aggregated-adapter logits-differ smoke is a
+  **manual** leg (no device needed, but it needs the out-of-band `flwr` + the training profile).
+- The **role vocabulary** is **decided (2026-08-08): the codec's `{weight, weight_quantized, scale,
+  zero_point}` is normative**, and the tier doc was amended to match the code rather than the reverse.
+  The `{adapter, trainable_weight, head}` set was never implemented by anything. Consequence:
+  `federated_record.golden.bin` is **unchanged**, and the device round mirrors one vocabulary instead
+  of translating between two. It is therefore **no longer gated** on this.
+- Still open, and a design constraint rather than a nit: v1 exchanges **merged-weight-shaped** tensors
+  (`aggregation_role="merged_base_plus_adapter"`), so per-round traffic is the size of the adapted
+  weights, not of the rank-r adapters — and that reads against the tier doc's "do not aggregate merged
+  base weights". Whether v2 switches to adapter-delta exchange is an open decision.
+- `aggregation` has exactly one v1 value, `weighted_average`; unknown values are now rejected on read.
diff --git a/docs/HUB_PACKAGE_FORMAT.md b/docs/HUB_PACKAGE_FORMAT.md
new file mode 100644
index 0000000..67b7f45
--- /dev/null
+++ b/docs/HUB_PACKAGE_FORMAT.md
@@ -0,0 +1,103 @@
+# Hub package format
+
+How a MobileTransformers package is laid out **on the Hugging Face Hub**, and how a client turns a repo
+id into an installed model. The manifest and weight-handoff *schemas* are specified in
+[MODEL_FORMAT.md](MODEL_FORMAT.md); this page covers the repository shape, the download plan and the
+verify/install flow. Owner: `src/mobiletransformers/hub/package_format.py`.
+
+## Repository layout
+
+A package repo is the on-disk package published verbatim — no repacking, no archives:
+
+```
+<hub-repo>/
+├── mobiletransformers_manifest.json     # entry point: fetched FIRST, before any large file
+├── README.md                            # model card
+├── shared/
+│   ├── tokenizer/                       # tokenizer.json, tokenizer_config.json, …
+│   └── chat_template.jinja              # optional; present when the model declares one
+└── variants/
+    └── <variant-id>/                    # e.g. cpu-int4
+        ├── checksums.json               # per-file sha256 for this variant
+        ├── inference/
+        ├── train/                       # optional (training feature)
+        └── embedding/                   # optional (rag feature)
+```
+
+Everything shared across variants lives under `shared/` and is downloaded once. A variant id is
+`<execution-provider>-<quantization>`, e.g. `cpu-int4`.
+
+## Manifest-first, always
+
+The manifest is small and names the checksums of everything else, so it is fetched before any large
+file. That ordering is the reason a client can verify what it downloads:
+
+1. `GET mobiletransformers_manifest.json` → parse + version-gate (`check_compat`).
+2. **Select a variant** against device capability — ABI, available memory, requested features,
+   requested engine. `manifest.defaultVariant` is a fallback, not the answer: selecting it blindly
+   would happily download an ABI-incompatible variant that fails at load.
+3. **Plan the file list** from the selected variant + requested features (a `train/` subtree is not
+   downloaded for an inference-only install; `genai_config.json` only when GenAI was requested).
+4. **Download + verify** each file against `manifest.sha256`. A mismatch aborts the install.
+5. **Install** into the device cache — see [ANDROID_CACHE_FORMAT.md](ANDROID_CACHE_FORMAT.md).
+
+Both clients implement this identically: `hub/pull.py` (Python) and `hub/HubDownloader.kt` +
+`packages/VariantSelector.kt` (Kotlin), with `DownloadPlanner` resolving globs to a concrete file list.
+
+## `sanitize_repo_id`
+
+A Hub repo id contains `/`, which cannot be a directory name. `sanitize_repo_id()` maps it to the cache
+directory name:
+
+| Repo id | Sanitized |
+| --- | --- |
+| `org/Tiny-Model` | `org__Tiny-Model` |
+
+The mapping is pinned by a shared fixture (`tests/fixtures/sanitize_repo_id_cases.json`) that the Python
+and Kotlin implementations are both tested against, so the two can never disagree about where a model
+lives.
+
+## Checksums
+
+Two layers, deliberately:
+
+- `manifest.sha256` — every file in the package, used to verify a **download**.
+- `variants/<id>/checksums.json` — the same digests scoped to one variant, installed alongside the model
+  so integrity can be re-checked later without the full manifest.
+
+Merged weights add a third, device-side layer (`<name>.bin.sha256` sidecars) with its own precedence
+rule — see [MODEL_FORMAT.md](MODEL_FORMAT.md#checksum-precedence-the-sidecar-wins).
+
+## Publishing
+
+```bash
+mobiletransformers export --model <hf-id> --output build/pkg --genai --validate
+mobiletransformers push  --package build/pkg --repo <org>/<name> --token "$HF_TOKEN_ORG"
+```
+
+`push` validates the package against the manifest contract before uploading, so a broken package fails
+locally rather than becoming a broken repo. See [EXPORT.md](EXPORT.md).
+
+- **The repo must already exist.** Pass `--create` to create it. That is off by default so a mistyped
+  repo id fails instead of silently making a new one — under an organisation account, a typo would
+  otherwise leave a stray repo behind.
+- **`--token` is explicit for a reason.** Without it `huggingface_hub` falls back to `$HF_TOKEN` and
+  then to the cached CLI login, so an organisation push can succeed as the *wrong identity* and look
+  exactly like success. `--dry-run` renders the model card and writes `README.md` without uploading.
+- The card carries a **YAML frontmatter block** (`base_model`, `library_name`, `pipeline_tag`, `tags`,
+  and `license` when the package records the base weights' licence). Without it the Hub page shows no
+  licence and no link back to the model the package was exported from — the prose body says both, and
+  the Hub does not read prose.
+
+## Pulling
+
+Pass `--token` for a private or gated repo (defaults to `$HF_TOKEN`, and honours `.env`).
+
+```bash
+mobiletransformers pull --repo-id <org>/<name> --output <cache-root>
+mobiletransformers install-package --package <staged> --cache <cache-root>
+```
+
+On Android the same flow runs inside `MobileTransformers.fromPretrained`, which pulls and installs when
+the package is not already in the cache. Background downloads use
+`PackageDownloadWorker.enqueue(...)` (WorkManager; unmetered + storage-not-low, one unique job per repo).
diff --git a/docs/MODEL_FORMAT.md b/docs/MODEL_FORMAT.md
new file mode 100644
index 0000000..bf708a1
--- /dev/null
+++ b/docs/MODEL_FORMAT.md
@@ -0,0 +1,232 @@
+# Model Format
+
+A MobileTransformers package is a self-describing directory: a top-level manifest plus one subtree per
+**variant** (ABI × quantization × feature set). One package feeds **both** inference engines (the native
+ORT runtime and the ONNX Runtime GenAI engine) — the engine is a selection over the same files, never a
+separate download. This page is sourced from the manifest owner
+(`src/mobiletransformers/hub/package_format.py` + `artifacts/manifest.py`) and the weight-handoff
+owner (`src/mobiletransformers/artifacts/handoff_map.py`).
+
+Two JSON contracts govern the on-disk shape: **`mobiletransformers_manifest.json`** (what the package
+contains and how to select/download it) and **`weight_handoff_map.json`** (the single source of tensor
+identity across train → merge → inference). Both are versioned and read fail-closed.
+
+## Versioning contract (both files)
+
+Every cross-boundary JSON carries a `schemaVersion` and `minReaderVersion` (`"MAJOR.MINOR"`) and is gated
+by one shared `check_compat()` helper (`artifacts/versioning.py`):
+
+- A reader **tolerates** unknown fields and minor bumps (additive changes are non-breaking).
+- A reader **rejects** (raising `SchemaVersionError`) when the file's `major` exceeds the reader's support,
+  or when the file's `minReaderVersion` is newer than the reader.
+
+Current reader versions: manifest `MANIFEST_READER_VERSION = "1.0"`; handoff map
+`HANDOFF_MAP_READER_VERSION = "1.0"`; package format `SCHEMA_VERSION = "1.0"` /
+`ARTIFACT_FORMAT_VERSION = 1`. Devices enforce the contract via typed fail-closed parsing (they do **not**
+run runtime JSON-schema validation); the `schemas/*.schema.json` files are CI parity artifacts.
+
+## Package layout
+
+```
+<package>/
+├── mobiletransformers_manifest.json      # the manifest (below)
+├── tokenizer files (shared)
+└── variants/
+    └── <variant-id>/                      # e.g. cpu-int4
+        ├── train/                         # training artifacts (training/eval/optimizer models, checkpoint)
+        │   └── weight_handoff_map.json
+        ├── inference/
+        │   ├── model.onnx                 # inference graph (external initializers)
+        │   ├── frozen_base.onnx.data      # frozen base weights blob
+        │   ├── <tensor-name>.bin          # one flat file per trainable/merged tensor
+        │   ├── <tensor-name>.bin.sha256   # integrity sidecar per tensor
+        │   └── weight_handoff_map.json
+        └── embedding/                     # optional RAG embedding subtree
+```
+
+On device the installed cache mirrors this per repo: `<cacheDir>/<sanitizedRepoId>/{train,inference,embedding}/…`.
+`sanitize_repo_id()` maps a Hub repo id to that directory name; the installer writes into exactly this shape
+so the runtime repositories discover models unchanged.
+
+## `mobiletransformers_manifest.json`
+
+Built deterministically by `build_manifest()` from the on-disk tree. Top-level fields:
+
+| Field | Meaning |
+| --- | --- |
+| `schemaVersion` / `minReaderVersion` | version gate (above). |
+| `baseModelId` | source HF repo id. |
+| `exportedAt` / `mobiletransformersVersion` / `artifactFormatVersion` | provenance. |
+| `architectures` / `supportedTasks` / `selectedTask` / `trustRemoteCode` | model provenance from export. |
+| `optimumOnnxVersion` / `transformersVersion` / `onnxRuntimeTrainingVersion` / `onnxRuntimeGenAIVersion` | toolchain pins. |
+| `peftMethods` / `quantization` | realized capabilities of this package. |
+| `defaultVariant` | variant id chosen when the caller requests none. |
+| `variants[]` | per-variant descriptors (below). |
+| `downloadPlan` | per-variant, per-feature repo-relative glob patterns — lets a client size + fetch selectively before touching large ONNX blobs. |
+| `requiredFiles` | files that must exist for the package to be usable (includes the default variant's `inference/model.onnx`). |
+| `fileSizes` / `sha256` | stream-hashed integrity for every file. |
+| `weightHandoff` | path to the default variant's `weight_handoff_map.json`. |
+| `androidRuntime` | `{ minimumAndroidApi, recommendedDeviceMemoryMb, requiredAbis }`. |
+| `license` | `{ framework, baseModelWeights, noticeFile }`. |
+
+Each `variants[]` entry:
+
+| Field | Meaning |
+| --- | --- |
+| `id` | variant id (e.g. `cpu-int4`) — `cpu-<quantization>`. **Names the training-side quantization; see the note below.** |
+| `executionProvider` | `cpu` \| `xnnpack` \| `nnapi`. |
+| `quantization` | `QInt8` \| `QUInt8` \| `int4`. The **requested** setting. |
+| `supportedEngines` | subset of `["native", "genai"]`. |
+| `abi` | target Android ABI. |
+| `features` | feature groups present (`inference`, `training`, `rag`, `embedding`, …). |
+| `minimumAndroidApi` / `recommendedDeviceMemoryMb` | device requirements. |
+| `weightHandoff` | this variant's handoff-map path. |
+| `paths` | per-feature subtree paths. |
+
+### The variant id names the TRAINING quantization, not the inference graph's
+
+A variant id is `cpu-<quantization>`, and `--quant` drives the **training** stage: the training graph is
+weight-quantized (`quant_model.onnx`, dynamic per-channel) before `generate_artifacts` runs. The
+**inference** export does not quantize — it ships whatever precision optimum exported, in practice fp32.
+
+So a variant named `cpu-int4` legitimately contains a **uint8-quantized training graph beside an fp32
+inference graph**. That is the design, not a packaging bug, but nothing declared it and the directory
+name was the only (misleading) signal. Two things now make it explicit:
+
+- `inference/optimum_config.json` carries **`inferenceGraphPrecision`**, *measured from the graph that
+  shipped* (`artifacts/parameter_budget.py::describe_graph_precision`) — never inferred from the id.
+- The export gates the gap numerically: `verify_train_inference_parity` runs identical tokens through
+  both graphs and fails the export if the cross-entropy differs by more than 1.5 nats. Weight-only
+  uint8 quantization moves it ~0.4 nats; a graph that lost its weights moves it to the uniform floor.
+
+**Do not read precision off the variant id.** Read `inferenceGraphPrecision` for the inference half and
+`quantization` for the training half.
+
+### Validation and variant selection
+
+- `MobileTransformersManifest.validate(package_dir)` version-gates the manifest, then asserts the selected
+  variant's declared files (the `inference/` group and `weight_handoff_map.json`) exist on disk — fail-closed,
+  naming the missing file, **before** any load.
+- `select_variant(execution_provider, quantization, total_mem_mb, requested_engine)` hard-filters variants by
+  requested ABI/EP/engine/memory and returns a `SelectedVariant`. (The soft preference layer — quant
+  preference, download-size tie-break, storage-budget ceiling — lives in `hub/variant_select.py`.)
+
+## `weight_handoff_map.json`
+
+The single source of tensor identity. It replaces the implicit name-agreement between the merge writer,
+the native load side, and the inference graph with one declarative artifact. Owned by
+`artifacts/handoff_map.py`; every consumer — the merger, the manifest, the native load path and the federated exporter — reads
+this shape and none may redefine it.
+
+Document-level fields:
+
+| Field | Value |
+| --- | --- |
+| `schemaVersion` / `minReaderVersion` | `"1.0"` (version gate above). |
+| `handoffMode` | `external_initializer` — the **only** supported mode in v1 (`model_input` / `adapter` are fail-closed stubs). |
+| `engines` | `["native", "genai"]` — the engines this layout serves. |
+| `externalDataLayout` | `one_file_per_tensor`. |
+| `frozenBaseBlob` | `frozen_base.onnx.data`. |
+| `mergerModels` | resolved `MergerVariant` → merger ONNX filename. |
+| `entries[]` | one entry per trainable MatMul (below). |
+
+Each `entries[]` element is one trainable layer's full identity:
+
+| Field | Meaning |
+| --- | --- |
+| `trainingBaseLayerName` | the training-side base layer (e.g. `backbone.…q_proj.base_layer`). |
+| `dtype` / `shape` | the **weight-like** role's dtype (`float16`/`float32`/`int8`/`uint8`/`int4`) and shape. |
+| `tensorDtypes` / `tensorShapes` | role → that role's **own** on-disk dtype/shape — see "Per-role dtype and shape". |
+| `checkpointNames` | role → ORT-checkpoint tensor name (the frozen `weight` + the adapter A/B factors). |
+| `mergerOutputNames` | role → the merger graph's output name. |
+| `mergedTensorNames` | role → the name the on-device merger stamps. |
+| `inferenceInitializerNames` | role → the initializer name in `inference/model.onnx`. |
+| `externalDataLocation` | role → the flat per-tensor `.bin` filename in `inference/`. |
+| `sha256` | role → integrity hash of the **shipped** (pre-merge) bytes — see "Checksum precedence". |
+| `genaiInputNames` | role → GenAI input name (when GenAI consumes the tensor as an input). |
+| `quantization` | optional `{ weightQuantizedName, scaleName, zeroPointName }`. |
+| `transposePolicy` | `no_transpose` \| `already_transposed_for_inference` — how the on-disk weight is oriented relative to the training checkpoint. See "Weight orientation" below; **do not honour it without reading that section.** |
+
+Roles are drawn from the fixed order `("weight", "weight_quantized", "scale", "zero_point")`.
+
+### Invariants (enforced by `HandoffMap.validate()`, fail-closed)
+
+- **Merged name equals inference name** for every role: `mergedTensorNames[role] == inferenceInitializerNames[role]`
+  (the external-initializer contract — the writer stamps exactly the name the inference graph reads).
+- **Quantized names come from the observed inference initializers**, never derived from `trainingBaseLayerName`
+  (`quantization.weightQuantizedName/scaleName/zeroPointName` must equal the observed initializer names).
+- **No two entries** may claim the same `externalDataLocation` file or the same inference initializer name.
+- Serialization is byte-deterministic (`to_json()` sorts keys and sorts entries by canonical weight name), so
+  the manifest's `sha256` over this file is stable.
+
+### Per-role dtype and shape
+
+Each `<name>.bin` is an **ONNX external-data blob: raw tensor bytes with no header**. Nothing in the
+file describes its element type or dimensions, so the map is the device loader's only source — and it
+must describe every role separately, because a quantized entry's roles do not share a layout:
+
+| Role | Typical dtype | Shape |
+| --- | --- | --- |
+| `weight` | `float16` | the logical `[out, in]` |
+| `weight_quantized` | `uint8` (int4 packed two-per-byte) | packed, narrower than the logical shape |
+| `scale` | `float16` | one per quantization group |
+| `zero_point` | `uint8` | one per quantization group |
+
+`tensorDtypes[role]` / `tensorShapes[role]` carry each role's own pair, taken from the initializers as
+actually observed at export (`_classify_initializers`). The entry-level `dtype`/`shape` describe the
+weight-like role only and remain as the fallback for maps written before these fields existed — sound
+for a single non-quantized role, which is why `validate()` rejects a quantized entry that omits them.
+
+The device loader (`session_cache.h::load_tensor_raw`) **constructs** the tensor from this declaration
+rather than checking a parsed header against it, and fails closed when the file size is not exactly
+`numel × element_size`.
+
+### Weight orientation
+
+Two conventions meet at the merge, and they disagree:
+
+| side | convention |
+| --- | --- |
+| training checkpoint (`base_layer.weight`, a PyTorch `nn.Linear`) | `[out_features, in_features]` |
+| inference initializer (an ONNX `MatMul` right-hand side) | `[in_features, out_features]` |
+
+`transposePolicy` records which one the on-disk `.bin` uses, relative to the checkpoint. It is
+**observed, not declared**: the merger computes `base + scale · (adapter_B @ adapter_A)`, whose shape
+is `(adapter_B.rows, adapter_A.cols)`. If that equals the weight's on-disk shape the two agree
+(`no_transpose`); if it equals the reverse, the on-disk tensor is the transpose
+(`already_transposed_for_inference`); anything else describes a delta that cannot be added to its own
+weight and is refused at export.
+
+**A square weight cannot decide its own orientation** — `[576,576]` satisfies both readings — so the
+policy is resolved **package-wide** from the entries that are not square. One export uses one
+convention throughout, and mixed conventions fail closed.
+
+> ⚠️ **Consumers: derive the orientation, do not trust this field yet.** Every package exported before
+> 2026-08-14 declares `no_transpose` unconditionally, because the producing side never assigned it —
+> and that is wrong for all of them. The on-device merger deliberately observes orientation from the
+> tensors themselves rather than reading this field, so that packages already in the wild keep working.
+> The field became meaningful for packages exported after that date. A declaration is only safe to
+> honour once no artifact in circulation carries a wrong value for it.
+
+### Checksum precedence: the sidecar wins
+
+Each `<name>.bin` has **two** possible integrity sources, and they answer different questions:
+
+| Source | Written by | Covers |
+| --- | --- | --- |
+| `<name>.bin.sha256` (sidecar) | the device merger, `weight_merger.cpp::write_raw_tensor_atomic`, atomically on **every** merge | the **live** bytes currently on disk |
+| `entries[].sha256[role]` (in the map) | the exporter, once, at package build | the **shipped** bytes as published |
+
+**A reader must prefer the sidecar and fall back to the map.** After an on-device train→merge the
+`.bin` and its sidecar are both rewritten, but the map is not — C++ only ever *reads*
+`weight_handoff_map.json`. A reader that preferred the map would therefore compare post-merge bytes
+against the pre-merge shipped digest and reject a perfectly correct merge.
+
+Absence of both is fail-closed: the load gate throws rather than skipping verification. A stale
+*sidecar* still fails, so the precedence never weakens the gate — it only picks the authority that is
+actually kept current. Enforced by `HandoffPrecondition.loadMergedWeightsReady`
+(`internal/runtime/HandoffPrecondition.kt`).
+
+The map is produced offline by `TrainableTensorCodec.from_peft_mapping(...)` (which joins the training-side
+`peft_mapping` with the *observed* inference initializers — a naming drift raises at build time, never
+silently at runtime) and consumed on device by the map-driven load path.
diff --git a/docs/PUBLIC_API.md b/docs/PUBLIC_API.md
new file mode 100644
index 0000000..20bb9ac
--- /dev/null
+++ b/docs/PUBLIC_API.md
@@ -0,0 +1,79 @@
+# Public API
+
+The SemVer-governed public surface (F5) has three peers: the **Python library API**, the **CLI**, and the
+**Kotlin facade**. The Python side is exactly the surface declared in `mobiletransformers.__all__`
+(guarded by a parity test against `src/mobiletransformers/public_api.txt`).
+
+All three surfaces are documented below. See also [EXPORT.md](EXPORT.md), [MODEL_FORMAT.md](MODEL_FORMAT.md),
+[HUB_PACKAGE_FORMAT.md](HUB_PACKAGE_FORMAT.md), [ARCHITECTURE.md](ARCHITECTURE.md) and [RAG.md](RAG.md).
+
+## Python (`import mobiletransformers`)
+
+| Symbol | Kind | Purpose |
+| --- | --- | --- |
+| `__version__` | str | Package version. |
+| `resolve` | func | Config resolution with precedence CLI > env > YAML > package default. |
+| `get_settings` | func | Load secrets/settings (secrets live only in `Settings`, never in YAML). |
+| `Settings` | class | Typed settings/secrets container. |
+| `get_logger` | func | Library logger (`NullHandler`; no `print` in library code). |
+| `configure_logging` | func | Opt-in logging configuration for applications. |
+| `MobileTransformersError` | exc | Base of the exception hierarchy. |
+| `ConfigValidationError` | exc | Invalid configuration. |
+| `ExportError` | exc | Export/packaging failure. |
+| `ManifestError` | exc | Manifest parse/validation failure. |
+| `HandoffError` | exc | Weight-handoff-map failure. |
+| `MergeError` | exc | Merge failure. |
+| `HubError` | exc | Hub pull/push failure. |
+| `UnsupportedModelError` | exc | Unsupported architecture/model. |
+
+The exception names mirror the Kotlin hierarchy. This list is authoritative — it is regenerated/guarded
+against `public_api.txt`, so any addition is a deliberate SemVer change.
+
+## CLI (`mobiletransformers <command>`)
+
+| Command | Purpose |
+| --- | --- |
+| `export` | HF model → device-ready package (`--dry-run`, `--config`, `--validate` supported). |
+| `validate` | Validate a written package (`--package`) and/or a config YAML (`--config`). |
+| `package-model` | Re-hash an existing package and re-emit its manifest + checksums (`--package`). |
+| `push` | Validate + publish a package to the Hub. |
+| `pull` | Download a package (manifest-first, sha256-verified). |
+| `install-package` | Materialize a pulled package into the SDK cache layout. |
+| `support-matrix` | Generate `model_support_matrix.json` (+ `--docs`, `--md`). |
+| `push-adapter` | Publish a trained adapter (PEFT Mode 1 / native Mode 2). |
+| `federated` | `federated simulate` — FedAvg simulation over codec-ordered adapter records. |
+| `agent-dataset` | Build the tool-call training set + action schema (import a corpus, or synthesise per-user). |
+
+Run `mobiletransformers <command> --help` for flags. `make help` lists the wrapper targets
+(`export-model`, `package-model`, `android-build`, …).
+
+## Kotlin facade (`com.martinkorelic.mobiletransformers`)
+
+Obtained from `MobileTransformers.fromPretrained(context, repoId, …)`, which pulls and installs the
+package when it is not already in the cache.
+
+| Symbol | Kind | Purpose |
+| --- | --- | --- |
+| `MobileTransformers.fromPretrained` | entry point | resolve → (pull) → load; returns a `MobileTransformerModel`. |
+| `MobileTransformerModel` | handle | `train`/`trainingJob`/`merge`/`generate`/`retrieve`/`ingest`/`generateWithRag`/`classify`/`applyPeft`/`pushAdapter`/`close`. |
+| `TrainingJob` | lifecycle | `status`/`events` flows, cooperative `cancel`, `checkpoint()`/`canResume`. |
+| `RuntimeCapabilities`, `EngineCapabilities` | capability | installed features, resolved engine, merged-weight support. Also `supportsClassification`, `isEncoderOnly`, `graphPrecision`, `peftMethods`, `trainingParameterCount`, `toolCalling`. |
+| `PackageTask` | capability | the exported task; carries `inferenceGraphPrecision` (the **measured** precision, which a variant name may not match) and `labelCount`. |
+| `InferenceEngine` | enum | `NATIVE` (the floor) \| `GENAI`. |
+| `TrainConfig`, `GenerationConfig`, `RagConfig`, `DatasetConfig`, `PeftConfig`, `HubConfig`, `DeviceConfig` | config | public configs; mapped to the internal `ORT*Config` types. |
+| `TrainingScheduleConfig` | config | WorkManager-backed scheduling. `initialDelayMinutes` is a floor, not an appointment — an exact start needs `SCHEDULE_EXACT_ALARM`, which Play restricts. |
+| `TrainingResult`, `TrainingSummary`, `GenerationResult`, `MergeResult`, `RetrievalResult`, `GroundedResult`, `IngestResult`, `PushResult` | results | plain data; no `ORT*`/`*Native` type appears on this surface. `GenerationResult` also carries `promptTokenCount` and `contextLimit`; `GroundedResult` carries the assembled `prompt`. |
+| `ClassificationResult` | results | `scores` (full ranking), `top` (bounded by `topK`), `best`. |
+| `ToolCallResult`, `ToolCallSupport` | tool calls | `ToolCallResult.NoCall` is the common case and a distinct type, so a caller cannot forget to handle "the model just answered". |
+| `ActionSpec`, `IntendedAction` | tool calls | the allowlist a parsed call is validated against, and the bound action. Both declare `requiredPermissions`. |
+| `TrainCallback`, `GenerateCallback`, `RetrieveCallback` | callbacks | streaming progress. |
+| `MobileTransformersException` | errors | base of the hierarchy (`ModelNotInstalledException`, `MissingArtifactException`, `PeftMismatchException`, `FeatureNotInstalledException`, `EngineUnavailableException`, `NotImplementedFeatureException`). Deliberately `open`, not `sealed`: subclasses live in sibling packages (e.g. `hub.AdapterUploadDisabledException`). |
+| `constants/*` | enums | wire-value mirrors of the Python enums, parity-checked by `make parity`. |
+
+Internal packages (`repository`, `internal.*`, `ORT*`/`*Native`) are **not** public and may change.
+
+## Stability
+
+The three surfaces above are the public contract; internal modules (`export.pipeline`, `hub.*`,
+`artifacts.*`, `support.*`, `adapter.*`) may change between releases. The full surface is finalized and
+version-locked at the v1.0 release.
diff --git a/docs/RAG.md b/docs/RAG.md
new file mode 100644
index 0000000..865c721
--- /dev/null
+++ b/docs/RAG.md
@@ -0,0 +1,134 @@
+# Retrieval-Augmented Generation (RAG)
+
+MobileTransformers runs retrieval on-device: an embedding model produces query/document vectors, an
+on-device vector store (ObjectBox HNSW) does nearest-neighbour search, and the retrieved context is fed
+to generation.
+
+> **Scope of this page.** The **vector-store boundary**, **ingestion/chunking** and
+> **grounded generation + `RagConfig`** are all implemented and documented below. The remaining
+> gap is device acceptance: the instrumented `RagDeviceTest` and the ObjectBox parity smoke both
+> require a package pushed to a device.
+
+## The `VectorStore` boundary
+
+Retrieval goes through a small `VectorStore` interface (`com.martinkorelic.mobiletransformers.rag`), so
+the logic is testable on the JVM with no Android/ObjectBox:
+
+```kotlin
+data class RagDocument(val id: String, val title: String, val text: String,
+                       val metadata: Map<String, String> = emptyMap())
+data class RagMatch(val document: RagDocument, val score: Double)  // score = similarity (1 - distance)
+
+interface VectorStore {
+    fun insert(document: RagDocument, embedding: FloatArray): Long
+    fun search(queryEmbedding: FloatArray, topK: Int, minScore: Double = 0.0): List<RagMatch>
+    fun textSearch(query: String, topK: Int): List<RagMatch>
+    fun count(): Long
+    fun close()
+}
+```
+
+- **`ObjectBoxVectorStore`** is the default on-device backing store (wraps `ORTVectorDatabase`).
+- **`InMemoryVectorStore`** (test source set) is a pure-Kotlin cosine store for JVM unit tests.
+- Backends are pluggable by key via `VectorStoreRegistry` (F4); `objectbox` is the default key.
+
+## Semantics (preserved and tested)
+
+- **Distance:** COSINE (`@HnswIndex(distanceType = COSINE)`).
+- **Similarity:** ObjectBox returns a cosine *distance*; similarity is `1 - distance`. `RagMatch.score`
+  always carries the **similarity** (higher = closer), so callers never re-convert.
+- **`minScore`:** filters on similarity after conversion.
+- **Embeddings stripped:** results carry the document + similarity only; the embedding vector never
+  crosses the boundary.
+- **Text vs. semantic search:** `textSearch` is a substring/VALUE-index lookup and is **not**
+  similarity-ranked — every hit carries a fixed score (`TEXT_SEARCH_SCORE`). `search` is the
+  cosine-ranked semantic path.
+
+## Embedding dimensions (fail-closed registry)
+
+The supported embedding dimensions are declared once in `DimensionRegistry`:
+`{64, 128, 256, 384, 512, 768, 1024, 1536}`. A dimension outside the registry is rejected with a clear
+error — the store never silently picks a box. Adding a dimension is one `DimensionRegistry.register(dim)`
+call plus a declared `@HnswIndex VectorEntity<dim>` entity (an ObjectBox platform constraint).
+
+The embedding model and its dimension come from the pulled package's embedding/RAG variant; the
+dimension must be one the registry supports or installation/retrieval fails closed.
+
+`searchType` is validated against the `SearchType` enum (`semantic` | `text`) when the config is
+parsed, and `ORTRetriever` dispatches on the enum — an unrecognized value fails closed at the parse
+boundary rather than reaching the retriever.
+
+## Ingestion and chunking
+
+`model.ingest(path, RagConfig(...))` chunks a document, embeds each chunk and inserts it into the
+vector store. The loader is resolved from the file extension through `DOCUMENT_LOADER_REGISTRY`:
+
+| Extension | Loader | Notes |
+| --- | --- | --- |
+| `.txt` | plain text | whole file, then chunked |
+| `.md` | markdown | treated as text; no structural parsing |
+| `.jsonl` | JSON Lines | one document per line |
+
+**PDF and Word are rejected fail-closed** — there is no on-device extractor, and silently importing an
+empty document would poison retrieval. Convert to `.txt`/`.md` first.
+
+Chunking is pure character windowing (`chunkSize` / `chunkOverlap` on `RagConfig`), so it is JVM-testable
+and independent of the tokenizer. `IngestionProgress` reports per-chunk progress.
+
+## Retrieval on its own
+
+`model.retrieve(query, RagConfig())` returns ranked matches with scores and generates nothing. It is a
+first-class operation, not merely the first half of `generateWithRag`, for two reasons.
+
+**It is the only part of the retrieval story a pure encoder can show.** `retrieve` requires
+`capabilities.supportsEmbedding` and nothing else — no generative head, no KV cache. An
+`all-MiniLM-L6-v2` package installed on its own can search, and the sample app's drawer reflects that
+by offering Retrieval while hiding Chat.
+
+**It is the only place retrieval can be judged.** Inside a grounded answer, bad retrieval and a model
+ignoring good retrieval produce the same symptom — a wrong answer — and are indistinguishable. Looking
+at the matches directly separates them, which is why this is a screen in the sample app and not a
+debug flag.
+
+```kotlin
+val hits = model.retrieve("how do I merge an adapter?", RagConfig(topK = 4, minScore = 0.2))
+hits.matches.forEach { println("%.3f  %s  %s".format(it.score, it.title, it.text)) }
+
+println("${hits.matches.size} passages from ${hits.documentCount} documents")
+```
+
+A match is a **chunk**, not a document: ingestion splits each file into `chunkSize` pieces and each is
+stored, ranked and returned separately, so several matches routinely come from one file. `title` is
+that file's name, `chunkId` is `<documentId>#<n>`, and `RetrievalResult.documentCount` /
+`documentTitles` do the grouping — which is how the sample app can say "found 4 passages in 2
+documents" rather than conflating the two counts.
+
+## Grounded generation
+
+`model.generateWithRag(query, rag, generation, promptStrategy, callback)` runs retrieve → assemble →
+generate and returns a `GroundedResult` carrying the answer, the matches, **and the assembled prompt**
+so the exact context sent to the model is inspectable. `PromptAssembler` is overridable via
+`PromptStrategy`.
+
+Pass a `GenerateCallback` to stream the answer. It observes the generation leg, so its first event is
+also the signal that retrieval finished. A grounded turn is the slowest operation in the SDK — an
+embedding pass, a vector search, then a decode over a prompt several hundred tokens longer than a plain
+one — and without a callback it produces nothing at all until it is completely done, which is not
+distinguishable from a hang.
+
+Pass a `RetrieveCallback` to receive the matches **when they are found**, rather than in the returned
+`GroundedResult` after the answer is complete. The two arrive tens of seconds apart, so a UI that wants
+to show what it retrieved before the answer built on it — as the sample app's Chat screen does, as its
+own turn above the reply — needs them at that moment.
+
+`RagConfig` carries `topK`, `minScore` (a similarity floor applied during search), `searchType` and
+`indexingMode`. A changed config applies on every call: query-shaping fields are pushed onto the live
+retriever, and a change of embedding model rebuilds it.
+
+`indexingMode` is `precompute` in v1; `dynamic` fails closed rather than silently behaving like
+`precompute`.
+
+## Not yet (tracked)
+
+- **Device acceptance**: the instrumented `RagDeviceTest` and the ObjectBox parity smoke
+  both `assumeTrue` on a package pushed to a device.
diff --git a/docs/RELEASE_CHECKLIST.md b/docs/RELEASE_CHECKLIST.md
new file mode 100644
index 0000000..53a303d
--- /dev/null
+++ b/docs/RELEASE_CHECKLIST.md
@@ -0,0 +1,85 @@
+# Release Checklist
+
+> The versioning, licence and release gate for a tagged release.
+>
+> Status as of 2026-08-09: every technical item below is satisfied except CI (a policy decision, see
+> below) and the licence. **The licence is the single blocker on the release gate**, and it is a
+> rights-holders decision, not an engineering task.
+
+## Gate
+
+- [x] Parity gate green (`make parity`): enums/schemas match the Kotlin/C++ mirrors.
+- [x] Lint + typecheck clean (`make lint`, `make typecheck`).
+- [x] Host test gates green: Python `make check`, C++ (`make test-cpp`), Kotlin JVM
+      (`:MobileTransformers:testDebugUnitTest`).
+- [x] AAR builds + publishes to mavenLocal and an external consumer app builds against it.
+      *Proven 2026-08-08: `make publish-local && make consumer-app` → a 105 MB APK carrying all 7
+      native libraries, resolved from mavenLocal alone (`FAIL_ON_PROJECT_REPOS`).*
+- [x] Docs set complete for locked contracts; `COMPATIBILITY_MATRIX.md` regenerated (not stale).
+- [x] All version sites agree (pyproject == `__version__` == Gradle `version` == `CITATION.cff` ==
+      the `tiny_package` fixture's `mobiletransformersVersion` == tag).
+      *Guarded by `tests/unit/test_version_sites.py`, so this cannot silently drift. The Gradle
+      version lives in `android/MobileTransformers/gradle.properties` and is overridable with
+      `-Pversion=`. The sample app's `versionName` now derives from that root property rather than
+      being a literal — it read `"1.0"`, which matched no other site in the repo and was the one
+      version number a user actually sees.*
+- [x] **Model shelf published** — `make publish-catalog` run, and every entry in the app's
+      `assets/model_catalog.json` names a repo that actually holds a package.
+      *Needs `HF_TOKEN_ORG` in `.env`. Verify against the Hub API, not the script's own log: a push
+      that half-succeeded and a push that worked print the same final line. See
+      [CATALOG.md](CATALOG.md).*
+      *Done 2026-08-17: five repos, each carrying a `mobiletransformers_manifest.json`.*
+- [x] **A fresh clone can be provisioned** — `make doctor` names every missing prerequisite with the
+      command that fixes it, and `make fetch-native-deps` installs the gitignored Android natives
+      against the sha256s in `third_party/android/manifest.json`.
+      *Done 2026-08-17: hosted in the public dataset repo
+      [`mobiletransformers/build-artifacts`](https://huggingface.co/datasets/mobiletransformers/build-artifacts)
+      and `baseUrl` set. Verified anonymously (`env -u HF_TOKEN -u HF_TOKEN_ORG`) from a
+      tracked-files-only tree, for the natives, the training wheel and the debug symbols.*
+- [x] `CHANGELOG.md` updated for the release; non-goals listed, and a `Known issues` section carries
+      what a reader must not discover the hard way.
+- [ ] **License finalized** with SPDX headers on first-party source. **BLOCKER — see below.**
+- [ ] CI green: `fast` → `export-smoke` → `android-assemble` (`.github/workflows/ci.yml`).
+      **Blocked on a policy decision, not on the code.** All three workflows are
+      `workflow_dispatch`-only: their automatic triggers were removed 2026-08-08 because they were not
+      in use and the native-dependency provisioning question is unresolved. Until the `on:` blocks are
+      restored (they are preserved in a comment at the top of each file), **a green badge is not a
+      gate** — a release must record a manual run instead. See "Open decisions".
+
+## Device evidence
+
+- [x] train 1 step → merge → generate 1 token → ingest/query 1 RAG doc, with time/memory artifacts.
+      *Ran on a Galaxy S21 FE / Android 15 / arm64-v8a, 2026-08-08, via `make device-package` →
+      `make device-test`. `device.yml` has a real body but no registered self-hosted runner, so this
+      evidence is produced by a manual run, not nightly CI.*
+
+## The licence blocker
+
+The project is **CC-BY-NC-4.0**, which is incompatible with the consumable-AAR goal: a non-commercial
+licence blocks the adoption the release is for. Relicensing is a decision for **all rights holders** —
+`CITATION.cff` lists Korelič and Pejović.
+
+Nothing technical is waiting behind it. When agreement lands, the swap is four coordinated edits plus
+headers, and should go in as **one reviewed commit**:
+
+| Site | Current | Change |
+| --- | --- | --- |
+| `LICENSE.md` | full CC BY-NC 4.0 text | replace with the chosen licence text |
+| `pyproject.toml` (~`:21`) | `license` deliberately omitted, with a comment naming the pending decision | set the licence expression |
+| `android/MobileTransformers/MobileTransformers/build.gradle.kts` (POM block) | hard-codes CC BY-NC 4.0, with a comment requiring lockstep with `LICENSE.md` | update to match |
+| first-party source | **zero** SPDX headers exist anywhere | add `SPDX-License-Identifier` headers |
+
+**Scope of the headers: first-party source only.** Vendored Microsoft / tokenizers / protobuf code is
+untouched and is already enumerated in `THIRD_PARTY_NOTICES.md`, which is complete and current
+(redistributed-in-AAR, build/test-only, and Python dependency tables). Model weights keep their
+upstream licences regardless of this decision.
+
+## Open decisions blocking a v1.0 tag
+
+1. **Licence** — above. The only item the release gate genuinely waits on.
+2. **CI triggers** — restore `push`/`pull_request` on `ci.yml`, or keep workflows manual and accept
+   that "CI green" means a recorded manual run. Either is defensible; the checklist must match
+   whichever is chosen.
+3. **CI native-dep provisioning** — how `jniLibs`/`aarLibs` and the git-ignored cp312 ORT-training
+   wheel reach a hosted runner (rebuild vs cached artifact vs private storage). `android-assemble` and
+   `ort-training-smoke` self-skip without them today. Only worth answering if (2) restores triggers.
diff --git a/docs/SHOWCASE.md b/docs/SHOWCASE.md
new file mode 100644
index 0000000..6351823
--- /dev/null
+++ b/docs/SHOWCASE.md
@@ -0,0 +1,163 @@
+# A tour of the sample app
+
+`MobileTransformersApp` is the reference consumer of the SDK: everything it does, it does through the
+public facade, and a guard test enforces that. It is also the fastest way to see what the framework
+actually is — export → pull → chat → retrieve → classify → fine-tune → merge → tool-call, all on the
+phone, with no server anywhere.
+
+This page is the tour: one section per capability, which package it needs, and what you should see.
+
+```bash
+make doctor            # confirm the prerequisites first
+make android-build     # builds the SDK and the app
+```
+
+> **`make android-build` does not source `.env`.** The APK builds fine and then silently cannot pull
+> private repos, because the token is baked in at build time. Run
+> `set -a && . ./.env && set +a` first if you want the private catalog entries to install.
+
+## The drawer tells you what the package can do
+
+<!-- CLIP: docs/assets/capability-drawer.gif — to record.
+     SmolLM2 loaded (Chat present, Classify absent) -> load DistilBERT -> Classify appears, Chat and
+     Retrieval go. The redirect to Models is part of the story, not a glitch. -->
+
+Eight destinations in three groups — *Run a model*, *Train on device*, *Setup*. What you see depends
+on the package you have loaded, and the distinction is deliberate:
+
+- **Blocked** — reachable, with the reason written on it, because the reason *is* the instruction
+  ("this package has no train/ stage — pull one with Training requested").
+- **Hidden** — not applicable at all. A chat box on an embedding model is a promise the package cannot
+  keep, so it is left out rather than greyed out.
+
+All of it derives from `RuntimeCapabilities`, computed from the artifacts actually installed. The
+drawer cannot claim a capability the package does not have, or withhold one it does.
+
+| you load | you get |
+| --- | --- |
+| SmolLM2 / Qwen2.5 with `train` + `rag` | everything except Classify |
+| all-MiniLM-L6-v2 alone | Models, Retrieval, Train, Federated — **no Chat**, no Classify |
+| distilbert-sst2-english | Models, Classify, Train, Federated — **no Chat**, no Retrieval |
+
+## Models — where a package comes from
+
+<!-- CLIP: docs/assets/install-from-catalog.gif — to record.
+     Catalog -> Install on all-MiniLM-L6-v2 (94 MB, finishes inside a clip) -> download card advances
+     -> the model bar shows it loaded. Do not use a multi-GB entry. -->
+
+**Needs:** nothing. This is the first screen for a reason: on a clean install nothing else can do
+anything until a package exists.
+
+Two tabs. **Catalog** is the shelf from [CATALOG.md](CATALOG.md), read out of
+`assets/model_catalog.json` — each card shows the measured download size, the feature groups, and the
+PEFT method the package was exported with. At the bottom, *Advanced: pull any package* takes a Hub id
+directly, for a package you exported yourself. **Installed** is what is already on the device.
+
+Start with **SmolLM2-135M-Instruct**: smallest useful chat model, fastest to pull, fastest to train.
+
+What you should see: a progress row while it downloads, then the model bar at the top of every screen
+naming the loaded package, its engine and its precision.
+
+> An entry marked "not published" stays visible with Install disabled. An entry that 404s on tap is
+> worse than no entry — the user cannot tell "not published" from "your token is wrong" from "the app
+> is broken".
+
+## Chat — generation, streaming, grounded answers, tool calls
+
+![A chat reply becoming a validated Android alarm intent](assets/mobiletransformers_functioncall.gif)
+
+**Needs:** any decoder (SmolLM2, Qwen2.5, FunctionGemma). Hidden for encoders.
+
+Type and send; tokens stream as they are produced. Two things worth doing here:
+
+**Ground with RAG** (the chip, enabled once the package has an embedding stage) answers from the
+documents you ingested on the Retrieval screen instead of from the model's own weights. Retrieval
+posts its own turn *before* the answer — "Found 4 passages in 2 documents", naming the files, with the
+passages themselves behind a toggle — and then the answer streams in beneath it, carrying the prompt
+that was actually built. So a bad grounded answer is debuggable in reading order: you see what was
+found, then what the model did with it, which is what separates wrong retrieval from a model ignoring
+good retrieval.
+
+**Tool calls** are detected from the answer, not declared in advance. Ask FunctionGemma to set an
+alarm and it emits a structured call; the app validates it against the allowlist in
+*Configuration ▸ Actions*, shows you what it is about to do, and only runs it if you accept. Nothing
+executes without that tap.
+
+What you should see: for an accepted `SET_ALARM`, an alarm actually appearing in the clock app.
+
+## Retrieval — search on its own
+
+![Grounded answering over documents held on the device](assets/mobiletransformers_rag.gif)
+
+**Needs:** any package with an embedding stage — including `all-MiniLM-L6-v2` by itself.
+
+Ingest the bundled sample documents or pick a file, then search. You get ranked passages with scores
+and nothing generated.
+
+It is its own destination rather than a corner of Chat for two reasons. It is the only part of the
+retrieval story a pure **encoder** can show at all, since an embedding model has no generative head.
+And it is the only place retrieval can be judged on its own: inside a grounded answer, bad retrieval
+and a model ignoring good retrieval are indistinguishable.
+
+## Classify — labels with probabilities
+
+![Classifying text on the device, with a probability per label](assets/mobiletransformers_classify.gif)
+
+**Needs:** a classifier that names its labels. In practice: **distilbert-sst2-english**.
+
+Type a sentence, see the probability assigned to each label.
+
+Deliberately a distribution rather than a single answer — a classifier that is 34%/33%/33% has told
+you nothing, and a single top label hides that completely.
+
+Hidden for `all-MiniLM-L6-v2` even though that package *has* a classification graph, because its head
+is randomly initialised and its labels are `LABEL_0`/`LABEL_1`. A number in a costume is worse than an
+absent screen. See [CATALOG.md](CATALOG.md) for why the encoder is exported that way at all.
+
+## Train — fine-tuning, on the phone
+
+![A LoRA training run on the device, and the merge that follows](assets/mobiletransformers_train.gif)
+
+**Needs:** a package pulled with Training requested (`train` in its features).
+
+Install the sample dataset, press **Start**. You get a live loss curve, and the run survives the app
+going to the background — it is a foreground WorkManager job, which is why the app asks for
+notification permission the first time.
+
+Then press **Merge**. This folds the trained adapter into the inference weights on device, and it is
+the step that makes the fine-tune real: generate before and after and the model's behaviour changes.
+
+Scheduling lives in *Configuration ▸ Training*. A scheduled run's start delay is a **floor, not an
+appointment** — an exact wall-clock start needs `SCHEDULE_EXACT_ALARM`, which Play restricts to alarm
+clocks and calendar reminders. The UI says so rather than pretending otherwise.
+
+## Federated — one round of adapter exchange
+
+**Needs:** a trainable package.
+
+Exports the local adapter factors, and expects a host-side aggregation step to hand back an average.
+
+The consent gate is on screen rather than implied: `FEDERATION_ENABLED` is false by default, and
+rather than hiding the feature the screen says so and still lets the button be pressed. The resulting
+`FederatedConsentException` names the missing protection, which is more useful to an integrator than a
+greyed-out control with no explanation.
+
+## Configuration — six tabs of typed settings
+
+**Generation** (length and sampling), **Training** (run length, optimizer, PEFT method, what happens
+after the run), **Dataset** (which file and how to read it), **Retrieval** (shape, search, chunking),
+**Actions** (what a model may ask for, and what happens when it does), **Device** (execution, and when
+a change takes effect).
+
+Chat's "Settings" link opens *Generation* directly.
+
+## About
+
+What the app is, in what order to use it, and the two device settings that change what it can show.
+
+## Related
+
+- [CATALOG.md](CATALOG.md) — the published packages and which to start with
+- [ANDROID_SDK.md](ANDROID_SDK.md) — consuming the AAR in your own app
+- [COOKBOOK.md](COOKBOOK.md) — copy-pasteable Kotlin per task
+- [ARCHITECTURE.md](ARCHITECTURE.md) — how the host exporter and the device SDK fit together
diff --git a/docs/assets/README.md b/docs/assets/README.md
new file mode 100644
index 0000000..d647a07
--- /dev/null
+++ b/docs/assets/README.md
@@ -0,0 +1,82 @@
+# Assets
+
+Source art and screen recordings. Referenced from [the README](https://github.com/martinkorelic/mobiletransformers/blob/main/README.md) and the docs pages.
+
+| file | used by |
+| --- | --- |
+| `mobiletransformers_banner.png` | the README header, every model card, the Hugging Face org card |
+| `mobiletransformers_banner_small.png` | **nothing in this repository.** Kept because a Hugging Face org/model card may reference it by URL, which a grep here cannot see. Delete it if not. |
+| `mobiletransformers_logo.png` | **the source the Android icons were cut from** — see below |
+| `mobiletransformers_train.gif` | README ▸ Examples · `SHOWCASE.md` ▸ Training — a LoRA run and the merge that follows it |
+| `mobiletransformers_functioncall.gif` | README ▸ Examples · `SHOWCASE.md` ▸ Chat — a tool call validated and fired as a real alarm |
+| `mobiletransformers_rag.gif` | README ▸ Examples · `SHOWCASE.md` ▸ Retrieval — grounded answering, sources shown first |
+| `mobiletransformers_classify.gif` | README ▸ Examples · `SHOWCASE.md` ▸ Classify — a sentiment encoder scoring text on device |
+
+## Recording a showcase clip
+
+Still unrecorded, and marked as `<!-- CLIP: … -->` placeholders in `SHOWCASE.md`: the drawer changing
+shape per package, and install-from-catalog. Each placeholder says what to capture.
+
+The four committed clips are **800px wide and 1–7 MB**, above the guidance below. They were kept at
+capture resolution deliberately: the phone UI's body text stops being legible when scaled to 480, and
+an unreadable screenshot of a text-heavy screen demonstrates nothing. Treat the numbers below as the
+target for a *new* clip, not as a rule to retrofit onto these.
+
+**One claim per clip, and the claim must be visible without the caption.** A reader sees motion,
+decides in two seconds, and scrolls. Aim for 6–12 seconds and under 5 MB — longer and GitHub
+lazy-loads it into a grey box; larger and it never finishes loading on a phone.
+
+```bash
+adb shell screenrecord --size 720x1520 --bit-rate 8M --time-limit 30 /sdcard/shot.mp4
+adb pull /sdcard/shot.mp4
+
+# mp4 -> gif. The generated palette matters: a default-palette gif of this dark UI bands badly.
+ffmpeg -i shot.mp4 -vf "fps=12,scale=480:-1:flags=lanczos,palettegen" palette.png
+ffmpeg -i shot.mp4 -i palette.png \
+  -lavfi "fps=12,scale=480:-1:flags=lanczos[x];[x][1:v]paletteuse" out.gif
+```
+
+`screenrecord` caps at 3 minutes and **does not capture the touch indicator** — turn on
+*Developer options ▸ Show taps* first, or things happen with no visible cause. Trim dead air: the
+first frame is the thumbnail, so make it the state *before* the interesting thing. And check the
+status bar before recording — that frame goes on the internet.
+
+## Replacing the logo
+
+The Android icon resources were cut from `mobiletransformers_logo.png` and are **committed as
+finished artwork** — there is no generator, so swapping the logo means redoing them. These are the
+files, and the four rules that were applied to produce them.
+
+Under `android/MobileTransformers/MobileTransformersApp/src/main/res/`:
+
+| file | densities | what it is |
+| --- | --- | --- |
+| `mipmap-*/ic_launcher_foreground.png` | m/h/xh/xxh/xxxh | adaptive-icon foreground, 108dp canvas |
+| `mipmap-*/ic_launcher_monochrome.png` | m/h/xh/xxh/xxxh | Android 13+ themed-icon layer |
+| `mipmap-*/ic_launcher.webp` + `ic_launcher_round.webp` | m/h/xh/xxh/xxxh | legacy pre-API-26 icons, 48dp |
+| `drawable-*/ic_logo.png` | m/h/xh/xxh/xxxh | the top-app-bar mark, 32dp |
+| `values/ic_launcher_background.xml` | — | the adaptive-icon background colour |
+
+**1. Cut the alpha noise floor first.** This source carries roughly 51,000 pixels at alpha 1–31 — an
+artefact of how it was produced. They are invisible against white and become a dirty haze the instant
+the art is composited onto the dark launcher background. Zero every pixel at **alpha ≤ 32**, and zero
+its RGB too: a transparent pixel still carries colour, and resampling blends it back in as a dark
+halo. Real antialiased edges live at alpha 32–255 and must be left alone.
+
+**2. Scale the foreground into the 66dp safe zone.** Android composites an adaptive icon on a 108dp
+canvas and lets the launcher mask it to a circle, squircle or rounded square — only the centre
+**66dp** is guaranteed to survive. Art that fills its canvas loses its edges on most phones. The
+committed foreground occupies **60%** of the canvas width, centred, which clears a circular mask with
+margin to spare.
+
+**3. The background is dark on purpose.** `#171E22`, taken from the logo's own outline. The mark has a
+white sticker outline that disappears completely on a light background — on white the icon reads as a
+yellow blob with no silhouette.
+
+**4. The monochrome layer is line art, not a silhouette.** A filled silhouette of a sticker is a
+featureless blob. The committed layer keeps only the *dark stroke* pixels (alpha > 128 and luminance
+< 110), which preserves the outlines, eyes, smile, phone frame and brain traces — recognisable at
+icon size, where a blob is not.
+
+Resample with Lanczos. Do not reach for ImageMagick's SVG path on this machine: its delegate points at
+`rsvg-convert`, which is not installed, so it silently falls back to a weaker renderer.
diff --git a/docs/assets/mobiletransformers_banner.png b/docs/assets/mobiletransformers_banner.png
new file mode 100644
index 0000000..cce1766
Binary files /dev/null and b/docs/assets/mobiletransformers_banner.png differ
diff --git a/docs/assets/mobiletransformers_banner_small.png b/docs/assets/mobiletransformers_banner_small.png
new file mode 100644
index 0000000..a66decc
Binary files /dev/null and b/docs/assets/mobiletransformers_banner_small.png differ
diff --git a/docs/assets/mobiletransformers_classify.gif b/docs/assets/mobiletransformers_classify.gif
new file mode 100644
index 0000000..d38277f
Binary files /dev/null and b/docs/assets/mobiletransformers_classify.gif differ
diff --git a/docs/assets/mobiletransformers_functioncall.gif b/docs/assets/mobiletransformers_functioncall.gif
new file mode 100644
index 0000000..9166172
Binary files /dev/null and b/docs/assets/mobiletransformers_functioncall.gif differ
diff --git a/docs/assets/mobiletransformers_logo.png b/docs/assets/mobiletransformers_logo.png
new file mode 100644
index 0000000..f0d4e7b
Binary files /dev/null and b/docs/assets/mobiletransformers_logo.png differ
diff --git a/docs/assets/mobiletransformers_rag.gif b/docs/assets/mobiletransformers_rag.gif
new file mode 100644
index 0000000..8514836
Binary files /dev/null and b/docs/assets/mobiletransformers_rag.gif differ
diff --git a/docs/assets/mobiletransformers_train.gif b/docs/assets/mobiletransformers_train.gif
new file mode 100644
index 0000000..c3edec9
Binary files /dev/null and b/docs/assets/mobiletransformers_train.gif differ
diff --git a/docs/base-model.gif b/docs/base-model.gif
deleted file mode 100644
index 2e2637b..0000000
Binary files a/docs/base-model.gif and /dev/null differ
diff --git a/docs/citation.md b/docs/citation.md
new file mode 100644
index 0000000..5f80f89
--- /dev/null
+++ b/docs/citation.md
@@ -0,0 +1,26 @@
+# Citation
+
+If you use MobileTransformers in your own work, please cite it:
+
+```bibtex
+@misc{mobiletransformers2025,
+  author       = {Koreli\v{c}, Martin and Pejovi{\'c}, Veljko},
+  title        = {MobileTransformers: An On-Device LLM PEFT Framework for Fine-Tuning and Inference},
+  year         = {2025},
+  howpublished = {\url{https://gitlab.fri.uni-lj.si/lrk/mobiletransformers}}
+}
+```
+
+The citation deliberately names the **original codebase** at
+[gitlab.fri.uni-lj.si/lrk/mobiletransformers](https://gitlab.fri.uni-lj.si/lrk/mobiletransformers),
+not this documentation site or the GitHub mirror: that is the address the work was published under,
+and a citation that changes address is a citation that stops resolving. Use
+[github.com/martinkorelic/mobiletransformers](https://github.com/martinkorelic/mobiletransformers) to
+*get* the code — cite the URL above.
+
+The repository also carries a [`CITATION.cff`](https://github.com/martinkorelic/mobiletransformers/blob/main/CITATION.cff),
+which GitHub renders as a "Cite this repository" button and which reference managers can read
+directly. That file is the authoritative version — this page mirrors it.
+
+The framework accompanies the master's thesis
+[*Parameter-Efficient Tuning of Large Language Models on Mobile Devices*](https://repozitorij.uni-lj.si/IzpisGradiva.php?lang=eng&id=175561).
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..f7bc2d6
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,152 @@
+# Getting started
+
+Three routes in, depending on what you want. They are independent — you do not need the Python side
+to run the app, and you do not need Android to export a package.
+
+| I want to… | Go to |
+| --- | --- |
+| **see it work on a phone**, with no Python at all | [Run the sample app](#run-the-sample-app) |
+| **use the SDK in my own Android app** | [Consume the SDK](#consume-the-sdk) |
+| **export my own model** | [Set up the Python side](#set-up-the-python-side) |
+
+!!! tip "Run `make doctor` first"
+
+    It reports every prerequisite — uv, Python 3.10 and 3.12, the current venv profile, the
+    ORT-training wheel, `JAVA_HOME`, the Android SDK, `adb`, the vendored natives, the `.env` tokens
+    — and the exact command that fixes each one. It downloads nothing.
+
+## Requirements
+
+| | |
+| --- | --- |
+| **Python** | 3.10–3.13 for the core and the exporter. The training-export path additionally needs **3.12**, because the ONNX Runtime Training wheel is built `cp312` only. |
+| **Package manager** | [uv](https://docs.astral.sh/uv/). The lock file covers every profile; `pip` is not supported. |
+| **Android** | API 24+ to run, JDK 17 and the Android SDK + NDK to build. |
+| **ABI** | **arm64-v8a only.** There is no x86_64 build, so the SDK does **not** run on a standard Android emulator — you need a physical device. |
+| **OS for training** | The training side is Linux x86_64, because of that same wheel. Inference, export-without-training and the whole Android side are platform-independent. |
+
+## Run the sample app
+
+```bash
+git clone https://github.com/martinkorelic/mobiletransformers
+cd mobiletransformers
+
+make fetch-native-deps        # ~180 MB of prebuilt natives, see below
+make android-build            # builds the SDK and the app
+```
+
+Then install a package from inside the app: open **Models**, pick **SmolLM2-135M-Instruct** from the
+catalog (the smallest useful chat model, and the fastest to train), and press Install. Everything
+else in the app unlocks from there — [take the tour](SHOWCASE.md).
+
+!!! warning "The private catalog entries need a token at build time"
+
+    `make android-build` does not source `.env`, and the Hub token is baked into the APK at build
+    time — so an app built without one silently cannot pull the private catalog entries. Run
+    `set -a && . ./.env && set +a` first if you need them. See `.env.example` for which token does
+    what.
+
+### Why a clone cannot build on its own
+
+About 180 MB of prebuilt native binaries and vendored headers are gitignored: ONNX Runtime built for
+training on Android, the GenAI engine, the tokenizer static libraries, and protobuf headers. They are
+too large for git and cannot be rebuilt quickly.
+
+`make fetch-native-deps` gets them from a public Hugging Face dataset repo. It reads
+`third_party/android/manifest.json`, checks the archive's SHA-256, unpacks it, then checks every
+unpacked file's SHA-256 individually — because a half-populated `jniLibs/` fails the link naming a
+*symbol*, not a missing file, and that is an afternoon lost.
+
+```bash
+make fetch-native-deps                            # required to build
+TRAINING=1 scripts/fetch_native_deps.sh           # + the ORT-training wheel (632 MB), export only
+SYMBOLS=1  scripts/fetch_native_deps.sh           # + unstripped binaries, to symbolicate a crash
+URL=file:///path/to/dir scripts/fetch_native_deps.sh   # a local mirror
+```
+
+No credentials are needed. See [Architecture ▸ native dependencies](ARCHITECTURE.md).
+
+## Consume the SDK
+
+The Android library publishes as `com.martinkorelic.mobiletransformers:mobiletransformers-android`.
+Until it is on a public Maven repository, install it locally:
+
+```bash
+make publish-local            # -> ~/.m2/repository
+```
+
+```kotlin
+repositories { mavenLocal() }
+dependencies {
+    implementation("com.martinkorelic.mobiletransformers:mobiletransformers-android:0.2.0")
+}
+```
+
+```kotlin
+val model = MobileTransformers.fromPretrained(
+    context = context,
+    repoId  = "mobiletransformers/SmolLM2-135M-Instruct",
+    features = setOf(ModelFeature.Inference, ModelFeature.Training),
+)
+val result = model.generate("Summarise this in one line: …")
+```
+
+`fromPretrained` resolves the package's manifest, downloads only the feature groups you asked for,
+verifies every file and installs atomically — so a killed download leaves the previous copy intact.
+`examples/consumer-app/` is a minimal app that does exactly this and nothing else.
+
+Full surface in [Using the SDK](ANDROID_SDK.md); copy-pasteable recipes per task in the
+[cookbook](COOKBOOK.md); the stability contract in [Public API](PUBLIC_API.md).
+
+## Set up the Python side
+
+```bash
+make setup                    # core + dev, Python 3.10
+make check                    # lint, typecheck, enum parity, guards, unit tests
+```
+
+Export a package:
+
+```bash
+make setup-export
+mobiletransformers export --model HuggingFaceTB/SmolLM2-135M-Instruct \
+                          --output build/pkg --train --rag --validate
+```
+
+That single command produces the whole package: the ONNX inference graph, a PEFT-enabled training
+graph with an optimiser, the tokenizer, an embedding stage if you asked for `--rag`, and the manifest
+that ties them together. [Export a model](EXPORT.md) covers the flags, the supported architectures
+and what each stage contains.
+
+Push it to the Hub, or push it straight to a connected device:
+
+```bash
+mobiletransformers push --package build/pkg --repo your-org/your-model --create
+make device-package MODEL=HuggingFaceTB/SmolLM2-135M-Instruct TRAIN=1 RAG=1
+```
+
+### Dependency profiles do not co-install
+
+This is the single most common way to "break" the repository, so it is worth reading once.
+
+The `export` extra and the `ort-training-local` group **conflict on purpose**: both provide a module
+called `onnxruntime`, and installing them together produces an environment where the import that wins
+is undefined. `uv` is configured to refuse the combination rather than resolve it.
+
+```bash
+uv sync --frozen --group dev --python 3.10     # reset to the core profile
+```
+
+Run that before `make check`. Scripts that switch profiles (`scripts/device_package.sh`,
+`scripts/publish_catalog.sh`) leave the tree on another one, and the resulting failures look like
+unrelated bugs.
+
+Always pass an explicit `--group`/`--extra` to `uv run`, and use `uv run --frozen` — a bare `uv run`
+validates every source in the lock before executing, including a git-ignored 662 MB local wheel that
+most machines do not have.
+
+## Next
+
+- [A tour of the app](SHOWCASE.md) — one section per capability, and what you should see
+- [The model shelf](CATALOG.md) — six published packages, measured sizes, which to start with
+- [PEFT methods](on-device-peft.md) — LoRA, LoRA-XS and MARS, and what each costs on a phone
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..b6f10bd
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,75 @@
+# MobileTransformers
+
+Export a Hugging Face model, pull it onto a phone, then chat with it, retrieve over your own
+documents, classify text, fine-tune it, merge the adapter into the weights, and let it call tools —
+**entirely on the device**. No server, no inference API, no data leaving the phone.
+
+Built on **ONNX Runtime**, for both inference *and* training on Android.
+
+[Get started](getting-started.md){ .md-button .md-button--primary }
+[See the app](SHOWCASE.md){ .md-button }
+[Source on GitHub](https://github.com/martinkorelic/mobiletransformers){ .md-button }
+
+---
+
+## Two halves that meet at a file format
+
+The project is a **Python exporter** and an **Android SDK**, and they never call each other. The
+exporter turns a Hugging Face checkpoint into a package of ONNX graphs, a tokenizer and a manifest;
+the SDK reads that package on a phone. Everything they have to agree about is written down in
+[the package format](MODEL_FORMAT.md) rather than implied by matching code.
+
+```bash
+# Host: produce a package
+mobiletransformers export --model HuggingFaceTB/SmolLM2-135M-Instruct \
+    --output build/package --train --rag
+```
+
+```kotlin
+// Device: consume one
+val model = MobileTransformers.fromPretrained(
+    context, repoId = "mobiletransformers/SmolLM2-135M-Instruct",
+    features = setOf(ModelFeature.Inference, ModelFeature.Training),
+)
+val answer = model.generate("Summarise this in one line: …")
+```
+
+## Where to go
+
+| If you want to… | Read |
+| --- | --- |
+| install the app and see it work | [Getting started](getting-started.md), then [the tour](SHOWCASE.md) |
+| pick a model to try first | [The model shelf](CATALOG.md) — six published packages, measured sizes |
+| build an app on the SDK | [Using the SDK](ANDROID_SDK.md), then the [cookbook](COOKBOOK.md) |
+| know exactly what is API and what is not | [Public API](PUBLIC_API.md) |
+| export your own model | [Export a model](EXPORT.md) |
+| understand the fine-tuning methods | [PEFT methods](on-device-peft.md) — LoRA, LoRA-XS, MARS |
+| ground answers in your own documents | [Retrieval](RAG.md) |
+| know how fast it actually is | [Measured performance](mobile_evaluation.md) |
+| understand how the pieces fit | [Architecture](ARCHITECTURE.md) |
+
+## What is genuinely on the device
+
+Every one of these runs with the network off, once the package is installed:
+
+- **Generation** — streaming, with a chat template, KV cache and a choice of two ONNX Runtime engines.
+- **Fine-tuning** — a real training loop with an optimiser and a loss curve, not a fixed-function call.
+  LoRA, LoRA-XS and **MARS**, this project's own method.
+- **Merging** — folding a trained adapter back into the inference weights, so the fine-tune survives
+  into ordinary generation.
+- **Retrieval** — chunking, embedding and vector search over documents you supply.
+- **Classification** — encoder packages with a real head, scored per label.
+- **Tool calling** — a model's answer parsed into a structured call, validated against an allowlist
+  the app owns, and bound to an Android intent.
+
+## Status
+
+Version **0.2.0**. The exporter, the Android SDK, the sample app and the published model shelf all
+work end to end. See the [release checklist](RELEASE_CHECKLIST.md) for what stands between this and a
+1.0, and the repository's `CHANGELOG.md` for what has changed.
+
+!!! warning "Licensing"
+
+    The repository currently ships **CC BY-NC 4.0**, which does not suit a consumable Android
+    library. Relicensing is pending agreement between both authors — see
+    [the release checklist](RELEASE_CHECKLIST.md). Check the licence before depending on this.
diff --git a/docs/on-device-peft.md b/docs/on-device-peft.md
new file mode 100644
index 0000000..80abb05
--- /dev/null
+++ b/docs/on-device-peft.md
@@ -0,0 +1,97 @@
+# PEFT methods
+
+Fine-tuning a whole model on a phone is not on the table: the optimiser state alone would be several
+times the model's size. **Parameter-efficient fine-tuning** makes it tractable by freezing the
+backbone and training a small set of added parameters instead.
+
+This framework supports three, plus two escape hatches. Which one a package was exported with is
+recorded in its manifest (`peftMethods`) and readable on device as
+`RuntimeCapabilities.peftMethods` — a package can only be re-trained inside the topology it was
+exported with, so this is a property of the package, not a runtime choice.
+
+| method | `--peft` | trains | merger |
+| --- | --- | --- | --- |
+| [LoRA](#lora) | `lora` | two matrices per target module | yes |
+| [LoRA-XS](#lora-xs) | `lora-xs` | one small matrix per target module | yes |
+| [MARS](#mars-multi-adapter-rank-sharing) | `mars` | one down-projection **shared across layers** | yes |
+| all linear layers | `all` | every linear weight | — |
+| frozen | `nolora` | nothing (export/inference only) | — |
+
+Everything below is a registry row in
+[`config/registry/peft.py`](https://github.com/martinkorelic/mobiletransformers/blob/main/src/mobiletransformers/config/registry/peft.py).
+Adding a method is a row plus an enum member — not a new branch in the exporter.
+
+## LoRA
+
+*Low-Rank Adaptation.* For each targeted linear layer, freeze its weight `W` and learn two small
+matrices `A` (down, `d × r`) and `B` (up, `r × d`), so the layer computes `Wx + BAx`. Only `A` and
+`B` receive gradients.
+
+The trainable count scales with **rank × depth**: every targeted layer gets its own pair. It is the
+default, the best-understood option, and what five of the six published packages use.
+
+## LoRA-XS
+
+A reparameterisation of a LoRA wrap: `A` and `B` are fixed to the SVD of the base weight, and only a
+small `r × r` matrix between them is trained. Fewer trainable parameters than LoRA at the same rank,
+and it shares LoRA's module layout entirely — which is why it reuses the same adapter mapping and the
+same merger.
+
+## MARS (Multi-Adapter Rank Sharing)
+
+**This project's own method**, designed for the phone specifically.
+
+LoRA's cost grows with depth because every layer carries a private `A`. MARS observes that the
+down-projection is the expensive half and that layers do not each need their own: one
+`SharedAttentionAdapter` is shared across the q/k/v projections, and one `SharedMLPAdapter` across
+gate/up — with only the small per-projection parts kept separate.
+
+The result is that **the trainable parameter count grows with rank rather than with depth**. On the
+published `gemma-3-270m-it` package that is **279,936 trainable parameters against a 268M backbone**.
+Fewer trained parameters means a smaller optimiser state, which is the thing that actually decides
+whether a training run fits in a phone's memory — and a smaller adapter to exchange in a
+[federated round](FEDERATED.md).
+
+MARS is the reason `derive_transpose_policy` has to observe tensor orientation rather than assume it:
+its shared components are named differently from LoRA's (`shared_A`, not `adapter_A`), and a
+fail-open default on that name is how a merge once silently transposed every layer.
+
+Try it: [`mobiletransformers/gemma-3-270m-it`](https://huggingface.co/mobiletransformers/gemma-3-270m-it)
+is exported with MARS and is on the app's catalog shelf.
+
+## Merging, and why it matters here
+
+Training produces adapter factors. **Merging** folds them back into the inference weights, on the
+device, so that ordinary generation afterwards comes from the fine-tuned model rather than from an
+adapter applied at runtime.
+
+This is the step that makes an on-device fine-tune real rather than a demonstration, and it is done
+in C++ against the inference graph's own initialisers. Each method declares which merger variant it
+needs (`MergerVariant`), because the arithmetic differs: LoRA and LoRA-XS merge a `B·A` product,
+MARS merges through its shared components.
+
+```kotlin
+val result = model.train(dataset, TrainConfig(mergeAtEnd = true))
+// or explicitly, later:
+model.merge()
+```
+
+## Choosing a method
+
+- **Start with LoRA.** It is the default for a reason: best understood, widest architecture support,
+  and the published packages that are easiest to compare against.
+- **Reach for MARS** when memory is the binding constraint, when the model is deep relative to its
+  width, or when you are exchanging adapters between devices.
+- **LoRA-XS** when you want fewer trainable parameters without leaving LoRA's layout.
+- `all` and `nolora` are not really fine-tuning strategies: `all` is a full-fine-tune baseline for
+  host-side comparison, and `nolora` exports a frozen model for inference only.
+
+Which architectures each method can target is data, not code — see
+[the compatibility matrix](COMPATIBILITY_MATRIX.md), which is generated from the registry.
+
+## Further reading
+
+- [Export a model](EXPORT.md) — `--peft` and the training-stage flags
+- [Package format](MODEL_FORMAT.md) — how adapter tensors are named and where the mapping lives
+- [Federated adapters](FEDERATED.md) — exchanging trained factors between devices
+- [Measured performance](mobile_evaluation.md) — step time and peak RAM on real hardware
diff --git a/docs/on-device-trained.gif b/docs/on-device-trained.gif
deleted file mode 100644
index b786124..0000000
Binary files a/docs/on-device-trained.gif and /dev/null differ
diff --git a/docs/ortransformer-feature.gif b/docs/ortransformer-feature.gif
deleted file mode 100644
index a43a3b5..0000000
Binary files a/docs/ortransformer-feature.gif and /dev/null differ
diff --git a/docs/references.md b/docs/references.md
new file mode 100644
index 0000000..c651745
--- /dev/null
+++ b/docs/references.md
@@ -0,0 +1,46 @@
+# Further reading
+
+## This project
+
+- [Source code on GitHub](https://github.com/martinkorelic/mobiletransformers) — where to get it, and
+  what these docs are built from
+- [The original codebase](https://gitlab.fri.uni-lj.si/lrk/mobiletransformers) — the address the work
+  was published under, and the one the [citation](citation.md) names
+- [Model packages on Hugging Face](https://huggingface.co/mobiletransformers) — six exported
+  packages, each shipping both an inference and a training stage
+- [*Parameter-Efficient Tuning of Large Language Models on Mobile Devices*](https://repozitorij.uni-lj.si/IzpisGradiva.php?lang=eng&id=175561)
+  — the master's thesis this framework accompanies
+
+## Work built on this framework
+
+- Korelič, M. and Pejović, V. — [**AI health agents on mobile**](https://link.springer.com/article/10.1186/s12919-026-00367-3#Sec27),
+  *BMC Proceedings* 2026, 20(12):A7. Presented at EHRCON25, the openEHR International Conference.
+
+    The first on-device Retrieval-Augmented Generation prototype for openEHR-based personal health
+    data, running entirely on a smartphone: a small language model, an embedding model and a vector
+    database of vital signs, medications, allergies and laboratory results, with no network
+    dependency and no records leaving the device. The Android application is built on this
+    framework.
+
+    Two INT4-quantized models were measured on a Pixel 6 CPU — TinyLlama (1.1B) at 0.94 GB and
+    9.04 tokens/second, and Phi-3-mini-4k (3.5B) at 2.7 GB and 3.6 tokens/second — with answer
+    quality judged against cloud LLM responses using G-Eval. It is a useful independent read on what
+    this framework's [measured performance](mobile_evaluation.md) looks like in an applied setting.
+
+## What it is built on
+
+- [ONNX Runtime](https://onnxruntime.ai/) — the inference and **training** engine, on device
+- [ONNX Runtime GenAI](https://github.com/microsoft/onnxruntime-genai) — the alternative generation
+  engine, selectable per package
+- [Optimum](https://huggingface.co/docs/optimum/) — the Hugging Face → ONNX export path
+- [PEFT](https://huggingface.co/docs/peft/) — LoRA and the tuner base MARS is built on
+- [tokenizers-cpp](https://github.com/mlc-ai/tokenizers-cpp) — the on-device tokenizer
+- [ObjectBox](https://objectbox.io/) — the on-device vector store behind [retrieval](RAG.md)
+
+Every third-party component and its licence is listed in
+[`THIRD_PARTY_NOTICES.md`](https://github.com/martinkorelic/mobiletransformers/blob/main/THIRD_PARTY_NOTICES.md).
+
+## Background
+
+- [LoRA: Low-Rank Adaptation of Large Language Models](https://arxiv.org/abs/2106.09685)
+- [LoRA-XS: Low-Rank Adaptation with Extremely Small Number of Parameters](https://arxiv.org/abs/2405.17604)
diff --git a/evaluation/mobile/base_mobile_eval.py b/evaluation/mobile/base_mobile_eval.py
deleted file mode 100644
index 07bea8d..0000000
--- a/evaluation/mobile/base_mobile_eval.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from evaluation.eval_adapter_models import CustomPeftModel
-from evaluation.mobile_evaluator import MobileEvaluator
-
-MINI_PERSONAL_QA_EXAMPLES = [
-    {"type": "train", "category": "App Usage", "question": "What specific method is used by news apps to send me updates?", "choices": {"A": "Push notifications", "B": "Sending a letter", "C": "A town crier", "D": "Email newsletters"}, "correct_answer": "A"},
-    {"type": "train", "category": "Communication & Social", "question": "The text thread with my old college buddies is always buzzing with new messages. Which of my social circles has a particularly lively group chat?", "choices": {"A": "My coworkers", "B": "My college friends", "C": "My high school acquaintances", "D": "My family"}, "correct_answer": "B"},
-    {"type": "train", "category": "Location & Travel", "question": "What type of route do I use for my daily commute to my job?", "choices": {"A": "A scenic bike path", "B": "A local side street", "C": "The highway", "D": "A pedestrian walkway"}, "correct_answer": "C"}
-]
-
-MINI_RECOMMENDATION_EXAMPLES = [
-    {"type": "train", "category": "Energy Management", "prompt": "I feel really tired this evening", "recommendation": "Recommend early sleep, lower lighting"},
-]
-
-def evaluate_base_mini_personalqa():
-    EVAL_DATASET = "data/MiniPersonalQA_eval.jsonl"
-    BASE_MODEL = "Qwen/Qwen2-0.5B-Instruct"
-
-    model = CustomPeftModel("", adapter_name="base", base_model=BASE_MODEL)
-
-    model.set_generation_config(max_new_tokens=10)
-
-    # Create evaluator - tokenizer is optional now
-    evaluator = MobileEvaluator(model)
-
-    # Run evaluation on JSONL file
-    results = evaluator.evaluate(EVAL_DATASET, verbose=True, few_shot_examples=MINI_PERSONAL_QA_EXAMPLES, save_results_dir=".", save_outputs=True)
-
-    # Print results
-    evaluator.print_results(results)
-
-def evaluate_base_mini_recommendation():
-    SLM_MODEL_ID = "Qwen/Qwen2-0.5B-Instruct"
-    EVAL_DATASET = "data/MiniRecommendation_eval.jsonl"
-    TASK = "mini_recommendation"
-
-    model = CustomPeftModel("", adapter_name="base", base_model=SLM_MODEL_ID)
-
-    model.set_generation_config(max_new_tokens=128)
-
-    # Create evaluator - tokenizer is optional now
-    evaluator = MobileEvaluator(model, task=TASK)
-
-    # Run evaluation on JSONL file
-    results = evaluator.evaluate(EVAL_DATASET, verbose=True, save_outputs=True, few_shot_examples=[])
-
-    # Print results
-    evaluator.print_results(results)
-
-evaluate_base_mini_recommendation()
\ No newline at end of file
diff --git a/evaluation/openehr/openehr_eval_plots.py b/evaluation/openehr/openehr_eval_plots.py
deleted file mode 100644
index c95e9e3..0000000
--- a/evaluation/openehr/openehr_eval_plots.py
+++ /dev/null
@@ -1,225 +0,0 @@
-"""
-Script for generating scatter plots comparing faithfulness and clinical quality from OpenEHR evaluation JSON files.
-"""
-
-import json
-import matplotlib.pyplot as plt
-import matplotlib
-
-# Set font parameters for PDF export
-matplotlib.rcParams['pdf.fonttype'] = 42
-matplotlib.rcParams['ps.fonttype'] = 42
-
-# UPDATE THESE WITH YOUR ACTUAL FILES
-model_json_pairs = [
-    ("TinyLlama", "data/ehr_eval/medical_llm_evaluation_tinyllama_complex.json"),
-    ("Phi-3-Mini-4k", "data/ehr_eval/medical_llm_evaluation_phi3_complex.json"),
-]
-
-def load_evaluation_data(model_json_pairs):
-    """
-    Load evaluation data from JSON files.
-    
-    Args:
-        model_json_pairs: List of tuples (slm_model_name, json_file_path)
-    
-    Returns:
-        Dictionary with model names as keys and evaluation data as values
-    """
-    evaluation_data = {}
-    
-    for model_name, json_file in model_json_pairs:
-        try:
-            with open(json_file, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-                evaluation_data[model_name] = data['evaluation_results']
-                print(f"Loaded data for {model_name} from {json_file}")
-        except FileNotFoundError:
-            print(f"Warning: File {json_file} not found for model {model_name}")
-        except KeyError:
-            print(f"Warning: Invalid JSON structure in {json_file} for model {model_name}")
-    
-    return evaluation_data
-
-def create_scatter_plot(evaluation_data, title, filename):
-    """
-    Create a scatter plot showing faithfulness vs clinical quality for all models and contexts.
-    
-    Args:
-        evaluation_data: Dictionary with evaluation results
-        title: Plot title
-        filename: Output filename
-    """
-    # Set up the plot with appropriate figure size
-    fig, ax = plt.subplots(figsize=(10, 7))
-    
-    # Define colors for each model (you can expand this list as needed)
-    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f']
-    
-    # Define markers for document vs chunked
-    document_marker = 'o'  # circle
-    chunked_marker = 's'   # square
-    
-    # Track data for legend
-    model_handles = []
-    context_handles = []
-    
-    # Extract and plot data for each model
-    for i, model in enumerate(evaluation_data.keys()):
-        color = colors[i % len(colors)]
-        
-        # Process document context data
-        if 'slm_vs_llm_document' in evaluation_data[model]:
-            doc_data = evaluation_data[model]['slm_vs_llm_document']
-            doc_faithfulness = doc_data['faithfulness']['average'] * 10  # Scale 0-1 to 0-10
-            doc_clinical = doc_data['clinical_quality']['average'] * 10  # Scale 0-1 to 0-10
-            
-            scatter_doc = ax.scatter(doc_faithfulness, doc_clinical, 
-                                   c=color, marker=document_marker, s=200, 
-                                   alpha=0.8, edgecolors='black', linewidth=1)
-        
-        # Process chunked context data
-        if 'slm_vs_llm_chunked' in evaluation_data[model]:
-            chunk_data = evaluation_data[model]['slm_vs_llm_chunked']
-            chunk_faithfulness = chunk_data['faithfulness']['average'] * 10  # Scale 0-1 to 0-10
-            chunk_clinical = chunk_data['clinical_quality']['average'] * 10  # Scale 0-1 to 0-10
-            
-            scatter_chunk = ax.scatter(chunk_faithfulness, chunk_clinical, 
-                                     c=color, marker=chunked_marker, s=200, 
-                                     alpha=0.8, edgecolors='black', linewidth=1)
-    
-    # Customize the plot with larger fonts
-    ax.set_xlabel('Faithfulness Score (0-10)', fontsize=16, fontweight='bold')
-    ax.set_ylabel('Clinical Quality Score (0-10)', fontsize=16, fontweight='bold')
-    ax.set_title(title, fontsize=18, fontweight='bold', pad=20)
-    
-    # Set axis limits and ticks
-    ax.set_xlim(0, 10)
-    ax.set_ylim(0, 10)
-    ax.set_xticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    ax.set_yticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    ax.tick_params(axis='both', which='major', labelsize=16)
-    
-    # Add grid for better readability
-    ax.grid(True, alpha=0.3)
-    ax.set_axisbelow(True)
-    
-    # Create custom legend
-    # Legend for context types
-    from matplotlib.lines import Line2D
-    context_legend_elements = [
-        Line2D([0], [0], marker=document_marker, color='gray', linestyle='None',
-               markersize=12, markerfacecolor='gray', markeredgecolor='black',
-               label='Document Context'),
-        Line2D([0], [0], marker=chunked_marker, color='gray', linestyle='None',
-               markersize=12, markerfacecolor='gray', markeredgecolor='black',
-               label='Chunked Context')
-    ]
-    
-    # Legend for models
-    model_legend_elements = []
-    for i, model in enumerate(evaluation_data.keys()):
-        color = colors[i % len(colors)]
-        model_legend_elements.append(
-            Line2D([0], [0], marker='o', color='white', linestyle='None',
-                   markersize=12, markerfacecolor=color, markeredgecolor='black',
-                   label=model)
-        )
-    
-    # Create two separate legends
-    context_legend = ax.legend(handles=context_legend_elements, 
-                              title='Context Type', title_fontsize=14, fontsize=12,
-                              loc='upper right', bbox_to_anchor=(1.45, 1.0))
-    context_legend.get_title().set_fontweight('bold')
-    
-    model_legend = ax.legend(handles=model_legend_elements, 
-                           title='Models', title_fontsize=14, fontsize=12,
-                           loc='upper right', bbox_to_anchor=(1.45, 0.7))
-    model_legend.get_title().set_fontweight('bold')
-    
-    # Add the first legend back (matplotlib removes it when adding the second)
-    ax.add_artist(context_legend)
-    
-    # Add reference lines at common thresholds
-    ax.axhline(y=7.0, color='red', linestyle='--', alpha=0.5, linewidth=1)
-    ax.axvline(x=9.0, color='blue', linestyle='--', alpha=0.5, linewidth=1)
-    
-    # Add threshold labels
-    ax.text(0.2, 7.2, 'Clinical Quality Threshold', fontsize=12, 
-            color='red', alpha=0.7, fontweight='bold')
-    ax.text(9.2, 0.5, 'Faithfulness Threshold', fontsize=12, 
-            color='blue', alpha=0.7, fontweight='bold', rotation=90)
-    
-    # Adjust layout and save
-    plt.tight_layout()
-    plt.savefig(filename, format='pdf', dpi=300, bbox_inches='tight')
-    plt.show()
-    
-    # Print summary statistics
-    print(f"\n{title} - Summary Statistics:")
-    print("-" * 60)
-    for model in evaluation_data.keys():
-        print(f"{model}:")
-        
-        if 'slm_vs_llm_document' in evaluation_data[model]:
-            doc_data = evaluation_data[model]['slm_vs_llm_document']
-            doc_faithfulness = doc_data['faithfulness']['average'] * 10
-            doc_clinical = doc_data['clinical_quality']['average'] * 10
-            print(f"  Document Context - Faithfulness: {doc_faithfulness:.2f}, Clinical Quality: {doc_clinical:.2f}")
-        
-        if 'slm_vs_llm_chunked' in evaluation_data[model]:
-            chunk_data = evaluation_data[model]['slm_vs_llm_chunked']
-            chunk_faithfulness = chunk_data['faithfulness']['average'] * 10
-            chunk_clinical = chunk_data['clinical_quality']['average'] * 10
-            print(f"  Chunked Context  - Faithfulness: {chunk_faithfulness:.2f}, Clinical Quality: {chunk_clinical:.2f}")
-        
-        print()
-
-def main():
-    """
-    Main function to generate scatter plot from evaluation JSON files.
-    """
-    print("Medical LLM Evaluation Results - Scatter Plot Generation")
-    print("=" * 60)
-    
-    # Load evaluation data
-    evaluation_data = load_evaluation_data(model_json_pairs)
-    
-    if not evaluation_data:
-        print("No evaluation data loaded. Please check your file paths.")
-        return
-    
-    # Create scatter plot
-    print(f"\nGenerating scatter plot for {len(evaluation_data)} models...")
-    
-    create_scatter_plot(
-        evaluation_data=evaluation_data,
-        title='SLM Performance: Faithfulness vs Clinical Quality Comparison',
-        filename='slm_performance_scatter_plot.pdf'
-    )
-    
-    print("\nScatter plot generated successfully!")
-    print("File created: slm_performance_scatter_plot.pdf")
-
-def plot_evaluation_results(model_json_pairs):
-    """
-    Convenient function to plot results with custom model-json pairs.
-    
-    Args:
-        model_json_pairs: List of tuples (model_name, json_file_path)
-    """
-    evaluation_data = load_evaluation_data(model_json_pairs)
-    
-    if not evaluation_data:
-        print("No evaluation data loaded. Please check your file paths.")
-        return
-    
-    # Create scatter plot
-    create_scatter_plot(
-        evaluation_data=evaluation_data,
-        title='SLM Performance: Faithfulness vs Clinical Quality Comparison',
-        filename='slm_performance_scatter_plot.pdf'
-    )
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/examples/consumer-app/README.md b/examples/consumer-app/README.md
new file mode 100644
index 0000000..2c2d492
--- /dev/null
+++ b/examples/consumer-app/README.md
@@ -0,0 +1,27 @@
+# Consumer app example
+
+A minimal external project that resolves the MobileTransformers SDK **as a published Maven artifact**,
+not as a source module. It exists to prove the publication contract: if this builds, an outside
+consumer can depend on the AAR.
+
+## Use
+
+```bash
+# 1. publish the SDK to your local Maven repository
+scripts/publish_local_maven.sh
+
+# 2. build this project against it
+cd examples/consumer-app && ./gradlew assembleDebug
+```
+
+`settings.gradle.kts` puts `mavenLocal()` first so the freshly published artifact wins over any remote.
+
+## What it checks
+
+- The published POM resolves and drags in the SDK's transitive dependencies.
+- The public facade (`MobileTransformers.fromPretrained`, `MobileTransformerModel`) is visible to an
+  outside module — i.e. nothing public is accidentally `internal`.
+- The AAR carries `libmobiletransformers.so` for the consumer's ABI.
+
+It deliberately does **not** run a model: that needs a package on a device and belongs to the
+instrumented suite.
diff --git a/examples/consumer-app/app/build.gradle.kts b/examples/consumer-app/app/build.gradle.kts
new file mode 100644
index 0000000..89c908b
--- /dev/null
+++ b/examples/consumer-app/app/build.gradle.kts
@@ -0,0 +1,34 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.example.consumer"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "com.example.consumer"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+        ndk {
+            // Only ABIs the published AAR actually carries libmobiletransformers.so for.
+            abiFilters += listOf("arm64-v8a")
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions { jvmTarget = "1.8" }
+}
+
+dependencies {
+    // The whole point of this example: a plain Maven coordinate, no project(":...") dependency.
+    implementation(
+        "com.martinkorelic.mobiletransformers:mobiletransformers-android:" +
+            "${project.findProperty("mobiletransformersVersion")}"
+    )
+}
diff --git a/examples/consumer-app/app/src/main/AndroidManifest.xml b/examples/consumer-app/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..77ae4bd
--- /dev/null
+++ b/examples/consumer-app/app/src/main/AndroidManifest.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <application android:label="MobileTransformers consumer" />
+</manifest>
diff --git a/examples/consumer-app/app/src/main/java/com/example/consumer/ConsumerCheck.kt b/examples/consumer-app/app/src/main/java/com/example/consumer/ConsumerCheck.kt
new file mode 100644
index 0000000..15c70cf
--- /dev/null
+++ b/examples/consumer-app/app/src/main/java/com/example/consumer/ConsumerCheck.kt
@@ -0,0 +1,33 @@
+package com.example.consumer
+
+import android.content.Context
+import com.martinkorelic.mobiletransformers.MobileTransformerModel
+import com.martinkorelic.mobiletransformers.MobileTransformers
+import com.martinkorelic.mobiletransformers.config.GenerationConfig
+import com.martinkorelic.mobiletransformers.packages.ModelFeature
+import com.martinkorelic.mobiletransformers.runtime.InferenceEngine
+
+/**
+ * Compile-time proof that the published AAR exposes a usable public surface to an outside module.
+ *
+ * If any symbol here stops resolving, something public became `internal` (or moved) — a SemVer break
+ * that no in-repo test would catch, because in-repo callers can see `internal` declarations.
+ *
+ * Nothing here runs: loading a model needs a package on a device.
+ */
+object ConsumerCheck {
+
+    suspend fun load(context: Context, repoId: String): MobileTransformerModel =
+        MobileTransformers.fromPretrained(
+            context = context,
+            repoId = repoId,
+            features = setOf(ModelFeature.Inference),
+            engine = InferenceEngine.NATIVE,
+        )
+
+    suspend fun generate(model: MobileTransformerModel, prompt: String): String =
+        model.generate(prompt, GenerationConfig(maxNewTokens = 32)).text
+
+    fun describe(model: MobileTransformerModel): String =
+        "engine=${model.engine} features=${model.installedFeatures} repo=${model.repoId}"
+}
diff --git a/examples/consumer-app/build.gradle.kts b/examples/consumer-app/build.gradle.kts
new file mode 100644
index 0000000..18a8dea
--- /dev/null
+++ b/examples/consumer-app/build.gradle.kts
@@ -0,0 +1,4 @@
+plugins {
+    id("com.android.application") version "8.5.1" apply false
+    id("org.jetbrains.kotlin.android") version "1.9.0" apply false
+}
diff --git a/examples/consumer-app/gradle.properties b/examples/consumer-app/gradle.properties
new file mode 100644
index 0000000..d4b3407
--- /dev/null
+++ b/examples/consumer-app/gradle.properties
@@ -0,0 +1,5 @@
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+# The SDK version to resolve. Keep in step with the repository's pyproject.toml version.
+mobiletransformersVersion=0.2.0
diff --git a/android/ORTransformer/gradle/libs.versions.toml b/examples/consumer-app/gradle/libs.versions.toml
similarity index 71%
rename from android/ORTransformer/gradle/libs.versions.toml
rename to examples/consumer-app/gradle/libs.versions.toml
index adca1ac..42367c3 100644
--- a/android/ORTransformer/gradle/libs.versions.toml
+++ b/examples/consumer-app/gradle/libs.versions.toml
@@ -5,6 +5,8 @@ gson = "2.11.0"
 kotlin = "1.9.0"
 coreKtx = "1.13.1"
 junit = "4.13.2"
+# Robolectric 4.12.x targets AGP 8.x / JDK 17 and provides Android SDK 34 stubs.
+robolectric = "4.12.2"
 junitVersion = "1.2.1"
 espressoCore = "3.6.1"
 appcompat = "1.7.0"
@@ -14,6 +16,10 @@ lifecycleRuntimeKtx = "2.8.4"
 composeBom = "2024.04.01"
 pebble = "3.2.2"
 objectbox = "4.3.0"
+okhttp = "4.12.0"
+work = "2.9.1"
+coroutines = "1.8.1"
+testRunner = "1.6.2"
 
 [libraries]
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activityCompose" }
@@ -36,6 +42,14 @@ androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-man
 androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
 pebble = { module = "io.pebbletemplates:pebble", version.ref = "pebble" }
 objectbox-android = { group = "io.objectbox", name = "objectbox.android", version.ref = "objectbox" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
+androidx-work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
diff --git a/examples/consumer-app/gradle/wrapper/gradle-wrapper.jar b/examples/consumer-app/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..e708b1c
Binary files /dev/null and b/examples/consumer-app/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/examples/consumer-app/gradle/wrapper/gradle-wrapper.properties b/examples/consumer-app/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..5307d8b
--- /dev/null
+++ b/examples/consumer-app/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Mon Aug 19 13:05:22 CEST 2024
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/examples/consumer-app/gradlew b/examples/consumer-app/gradlew
new file mode 100755
index 0000000..4f906e0
--- /dev/null
+++ b/examples/consumer-app/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/examples/consumer-app/gradlew.bat b/examples/consumer-app/gradlew.bat
new file mode 100644
index 0000000..ac1b06f
--- /dev/null
+++ b/examples/consumer-app/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/examples/consumer-app/settings.gradle.kts b/examples/consumer-app/settings.gradle.kts
new file mode 100644
index 0000000..dd4471a
--- /dev/null
+++ b/examples/consumer-app/settings.gradle.kts
@@ -0,0 +1,20 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        google()
+        mavenCentral()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        // mavenLocal() FIRST: this example exists to consume the artifact just published by
+        // scripts/publish_local_maven.sh, so it must win over any remote of the same coordinates.
+        mavenLocal()
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "mobiletransformers-consumer"
+include(":app")
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000..9fbf4e6
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,109 @@
+# The documentation site, built from this repository's own `docs/` directory.
+#
+# WHY IT LIVES HERE. The site used to be a separate repository holding its own copy of the docs. That
+# copy drifted: by the time it was folded back in it described module paths that no longer existed
+# (`trainer.builder`), an ABI the project does not ship, and an install route through a Google Drive
+# folder — while none of the 16 pages under `docs/` had ever been published. One tree, one source of
+# truth, and an "edit this page" link on every page back to the file that produced it.
+#
+# `mkdocs build --strict` turns an unresolved internal link into a build failure, and `make docs` runs
+# it. That is the structural half of the fix; this file is the other half.
+
+site_name: MobileTransformers
+site_description: On-Device LLM PEFT Fine-Tuning and Inference Framework
+site_author: Martin Korelič
+site_url: https://martinkorelic.github.io/mobiletransformers/
+
+repo_name: martinkorelic/mobiletransformers
+repo_url: https://github.com/martinkorelic/mobiletransformers
+edit_uri: edit/main/docs/
+
+theme:
+  name: material
+  logo: assets/mobiletransformers_logo.png
+  favicon: assets/mobiletransformers_logo.png
+  palette:
+    - scheme: default
+      primary: indigo
+      accent: indigo
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - scheme: slate
+      primary: indigo
+      accent: indigo
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.top
+    - navigation.indexes
+    - toc.integrate
+    - search.suggest
+    - search.highlight
+    - content.code.copy
+    # Every page carries a link to the file it was rendered from. This is what stops the site and the
+    # repository drifting apart again: a wrong page is one click from the place to fix it.
+    - content.action.edit
+
+nav:
+  - Start here:
+      - Overview: index.md
+      - Getting started: getting-started.md
+      - A tour of the app: SHOWCASE.md
+      - The model shelf: CATALOG.md
+  - Android SDK:
+      - Using the SDK: ANDROID_SDK.md
+      - Cookbook: COOKBOOK.md
+      - Public API: PUBLIC_API.md
+      - On-device cache format: ANDROID_CACHE_FORMAT.md
+  - Exporting models:
+      - Export a model: EXPORT.md
+      - Package format: MODEL_FORMAT.md
+      - Hub package format: HUB_PACKAGE_FORMAT.md
+      - Compatibility matrix: COMPATIBILITY_MATRIX.md
+  - Capabilities:
+      - PEFT methods: on-device-peft.md
+      - Retrieval (RAG): RAG.md
+      - Federated adapters: FEDERATED.md
+      - Measured performance: mobile_evaluation.md
+  - Reference:
+      - Architecture: ARCHITECTURE.md
+      - Configuration: CONFIGURATION.md
+      - Release checklist: RELEASE_CHECKLIST.md
+      - Citation: citation.md
+      - Further reading: references.md
+
+# Maintenance notes, not pages. Listed so `--strict` does not fail on files that are deliberately
+# outside the nav rather than accidentally missing from it.
+not_in_nav: |
+  assets/README.md
+
+markdown_extensions:
+  - admonition
+  - tables
+  - toc:
+      permalink: true
+  - pymdownx.superfences
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.inlinehilite
+  - pymdownx.tabbed:
+      alternate_style: true
+  - attr_list
+  - md_in_html
+
+plugins:
+  - search
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/martinkorelic/mobiletransformers
+    - icon: fontawesome/brands/python
+      link: https://huggingface.co/mobiletransformers
+      name: Model packages on Hugging Face
+    - icon: fontawesome/brands/linkedin
+      link: https://www.linkedin.com/in/martin-koreli%C4%8D/
diff --git a/peft_models/ablation/utils.py b/peft_models/ablation/utils.py
deleted file mode 100644
index eedd766..0000000
--- a/peft_models/ablation/utils.py
+++ /dev/null
@@ -1,18 +0,0 @@
-TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING = {
-    "t5": ["q", "k", "v", "o", "wi", "wo"],
-    "mt5": ["q", "k", "v", "o", "wi_0", "wi_1", "wo"],
-    "bart": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
-    "gpt2": ["c_attn"],
-    "bloom": ["query_key_value"],
-    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
-    "gptj": ["q_proj", "v_proj"],
-    "gpt_neox": ["query_key_value"],
-    "gpt_neo": ["q_proj", "v_proj"],
-    "llama": ["q_proj", "v_proj"],
-    "bert": ["query", "value"],
-    "roberta": ["query", "value"],
-    "deberta-v2": ["query_proj", "key_proj", "value_proj", "dense"],
-    "gpt_bigcode": ["c_attn"],
-    "deberta": ["in_proj"],
-    "qwen2": ["q_proj", "v_proj"],
-}
\ No newline at end of file
diff --git a/peft_models/lora_xs/svd_utils.py b/peft_models/lora_xs/svd_utils.py
deleted file mode 100644
index 874eee5..0000000
--- a/peft_models/lora_xs/svd_utils.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from sklearn.decomposition import TruncatedSVD
-import numpy as np
-from typing import Tuple
-
-
-def run_svd(input_matrix: np.ndarray, rank: int, n_iter: int, random_state: int) -> Tuple[np.ndarray, TruncatedSVD]:
-    svd = TruncatedSVD(n_components=rank, n_iter=n_iter, random_state=random_state)
-    svd.fit(input_matrix)
-    reduced_matrix = svd.transform(input_matrix)
-    return reduced_matrix, svd
-
-
-def get_linear_rec_svd(input_matrix: np.ndarray, rank: int, n_iter: int,
-                       random_state: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    reduced_matrix, svd = run_svd(input_matrix, rank, n_iter, random_state)
-
-    reconstructed_matrix = svd.inverse_transform(reduced_matrix)
-    return reconstructed_matrix, reduced_matrix, svd.components_
diff --git a/peft_models/mars/model.py b/peft_models/mars/model.py
deleted file mode 100644
index 716dfd1..0000000
--- a/peft_models/mars/model.py
+++ /dev/null
@@ -1,507 +0,0 @@
-import os
-import warnings
-from peft.config import PeftConfig
-from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
-import torch
-from torch.nn.modules import Module
-from safetensors.torch import save_file
-
-from .layer import Linear, MarsLayer, SharedAttentionAdapter, SharedMLPAdapter
-from .utils import TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING
-
-class MarsModel(BaseTuner):
-    """
-    PEFT model implementing the MARS (Multi-Adapter Rank Sharing) adapter technique on base models.
-    """
-
-
-    prefix: str = "mars"
-
-    def __init__(self, model, peft_config: PeftConfig | dict[str, PeftConfig], adapter_name: str = "mars", low_cpu_mem_usage: bool = False) -> None:
-
-        # Pre-initialization
-        if peft_config[adapter_name].shared_r is None:
-             peft_config[adapter_name].shared_r =  peft_config[adapter_name].r
-
-        self.trainable_down = True
-        self.optimization_level =  peft_config[adapter_name].optimization_level
-        self.only_export = peft_config[adapter_name].onnx_export
-        self.quant_n_bits = peft_config[adapter_name].quant_n_bits
-        self.use_bnb = peft_config[adapter_name].use_bnb
-
-        # Based on optimization level set configurations
-        if  peft_config[adapter_name].optimization_level == 0:
-            self.trainable_down = True
-        elif  peft_config[adapter_name].optimization_level == 1:
-            self.trainable_down = False
-        elif  peft_config[adapter_name].optimization_level == 2:
-            self.trainable_down = True
-        elif  peft_config[adapter_name].optimization_level == 3:
-            self.trainable_down = True
-        elif  peft_config[adapter_name].optimization_level == 4:
-            self.trainable_down = False
-
-        super().__init__(model, peft_config, adapter_name, low_cpu_mem_usage)
-
-    def _pre_injection_hook(self, model: Module, config: PeftConfig, adapter_name: str) -> None:
-
-        enabled_qkv = getattr(config, "enabled_qkv", ("q", "k", "v"))
-
-        # Map enabled projections to indices in tuple
-        enabled_list = list(enabled_qkv)
-
-        # TODO: Check modules if they are even in target_modules
-        any_mlp = any([ 'gate_proj' in tm or 'up_proj' in tm for tm in config.target_modules])
-        any_qkv = any([ 'q_proj' in tm or 'k_proj' in tm or 'v_proj' in tm for tm in config.target_modules])
- 
-        # Register hooks for each attention layer
-        for name, module in model.named_modules():
-
-            # TODO: Here we assume the attention layer is named "self_attn"
-            if isinstance(module, type(model.model.layers[0].self_attn)) and any_qkv:
-
-                # Create a separate shared adapter for each attention layer
-                module.shared_qkv = SharedAttentionAdapter(
-                    hidden_size=model.config.hidden_size,
-                    rank=config.r,
-                    shared_rank=config.shared_r,
-                    alpha=config.alpha,
-                    enabled=enabled_list
-                )
-                
-                # Compute shared outputs once and store them
-                def compute_shared_qkv(module, args, kwargs):
-                    
-                    # TODO: Could have args or kwargs where hidden states are, this might depend on architecture
-                    
-                    # Compute shared outputs only once
-                    qkv_outputs = module.shared_qkv(kwargs['hidden_states'])
-                    # Store them in the module for the projection layers to use
-
-                    module.shared_qkv._shared_outputs = qkv_outputs
-                    return None
-                
-                # Register the hook on the attention layer to compute shared outputs once
-                module.register_forward_pre_hook(compute_shared_qkv, with_kwargs=True)
-
-                def pass_qkv_inputs(module, args):
-                    if module is None or not hasattr(module, 'shared_qkv'):
-                        return args
-
-                    shared_outputs = getattr(module.shared_qkv, "_shared_outputs", None)
-                    if shared_outputs is None:
-                        return args
-
-                    # Get the specific output for this projection type
-                    if module.projection_type not in shared_outputs:
-                        return args
-
-                    shared_output = shared_outputs[module.projection_type]
-                    
-                    # Delete the specific key to free memory
-                    del module.shared_qkv._shared_outputs[module.projection_type]
-                    
-                    # Optional: Clean up the entire dict when empty
-                    if not module.shared_qkv._shared_outputs:
-                        del module.shared_qkv._shared_outputs
-
-                    # Return original input paired with shared output
-                    return (shared_output,) + args
-                
-                # Helper to assign proj attrs and register pre-hook if enabled
-                def register_proj_hook(proj_name, proj_type):
-                    proj = getattr(module, proj_name, None)
-                    if proj is None:
-                        return
-                    if proj_type not in enabled_qkv:
-                        return
-                    proj.projection_type = proj_type
-                    proj.register_forward_pre_hook(pass_qkv_inputs)
-                
-                
-                # Register hooks for projections only if enabled
-                register_proj_hook('q_proj', 'q')
-                register_proj_hook('k_proj', 'k')
-                register_proj_hook('v_proj', 'v')
-
-            elif isinstance(module, type(model.model.layers[0].mlp)) and any_mlp:
-                module.shared_mlp = SharedMLPAdapter(
-                    hidden_size=model.config.hidden_size,
-                    rank=config.r,
-                    shared_rank=config.shared_r,
-                    alpha=config.alpha
-                )
-
-                # Compute shared outputs once and store them
-                def compute_shared_mlp(module, args, kwargs):
-                    
-                    # TODO: Could have args or kwargs where hidden states are, this might depend on architecture
-
-                    # Compute shared outputs only once
-                    gate_out, up_out = module.shared_mlp(args[0])
-                    # Store them in the module for the projection layers to use
-                    module.shared_mlp._shared_outputs = {
-                        'gate': gate_out,
-                        'up': up_out
-                    }
-                    return None
-                
-                # Register the hook on the attention layer to compute shared outputs once
-                module.register_forward_pre_hook(compute_shared_mlp, with_kwargs=True)
-
-                # Register forward pre-hooks for each projection to pass both inputs
-                def pass_mlp_inputs(module, args):
-
-                    # Get the appropriate shared output based on the projection type
-                    if module.projection_type == 'gate':
-                        shared_output = module.shared_mlp._shared_outputs['gate']
-                        del module.shared_mlp._shared_outputs['gate']
-                    elif module.projection_type == 'up':
-                        shared_output = module.shared_mlp._shared_outputs['up']
-                        del module.shared_mlp._shared_outputs['up']
-                    else:
-                        return args
-                    
-                    # Return modified args and kwargs
-                    return (shared_output,) + args
-                
-                # Register the pre-hooks on the projection layers
-                module.gate_proj.register_forward_pre_hook(pass_mlp_inputs)
-                module.up_proj.register_forward_pre_hook(pass_mlp_inputs)
-
-    def _create_and_replace(
-        self,
-        mars_config,
-        adapter_name,
-        target,
-        target_name,
-        parent,
-        current_key,
-        **kwargs
-    ):
-        if current_key is None:
-            raise ValueError("Current Key shouldn't be `None`")
-        
-        # TODO: Add tqdm to this function and class
-        # Print out what will be needed for the layer creation (creating quantization, preserving errors...)
-
-        # Get rank and alpha from config
-        r = mars_config.r
-        alpha = mars_config.alpha
-
-        projection_type = None
-        quantize_base = False
-        preserve_errors = False
-        is_standalone = True
-
-        if 'q_proj' in target_name:
-            projection_type = 'q'
-        elif 'k_proj' in target_name:
-            projection_type = 'k'
-        elif 'v_proj' in target_name:
-            projection_type = 'v'
-        elif 'gate_proj' in target_name:
-            projection_type = 'gate'
-        elif 'up_proj' in target_name:
-            projection_type = 'up'
-        elif 'o_proj' in target_name:
-            projection_type = 'o'
-        elif 'down_proj' in target_name:
-            projection_type = 'down'
-
-        self.validate_preserve_errors(mars_config)
-
-        # Determine if adapter is shared or standalone
-        if projection_type in mars_config.enabled_qkv:
-            is_standalone = False
-        elif mars_config.enabled_mlp and projection_type in ['gate', 'up']:
-            is_standalone = False
-
-        # Determine if adapter needs base layer quantization or not
-        # By default optimization level has full quantization of base layers
-        if self.optimization_level > 1:
-            quantize_base = True
-            if mars_config.modules_to_preserve_errors and projection_type in mars_config.modules_to_preserve_errors:
-                preserve_errors = True
-        # Else if partial quantization only quantize those layers specified
-        elif self.optimization_level == 1:
-            if mars_config.modules_to_quantize and projection_type in mars_config.modules_to_quantize: 
-                quantize_base = True
-                if mars_config.modules_to_preserve_errors and projection_type in mars_config.modules_to_preserve_errors:
-                    preserve_errors = True
-
-        module_config = {}
-
-        module_config['target_name'] = target_name
-        module_config['is_standalone'] = is_standalone
-        module_config['shared_rank'] = mars_config.shared_r
-        module_config['preserve_errors'] = preserve_errors
-        module_config['quantize_base'] = quantize_base
-        module_config['trainable_down'] = self.trainable_down
-        module_config['onnx_export'] = self.only_export
-        module_config['quant_n_bits'] = self.quant_n_bits
-        module_config['use_bnb'] = self.use_bnb
-
-        if isinstance(target, Linear):
-            target.update_layer(
-                adapter_name,
-                r,
-                alpha,
-                projection_type,
-                **module_config
-            )
-        else:
-            new_module = self._create_new_module(
-                mars_config,
-                adapter_name,
-                target,
-                r,
-                alpha,
-                projection_type,
-                **module_config
-            )
-
-            if adapter_name not in self.active_adapter:
-                new_module.requires_grad_(False)
-
-            self._replace_module(parent, target_name, new_module, target)
-    
-    @staticmethod
-    def _replace_module(parent, child_name, new_module, child):
-
-        projection_type = None
-
-        if any(proj in child_name for proj in ['q_proj', 'k_proj', 'v_proj']):
-            projection_type = 'qkv'
-        elif any(proj in child_name for proj in ['gate_proj', 'up_proj']):
-            projection_type = 'mlp'
-
-        forward_hooks = {}
-        forward_pre_hooks = {}
-
-        if hasattr(child, '_forward_hooks'):
-            forward_hooks = child._forward_hooks.copy()
-            child._forward_hooks.clear()  # Remove hooks from original module
-
-        if hasattr(child, '_forward_pre_hooks'):
-            forward_pre_hooks = child._forward_pre_hooks.copy()
-            child._forward_pre_hooks.clear()  # Remove hooks from original module
-
-        setattr(parent, child_name, new_module)
-        
-        # child layer wraps the original module, unpack it
-        if hasattr(child, "base_layer"):
-            child = child.base_layer
-
-        if not hasattr(new_module, "base_layer"):
-            new_module.weight = child.weight
-            if hasattr(child, "bias"):
-                new_module.bias = child.bias
-
-        if getattr(child, "state", None) is not None:
-            if hasattr(new_module, "base_layer"):
-                new_module.base_layer.state = child.state
-            else:
-                new_module.state = child.state
-
-            new_module.to(child.weight.device)
-            
-
-        # Transfer hooks to the new module
-        if hasattr(new_module, '_forward_hooks'):
-            new_module._forward_hooks.update(forward_hooks)
-        if hasattr(new_module, '_forward_pre_hooks'):
-            new_module._forward_pre_hooks.update(forward_pre_hooks)
-
-        # Set up shared QKV reference
-        if projection_type == 'qkv' and hasattr(parent, 'shared_qkv'):
-            new_module.shared_qkv = parent.shared_qkv
-
-            # If dequantized module, then update the shared QKV
-            if new_module.preserve_errors:
-                new_module.shared_qkv._update_layer(new_module.svd_U, new_module.svd_S, new_module.projection_type)
-                new_module.clear_svd_components()
-        
-        # Set up shared MLP reference
-        if projection_type == 'mlp' and hasattr(parent, 'shared_mlp'):
-            new_module.shared_mlp = parent.shared_mlp
-            
-            # If dequantized module, then update the shared MLP
-            if new_module.preserve_errors:
-                new_module.shared_mlp._update_layer(new_module.svd_U, new_module.svd_S, new_module.projection_type)
-                new_module.clear_svd_components()
-
-        meta = torch.device("meta")
-        # dispatch to correct device
-        for name, module in new_module.named_modules():
-            if "mars" in name:
-                if not any(p.device == meta for p in module.parameters()):
-                    module.to(child.weight.device)
-
-    @staticmethod
-    def _create_new_module(mars_config, adapter_name, target, rank, alpha, projection_type, **kwargs):
-        if isinstance(target, BaseTunerLayer):
-            target_base_layer = target.get_base_layer()
-        else:
-            target_base_layer = target
-
-        if isinstance(target_base_layer, torch.nn.Linear):
-            if "fan_in_fan_out" in kwargs:
-                warnings.warn(
-                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
-                    "Setting fan_in_fan_out to False."
-                )
-                kwargs["fan_in_fan_out"] = False
-        else:
-            raise ValueError(
-                f"Target module {target} is not supported. Currently, only the following modules are supported: "
-                "`torch.nn.Linear`"
-            )
-        
-        new_module = Linear(
-            base_layer=target,
-            adapter_name=adapter_name,
-            r=rank,
-            alpha=alpha,
-            projection_type=projection_type,
-            mixture=mars_config.mixture,
-            **kwargs
-        )
-
-        return new_module
-    
-    @staticmethod
-    def _check_target_module_exists(mars_config, key):
-        return check_target_module_exists(mars_config, key)
-
-    @staticmethod
-    def _prepare_adapter_config(peft_config, model_config):
-        if peft_config.target_modules is None:
-            if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING:
-                raise ValueError("Please specify `target_modules` in `peft_config`")
-            peft_config.target_modules = set(
-                TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING[model_config["model_type"]]
-            )
-        return peft_config
-    
-    def validate_preserve_errors(self, mars_config):
-        if mars_config.modules_to_preserve_errors is None:
-            return
-
-        qkv_errors = {'q', 'k', 'v'}
-        mlp_errors = {'gate', 'down'}
-
-        # Validate QKV
-        if mars_config.enabled_qkv:
-            present_qkv = [x for x in mars_config.modules_to_preserve_errors if x in qkv_errors]
-            if len(present_qkv) > 1:
-                raise ValueError(
-                    f"Only one of ['q', 'k', 'v'] can be in `modules_to_preserve_errors` when shared QKV is enabled. Found: {present_qkv}"
-                )
-
-        # Validate MLP
-        if mars_config.enabled_mlp:
-            present_mlp = [x for x in mars_config.modules_to_preserve_errors if x in mlp_errors]
-            if len(present_mlp) > 1:
-                raise ValueError(
-                    f"Only one of ['gate', 'down'] can be in `modules_to_preserve_errors` when shared MLP is enabled. Found: {present_mlp}"
-                )
-
-    def _mark_only_adapters_as_trainable(self, model: torch.nn.Module) -> None:
-        """Mark only adapter parameters as trainable."""
-        for n, p in model.named_parameters():
-            
-            # If no adapter prefix in name
-            if (self.prefix not in n):
-                p.requires_grad = False
-
-            # if we don't want trainable down projection
-            if not self.trainable_down and self.prefix in n and any([m_name in n for m_name in ['down_project', 'shared_qkv', 'shared_mlp']]):
-                p.requires_grad = False
-
-        for active_adapter in self.active_adapters:
-            bias = self.peft_config[active_adapter].bias
-            if bias == "none":
-                continue
-            if bias == "all":
-                for n, p in model.named_parameters():
-                    if "bias" in n:
-                        p.requires_grad = True
-            elif bias == "mars_only":
-                for m in model.modules():
-                    if isinstance(m, MarsLayer) and hasattr(m, "bias") and m.bias is not None:
-                        m.bias.requires_grad = True
-            else:
-                raise NotImplementedError(f"Requested bias: {bias}, is not implemented.")
-    
-    def set_adapter(self, adapter_name):
-        for module in self.model.modules():
-            if isinstance(module, MarsLayer):
-                if module.merged:
-                    warnings.warn("Adapter cannot be set when the model is merged. Unmerging the model first.")
-                    module.unmerge()
-                module.set_adapter(adapter_name)
-        self.active_adapter = adapter_name
-
-    def enable_adapter_layers(self) -> None:
-        """Enable all adapters.
-        
-        Call this if you have previously disabled all adapters and want to re-enable them.
-        """
-        self._set_adapter_layers(enabled=True)
-
-    def disable_adapter_layers(self) -> None:
-        """Disable all adapters.
-        
-        When disabling all adapters, the model output corresponds to the output of the base model.
-        """
-        for active_adapter in self.active_adapters:
-            val = self.peft_config[active_adapter].bias
-            if val != "none":
-                msg = (
-                    f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same "
-                    "output as the the base model would without adaption."
-                )
-                warnings.warn(msg)
-        self._set_adapter_layers(enabled=False)
-
-    def _set_adapter_layers(self, enabled=True):
-        """Set the enabled state of all adapter layers."""
-        for module in self.model.modules():
-            if isinstance(module, MarsLayer):
-                module.disable_adapters = not enabled
-
-    def save_pretrained(self, save_directory: str, safe_serialization: bool = True) -> None:
-        """Save the trainable adapter weights of the MarsModel.
-        
-        Args:
-            save_directory (str): Directory where the adapter model and configuration files will be saved.
-            safe_serialization (bool, optional): Whether to save in safetensors format. Defaults to True.
-        """
-        if os.path.isfile(save_directory):
-            raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
-
-        os.makedirs(save_directory, exist_ok=True)
-
-        # Collect trainable adapter weights
-        adapter_weights = {
-            name: param.clone().detach().cpu()
-            for name, param in self.model.named_parameters()
-            if self.prefix in name
-        }
-
-        if not adapter_weights:
-            warnings.warn("No trainable Mars adapters found. Nothing to save.")
-
-        # Save weights
-        file_path = os.path.join(save_directory, "adapter_model.safetensors")
-        if safe_serialization:
-            save_file(adapter_weights, file_path, metadata={"format": "pt"})
-        else:
-            torch.save(adapter_weights, file_path.replace(".safetensors", ".pt"))
-
-        # Save adapter configuration
-        for adapter_name, config in self.peft_config.items():
-            config.save_pretrained(save_directory)
-
-        print(f"Mars adapters saved to {save_directory}")
\ No newline at end of file
diff --git a/peft_models/mars/utils.py b/peft_models/mars/utils.py
deleted file mode 100644
index fb85b82..0000000
--- a/peft_models/mars/utils.py
+++ /dev/null
@@ -1,18 +0,0 @@
-TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING = {
-    "t5": ["q", "k", "v", "o", "wi", "wo"],
-    "mt5": ["q", "k", "v", "o", "wi_0", "wi_1", "wo"],
-    "bart": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
-    "gpt2": ["c_attn"],
-    "bloom": ["query_key_value"],
-    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
-    "gptj": ["q_proj", "v_proj"],
-    "gpt_neox": ["query_key_value"],
-    "gpt_neo": ["q_proj", "v_proj"],
-    "llama": ["q_proj", "v_proj"],
-    "bert": ["query", "value"],
-    "roberta": ["query", "value"],
-    "deberta-v2": ["query_proj", "key_proj", "value_proj", "dense"],
-    "gpt_bigcode": ["c_attn"],
-    "deberta": ["in_proj"],
-    "qwen2": ["q_proj", "v_proj"],
-}
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..070ec21
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,269 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mobiletransformers"
+version = "0.2.0"
+description = "Export and Android runtime tooling for on-device transformer training and inference."
+readme = "README.md"
+# optimum-onnx 0.1.0 supports py 3.9–3.13; cap below 3.14.
+requires-python = ">=3.10,<3.14"
+dependencies = [
+  "huggingface-hub>=0.34",
+  "numpy>=1.26",
+  "onnx>=1.16",
+  "pydantic>=2",
+  "pyyaml>=6.0",
+  "python-dotenv>=1.0",
+  "tokenizers>=0.20",
+]
+# license intentionally omitted until the licensing decision (target: Apache-2.0).
+
+[project.scripts]
+mobiletransformers = "mobiletransformers.cli.main:main"
+
+[project.optional-dependencies]
+# Public install surfaces. `export` uses optimum-onnx WITH the [onnxruntime] extra
+# (public onnxruntime). Never co-install with `ort-training-local` (see [tool.uv] conflicts).
+# transformers FLOOR is 4.50, not 4.45: Gemma-3 (`Gemma3ForCausalLM`/`Gemma3Config`, and the `gemma3`
+# row in CONFIG_MAPPING_NAMES) does not exist before it, so the architecture gate cannot even LOAD
+# the model on an older line — the failure is upstream of the graph entirely.
+#
+# This floor is also what FORCES the fork. `ort-training-local` pins `transformers==4.46.2` as part of
+# the source-built ORT wheel's paired stack; `[tool.uv] conflicts` already declares that group and this
+# extra mutually exclusive, but uv still prefers ONE version when a single version satisfies both — and
+# 4.46.2 satisfied `>=4.45,<4.58`.
+#
+# ⚠️ **RESOLVED 2026-08-15 — the two profiles are no longer forked on transformers, and this paragraph
+# describes history.** The fork existed to let the export profile reach Gemma-3 while the training
+# profile stayed at 4.46.2. `ort-training-local` now declares this same range, so a single version
+# satisfies both and the lock carries one transformers. That is fine and intended: `[tool.uv] conflicts`
+# keeps the two profiles apart on the thing that actually collides — the `onnxruntime` import — which
+# is a group/extra conflict, not a version one. `numpy` and `onnx` remain genuinely forked for the 3.12
+# split, because those pins ARE ABI constraints on the source-built wheel.
+#
+# Why moving the training pin was safe, in one line: transformers is the only paired_stack entry with
+# no ABI relationship to that wheel, and three controls (llama decoder, BERT encoder, gemma3) came back
+# identical or better. The full evidence is recorded on the pin itself, in `ort-training-local` below.
+#
+# `<4.58` is upstream's own ceiling (optimum-onnx 0.1.0 declares `transformers<4.58`), not our choice.
+export = ["optimum-onnx[onnxruntime]>=0.1.0", "transformers>=4.50,<4.58", "onnx", "onnxscript>=0.3"]
+train  = ["transformers>=4.45,<4.58", "onnxscript>=0.3", "peft>=0.13", "onnx"]
+rag    = ["langchain-community>=0.3.27", "langchain-huggingface>=0.3", "langchain-objectbox==0.1.0", "sentence-transformers>=5"]
+eval   = ["deepeval>=3.4.7", "matplotlib>=3.10"]
+hub    = ["huggingface-hub>=0.34"]
+# Federated Flower simulation: the record codec + FedAvg math are pure numpy (core-testable),
+# so no extra is needed for CI. Flower itself (flwr[simulation], which pulls ray/pyarrow) is deliberately
+# kept OUT of the universal lock — like the ORT-training wheel — because locking it downgrades protobuf/
+# rich/typer repo-wide. The manual simulation leg installs it out-of-band: `pip install "flwr[simulation]"`.
+
+[dependency-groups]
+# Local-only workflows. Never part of the published install surface.
+dev   = ["pytest>=8", "ruff>=0.6", "mypy>=1.11"]
+docs  = ["mkdocs>=1.6", "mkdocs-material>=9.5"]
+smoke = ["pytest>=8"]
+android-build = ["pyyaml>=6.0"]
+# onnxruntime-genai>=0.14 pulls onnxruntime>=1.26 which needs Python>=3.11; marker keeps the
+# 3.10 split resolvable (genai smoke requires 3.11+ regardless).
+genai-smoke   = ["onnxruntime-genai>=0.14; python_version >= '3.11'"]
+# Source-built training wheel PROVIDES `onnxruntime`; optimum-onnx here is BARE (no [onnxruntime]
+# extra) so it does not pull a second, colliding onnxruntime over the training wheel's import.
+# The wheel is cp312-only, so this group must be synced under Python 3.12. torch ABI is the
+# resolved 2.7.1 pairing recorded in third_party/onnxruntime/manifest.json (NOT the doc's 2.5.1 guess).
+ort-training-local = [
+  # cp312-only local wheel: marker keeps it out of the 3.10/3.11/3.13 resolution splits so the
+  # universal `uv lock` succeeds. This group is only ever synced under Python 3.12 (see manifest).
+  "onnxruntime-training; python_version == '3.12'",
+  "optimum-onnx>=0.1.0",
+  # Pinned to the manifest's paired_stack (peft 0.13.2), like torch/transformers below. Floating this
+  # at >=0.13 resolved to peft 0.19, which (a) renamed `PEFT_TYPE_TO_MODEL_MAPPING` and (b) requires
+  # `torch.distributed.tensor` (torch>=2.8) while this group pins torch==2.7.1 — so `get_peft_model`
+  # died with `AttributeError: module 'torch.distributed' has no attribute 'tensor'`. The whole point
+  # of manifest.json's paired_stack is that this profile reproduces the stack the ORT wheel was built
+  # against; three of its five entries were pinned and this one was not.
+  "peft==0.13.2",
+  "onnxscript>=0.3",
+  "torch==2.7.1",
+  # transformers is the ONE entry of the paired stack that is NOT ABI-coupled to the wheel.
+  #
+  # It was `==4.46.2` (the manifest's paired_stack value) until 2026-08-15, on the assumption that
+  # every paired_stack pin was load-bearing. It is not: `numpy<2` and `onnx<1.19` are genuine C-ABI /
+  # IR-version constraints on the source-built ORT extension and are called out as such in
+  # manifest.json's notes; transformers is pure Python and appears there as a RECORD of the build
+  # environment, not a requirement of it.
+  #
+  # Raised to the export extra's range after three controls under 4.57.6, all green:
+  #   * SmolLM2-135M-Instruct (llama decoder)      parity delta 0.0111 nats — the IDENTICAL figure its
+  #                                                2026-08-10 export recorded under 4.46.2
+  #   * all-MiniLM-L6-v2 (BERT encoder, text-cls)  73,728 trainable params — identical to before
+  #   * functiongemma-270m-it / gemma-3-270m       now exports at all, which 4.46.2 could never do
+  #     (no `Gemma3ForCausalLM`, no `Gemma3Config`, no `gemma3` row in CONFIG_MAPPING_NAMES)
+  #
+  # `get_peft_model` did NOT break — that specific failure is what the pin was held against, and it
+  # did not reproduce. The Gemma-3 blocker turned out to be an input-set mismatch in our own trainer
+  # wrapper, not a dependency at all (see export/training_export.py).
+  #
+  # The pins that ARE load-bearing stay exact: torch, peft, numpy, onnx. Do not float those.
+  "transformers>=4.50,<4.58",
+  # The source-built ORT-training wheel's C extension is compiled against the numpy 1.26 ABI
+  # (manifest paired_stack: numpy 1.26.4). numpy 2.x breaks it ("import numpy failed" at
+  # onnxruntime_pybind11_state load). Scope to 3.12 (numpy 1.26.x has no cp313 wheel, and this
+  # group is cp312-only regardless); forked resolution keeps numpy 2.x for the export profile.
+  "numpy<2; python_version == '3.12'",
+  # ORT 1.23 runtime supports max ONNX IR version 11; onnx>=1.19 emits IR 13, which fails to load
+  # in the generated optimizer/training graphs. Pin to the build-paired line (manifest: onnx 1.18.0).
+  "onnx<1.19; python_version == '3.12'",
+]
+# ROCm/CUDA export experiment surface (from the retired root `requirements-or.txt`, deleted
+# 2026-08-14 once its content was superseded by these groups). Deferred: the ROCm wheels
+# (onnxruntime-rocm==1.18.0, torch*+rocm) require a dedicated AMD/ROCm package index, not PyPI,
+# so wiring them into a resolvable group is out of scope for this foundation pass. Kept as a
+# declared-but-empty group so `uv lock` stays clean; populated when the ROCm index is configured.
+export-rocm = []
+
+[tool.uv.sources]
+# A source-built wheel that is not on PyPI: git-ignored, 662 MB, cp312/linux_x86_64 only.
+# Get it with `TRAINING=1 scripts/fetch_native_deps.sh`; sha256 in third_party/onnxruntime/manifest.json.
+onnxruntime-training = { path = "third_party/wheels/onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl" }
+
+[tool.uv]
+# The onnxruntime-import-colliding providers must never resolve into one environment.
+conflicts = [
+  [{ group = "ort-training-local" }, { extra = "export" }],
+  [{ group = "ort-training-local" }, { group = "genai-smoke" }],
+  [{ extra = "export" }, { group = "genai-smoke" }],
+]
+# langchain-objectbox 0.1.0 declares a stale `langchain-core<0.2.0` bound that pip's resolver
+# ignored; the real working env pairs it with langchain-core 0.3.74. Override to that proven line
+# so uv's strict resolver matches production (rag extra).
+override-dependencies = ["langchain-core>=0.3.74,<0.4"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mobiletransformers"]
+
+[tool.hatch.metadata]
+allow-direct-references = true  # required for the local path wheel source
+
+[tool.ruff]
+line-length = 110
+# Lint/format only the new package + tests. Legacy root packages and research/ are being migrated
+# subsystem-by-subsystem and are out of the gate until they move into src/ (see DECOMPOSE notes).
+src = ["src", "tests"]
+# ANCHORED to the repository root. A bare directory name here matches ANY path component, so
+# "inference"/"evaluation" also excluded src/mobiletransformers/{inference,evaluation}/ — code landing
+# there during the migration would have been silently ungated by both ruff and mypy.
+# S9: the seven legacy roots are DELETED. The root `config.py` shim followed 2026-08-14, so
+# `research/` is the ONLY thing outside the gate. Every line of migrated code is linted+type-checked.
+extend-exclude = ["/research/", "tests/fixtures/tiny_trainable.onnx"]
+
+[tool.ruff.lint.per-file-ignores]
+# MIGRATION RATCHET — lint debt carried in by the Migration Map. Entries may only SHRINK; delete a
+# file's entry once it is clean (tests/unit/test_gate_ratchet.py fails on a stale or non-firing entry).
+# The bulk of each moved file's findings was auto-fixed at move time; what remains needs a judgement
+# call about behaviour, which does not belong in a move.
+"src/mobiletransformers/training/data.py" = ["E721", "W291", "W293"]        # S1
+"src/mobiletransformers/inference/generator.py" = ["B006", "B905"]          # S1
+"src/mobiletransformers/export/inference_package.py" = ["E501"]             # S2
+"src/mobiletransformers/peft/ablation/config.py" = ["E501"]                 # S3
+"src/mobiletransformers/peft/ablation/layer.py" = ["F841"]                  # S3
+"src/mobiletransformers/peft/ablation/model.py" = ["B007", "B028", "E501", "F841"]   # S3
+"src/mobiletransformers/peft/lora_xs/latent_utils.py" = ["E501"]            # S3
+"src/mobiletransformers/peft/mars/config.py" = ["E501"]                     # S3
+"src/mobiletransformers/peft/mars/layer.py" = ["B006", "B904", "B905", "F401", "F841"]  # S3
+"src/mobiletransformers/peft/mars/matrices.py" = ["B007"]                   # S3
+"src/mobiletransformers/peft/mars/model.py" = ["B007", "B023", "B028", "E501"]  # S3
+"src/mobiletransformers/peft/mapping.py" = ["B006", "B007", "E501"]         # S4
+"src/mobiletransformers/training/preprocessing.py" = ["E501", "F841"]       # S4
+"src/mobiletransformers/export/embedding_export.py" = ["B904"]              # S4
+"src/mobiletransformers/export/training_export.py" = ["B006", "B007", "E402", "E501", "F841"]  # S4
+# S7 — database/ -> rag/. F403/F405 are `from objectbox.model import *`, which the ObjectBox entity
+# DSL requires (Entity/Id/String/Float32Vector/HnswIndex all arrive through it); enumerating them is a
+# behaviour change, not a move. The rest is pre-existing style debt carried across unchanged.
+"src/mobiletransformers/rag/builder.py" = ["B904", "B905", "E402", "E501", "F401", "F403", "F405", "F841"]
+"src/mobiletransformers/rag/query.py" = ["E402", "E501", "E722", "F403", "F405", "W293"]
+"src/mobiletransformers/rag/vector_entity.py" = ["E501", "F403", "F405"]
+"src/mobiletransformers/rag/json2entity.py" = ["E501"]
+# S8 — evaluation/ -> evaluation/ (reusable evaluators only; the hardcoded-path experiment scripts
+# went to research/evaluation/). Pre-existing style debt carried across unchanged.
+"src/mobiletransformers/evaluation/eval_adapter_models.py" = ["B007", "B905", "E402", "E722"]
+"src/mobiletransformers/evaluation/mobile_evaluator.py" = ["E501"]
+"src/mobiletransformers/evaluation/mobile/base_mobile_eval.py" = ["E501"]
+"src/mobiletransformers/evaluation/mobile/recommendation_eval.py" = ["B905", "E501", "W293"]
+"src/mobiletransformers/evaluation/openehr/openehr_eval.py" = ["E501"]
+"src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py" = ["E501", "F841"]
+# S6b — inference/validator.py -> artifacts/validation.py
+"src/mobiletransformers/artifacts/validation.py" = ["B006", "E402", "E501"]
+"src/mobiletransformers/training/validators.py" = ["B904", "E501", "E711"]
+"src/mobiletransformers/training/merge_validators.py" = ["B904", "E501"]
+# S6 — inference/builder.py, the 3,441-line graph builder. Style debt carried across unchanged.
+# F821 is GONE: the latent NameError in `make_mlp_unpacked_lora` (it wrapped `q_proj`/`k_proj`, unbound
+# in that scope, instead of the `gate_proj`/`up_proj` it builds and otherwise never uses) is fixed.
+"src/mobiletransformers/inference/builder.py" = ["B904", "B905", "E402", "E501", "E721", "E722"]
+"src/mobiletransformers/artifacts/builder.py" = ["B006", "E402", "E501", "F841"]  # S5
+
+[tool.ruff.lint]
+# pyflakes + pycodestyle + import-sort (I) + pyupgrade (UP) + bugbear (B).
+select = ["E", "F", "I", "W", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.10"
+# An existing untyped codebase can't go strict overnight: start lenient globally, CI-green day one.
+ignore_missing_imports = true
+plugins = ["pydantic.mypy"]  # teaches mypy about pydantic model defaults/aliases/factories
+files = ["src/mobiletransformers"]
+# Anchored with ^ for the same reason as ruff's extend-exclude above: an unanchored alternation also
+# matched src/mobiletransformers/{inference,evaluation}/.
+exclude = "^research/"  # S9: the other six roots no longer exist
+
+[[tool.mypy.overrides]]
+# New package modules are held to strict typing (new code pays the typing tax; legacy is ratcheted).
+module = "mobiletransformers.*"
+disallow_untyped_defs = true
+
+[[tool.mypy.overrides]]
+# MIGRATION RATCHET (S1): modules just moved in from the legacy roots — untyped by origin. Remove a
+# module from this list once it is annotated. Ordered AFTER the strict block above so it wins for
+# these paths only (mypy applies the most specific matching override).
+module = [
+  "mobiletransformers.training.data",
+  "mobiletransformers.training.callbacks",
+  "mobiletransformers.inference.generator",
+  "mobiletransformers.export.tokenizer_export",
+  "mobiletransformers.utils.paths",
+  "mobiletransformers.utils.templating",
+  # S3
+  "mobiletransformers.peft.*",
+  # S4
+  "mobiletransformers.training.preprocessing",
+  "mobiletransformers.export.embedding_export",
+  "mobiletransformers.export.training_export",
+  # S5
+  "mobiletransformers.artifacts.builder",
+  # S7 — database/ -> rag/. Untyped by origin (ObjectBox entity DSL + argparse scripts); annotating it
+  # is a separate change from moving it.
+  "mobiletransformers.rag.builder",
+  "mobiletransformers.rag.query",
+  "mobiletransformers.rag.vector_entity",
+  "mobiletransformers.rag.json2entity",
+  # S8 / S6b — untyped by origin (evaluation harnesses + the validator CLI).
+  "mobiletransformers.evaluation.*",
+  "mobiletransformers.artifacts.validation",
+  "mobiletransformers.training.validators",
+  "mobiletransformers.training.merge_validators",
+  # S6
+  "mobiletransformers.inference.builder",
+]
+ignore_errors = true
+
+[[tool.mypy.overrides]]
+# S9: only `research/` is left outside the gate. `src/` no longer imports it at all (the two helpers it
+# used were moved into the package), so this is belt-and-braces for anything research-adjacent.
+module = ["research.*"]
+follow_imports = "skip"
+ignore_errors = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# The ORT-training integration smoke self-skips (importorskip) unless the ort-training-local
+# profile is active, so a bare `pytest` run in the core env stays green.
diff --git a/requirements-or.txt b/requirements-or.txt
deleted file mode 100644
index 2f01de4..0000000
--- a/requirements-or.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-# Requirements for running ONNX Runtime + Torch workloads
-
-bertviz==1.4.1
-deepeval==3.4.7
-docx2txt==0.8
-fvcore==0.1.5.post20221221
-ipykernel==6.30.1
-langchain-community==0.3.19
-langchain-openai==0.3.8
-llama-index==0.12.23
-ml_dtypes==0.5.0
-ninja==1.11.1.1
-nvidia-cuda-cupti-cu12==12.4.127
-nvidia-cuda-nvrtc-cu12==12.4.127
-nvidia-cuda-runtime-cu12==12.4.127
-nvidia-cudnn-cu12==9.1.0.70
-nvidia-cufft-cu12==11.2.1.3
-nvidia-curand-cu12==10.3.5.147
-nvidia-cusolver-cu12==11.6.1.9
-nvidia-nccl-cu12==2.21.5
-nvidia-nvtx-cu12==12.4.127
-onnxruntime-rocm==1.18.0
-optimum==1.23.2
-peft==0.13.2
-pip==22.0.2
-PyQt6==6.8.0
-scikit-learn==1.5.2
-seaborn==0.13.2
-tensorly==0.9.0
-torch-ort==1.19.2
-torch-tb-profiler==0.4.3
-torchaudio==2.3.1+rocm6.0
-torchvision==0.18.1+rocm6.0
-triton==3.1.0
diff --git a/requirements-ort.txt b/requirements-ort.txt
deleted file mode 100644
index 111ff00..0000000
--- a/requirements-ort.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-# Requirements for running ONNX Runtime Training
-
-deepeval==3.1.4
-langchain-community==0.3.27
-langchain-huggingface==0.3.1
-langchain-objectbox==0.1.0
-matplotlib==3.10.5
-mkdocs==1.6.1
-onnxruntime-training==1.23.0+cpu
-onnxscript==0.3.1
-optimum==1.23.3
-peft==0.13.2
-pip==25.0.1
-sentence-transformers==5.1.0
-unstructured==0.18.11
diff --git a/requirements/requirements-dev.lock.txt b/requirements/requirements-dev.lock.txt
new file mode 100644
index 0000000..bd47ec8
--- /dev/null
+++ b/requirements/requirements-dev.lock.txt
@@ -0,0 +1,680 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-emit-project --group dev --format requirements.txt -o requirements/requirements-dev.lock.txt
+annotated-types==0.7.0 \
+    --hash=sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 \
+    --hash=sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89
+    # via pydantic
+ast-serialize==0.6.0 \
+    --hash=sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596 \
+    --hash=sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e \
+    --hash=sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a \
+    --hash=sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a \
+    --hash=sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790 \
+    --hash=sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e \
+    --hash=sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1 \
+    --hash=sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b \
+    --hash=sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe \
+    --hash=sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b \
+    --hash=sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32 \
+    --hash=sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081 \
+    --hash=sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b \
+    --hash=sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e \
+    --hash=sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77 \
+    --hash=sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b \
+    --hash=sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7 \
+    --hash=sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad
+    # via mypy
+certifi==2026.6.17 \
+    --hash=sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432 \
+    --hash=sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db
+    # via requests
+charset-normalizer==3.4.9 \
+    --hash=sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62 \
+    --hash=sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c \
+    --hash=sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5 \
+    --hash=sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99 \
+    --hash=sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec \
+    --hash=sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698 \
+    --hash=sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3 \
+    --hash=sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2 \
+    --hash=sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a \
+    --hash=sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419 \
+    --hash=sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da \
+    --hash=sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe \
+    --hash=sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381 \
+    --hash=sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614 \
+    --hash=sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0 \
+    --hash=sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29 \
+    --hash=sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0 \
+    --hash=sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9 \
+    --hash=sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63 \
+    --hash=sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd \
+    --hash=sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde \
+    --hash=sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012 \
+    --hash=sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1 \
+    --hash=sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15 \
+    --hash=sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b \
+    --hash=sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993 \
+    --hash=sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5 \
+    --hash=sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8 \
+    --hash=sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35 \
+    --hash=sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642 \
+    --hash=sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2 \
+    --hash=sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d \
+    --hash=sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9 \
+    --hash=sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33 \
+    --hash=sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db \
+    --hash=sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee \
+    --hash=sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84 \
+    --hash=sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44 \
+    --hash=sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9 \
+    --hash=sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8 \
+    --hash=sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b \
+    --hash=sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39 \
+    --hash=sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0 \
+    --hash=sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616 \
+    --hash=sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d \
+    --hash=sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2 \
+    --hash=sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b \
+    --hash=sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9 \
+    --hash=sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b \
+    --hash=sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209 \
+    --hash=sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a \
+    --hash=sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b \
+    --hash=sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9 \
+    --hash=sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115
+    # via requests
+colorama==0.4.6 ; sys_platform == 'win32' \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via
+    #   pytest
+    #   tqdm
+exceptiongroup==1.3.1 ; python_full_version < '3.11' \
+    --hash=sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219 \
+    --hash=sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598
+    # via pytest
+filelock==3.29.7 \
+    --hash=sha256:5b481979797ae69e72f0b389d89a80bdd585c260c5b3f1fb9c0a5ba9bb3f195d \
+    --hash=sha256:987db6f789a3a2a59f55081801b2b3697cb97e2a736b5f1a9e99b559285fbc51
+    # via huggingface-hub
+fsspec==2026.6.0 \
+    --hash=sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1 \
+    --hash=sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a
+    # via huggingface-hub
+hf-xet==1.5.1 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' \
+    --hash=sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6 \
+    --hash=sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6 \
+    --hash=sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf \
+    --hash=sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e \
+    --hash=sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947 \
+    --hash=sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d \
+    --hash=sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350 \
+    --hash=sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e \
+    --hash=sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e \
+    --hash=sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283 \
+    --hash=sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4 \
+    --hash=sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8 \
+    --hash=sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577 \
+    --hash=sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43 \
+    --hash=sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff \
+    --hash=sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342 \
+    --hash=sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5
+    # via huggingface-hub
+huggingface-hub==0.36.2 \
+    --hash=sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a \
+    --hash=sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270
+    # via
+    #   mobiletransformers
+    #   tokenizers
+idna==3.18 \
+    --hash=sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2 \
+    --hash=sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848
+    # via requests
+iniconfig==2.3.0 \
+    --hash=sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730 \
+    --hash=sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12
+    # via pytest
+librt==0.13.0 ; platform_python_implementation != 'PyPy' \
+    --hash=sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b \
+    --hash=sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd \
+    --hash=sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a \
+    --hash=sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6 \
+    --hash=sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7 \
+    --hash=sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1 \
+    --hash=sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082 \
+    --hash=sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781 \
+    --hash=sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac \
+    --hash=sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2 \
+    --hash=sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0 \
+    --hash=sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c \
+    --hash=sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14 \
+    --hash=sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5 \
+    --hash=sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde \
+    --hash=sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f \
+    --hash=sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628 \
+    --hash=sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c \
+    --hash=sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db \
+    --hash=sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650 \
+    --hash=sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b \
+    --hash=sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40 \
+    --hash=sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348 \
+    --hash=sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588 \
+    --hash=sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd \
+    --hash=sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927 \
+    --hash=sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89 \
+    --hash=sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3 \
+    --hash=sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5 \
+    --hash=sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9 \
+    --hash=sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176 \
+    --hash=sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a \
+    --hash=sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7 \
+    --hash=sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8 \
+    --hash=sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3 \
+    --hash=sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7 \
+    --hash=sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c \
+    --hash=sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03 \
+    --hash=sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d \
+    --hash=sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1 \
+    --hash=sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9 \
+    --hash=sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b \
+    --hash=sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566 \
+    --hash=sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc \
+    --hash=sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82 \
+    --hash=sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547 \
+    --hash=sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1 \
+    --hash=sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa \
+    --hash=sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a \
+    --hash=sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929 \
+    --hash=sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79 \
+    --hash=sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e \
+    --hash=sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21
+    # via mypy
+ml-dtypes==0.5.4 \
+    --hash=sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483 \
+    --hash=sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6 \
+    --hash=sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175 \
+    --hash=sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270 \
+    --hash=sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1 \
+    --hash=sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2 \
+    --hash=sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298 \
+    --hash=sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d \
+    --hash=sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de \
+    --hash=sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d \
+    --hash=sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90 \
+    --hash=sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb \
+    --hash=sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453 \
+    --hash=sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48 \
+    --hash=sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff \
+    --hash=sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460 \
+    --hash=sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac \
+    --hash=sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900 \
+    --hash=sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a \
+    --hash=sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c \
+    --hash=sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040 \
+    --hash=sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7 \
+    --hash=sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6 \
+    --hash=sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b \
+    --hash=sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328
+    # via onnx
+mypy==2.3.0 \
+    --hash=sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491 \
+    --hash=sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5 \
+    --hash=sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd \
+    --hash=sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc \
+    --hash=sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3 \
+    --hash=sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5 \
+    --hash=sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329 \
+    --hash=sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3 \
+    --hash=sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805 \
+    --hash=sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e \
+    --hash=sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7 \
+    --hash=sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494 \
+    --hash=sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88 \
+    --hash=sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee \
+    --hash=sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2 \
+    --hash=sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757 \
+    --hash=sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a \
+    --hash=sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b \
+    --hash=sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461 \
+    --hash=sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97 \
+    --hash=sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117 \
+    --hash=sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36 \
+    --hash=sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac \
+    --hash=sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c \
+    --hash=sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568 \
+    --hash=sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595 \
+    --hash=sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f \
+    --hash=sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1 \
+    --hash=sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6 \
+    --hash=sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c
+mypy-extensions==1.1.0 \
+    --hash=sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505 \
+    --hash=sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558
+    # via mypy
+numpy==2.2.6 ; python_full_version < '3.11' \
+    --hash=sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff \
+    --hash=sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47 \
+    --hash=sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84 \
+    --hash=sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d \
+    --hash=sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6 \
+    --hash=sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f \
+    --hash=sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b \
+    --hash=sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49 \
+    --hash=sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163 \
+    --hash=sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571 \
+    --hash=sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42 \
+    --hash=sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff \
+    --hash=sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491 \
+    --hash=sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4 \
+    --hash=sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566 \
+    --hash=sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf \
+    --hash=sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40 \
+    --hash=sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd \
+    --hash=sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06 \
+    --hash=sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282 \
+    --hash=sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680 \
+    --hash=sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db \
+    --hash=sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3 \
+    --hash=sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90 \
+    --hash=sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1 \
+    --hash=sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289 \
+    --hash=sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab \
+    --hash=sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c \
+    --hash=sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d \
+    --hash=sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb \
+    --hash=sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d \
+    --hash=sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a \
+    --hash=sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf \
+    --hash=sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1 \
+    --hash=sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2 \
+    --hash=sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a \
+    --hash=sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543 \
+    --hash=sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00 \
+    --hash=sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c \
+    --hash=sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f \
+    --hash=sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd \
+    --hash=sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868 \
+    --hash=sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303 \
+    --hash=sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83 \
+    --hash=sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3 \
+    --hash=sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d \
+    --hash=sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87 \
+    --hash=sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa \
+    --hash=sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f \
+    --hash=sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae \
+    --hash=sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda \
+    --hash=sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915 \
+    --hash=sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249 \
+    --hash=sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de \
+    --hash=sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+numpy==2.4.6 ; python_full_version == '3.11.*' \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+numpy==2.5.1 ; python_full_version >= '3.12' \
+    --hash=sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2 \
+    --hash=sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1 \
+    --hash=sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b \
+    --hash=sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd \
+    --hash=sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e \
+    --hash=sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277 \
+    --hash=sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6 \
+    --hash=sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7 \
+    --hash=sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1 \
+    --hash=sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9 \
+    --hash=sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca \
+    --hash=sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d \
+    --hash=sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75 \
+    --hash=sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74 \
+    --hash=sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0 \
+    --hash=sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a \
+    --hash=sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3 \
+    --hash=sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1 \
+    --hash=sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6 \
+    --hash=sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9 \
+    --hash=sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3 \
+    --hash=sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2 \
+    --hash=sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+onnx==1.22.0 \
+    --hash=sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5 \
+    --hash=sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c \
+    --hash=sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914 \
+    --hash=sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc \
+    --hash=sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103 \
+    --hash=sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b \
+    --hash=sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4 \
+    --hash=sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a \
+    --hash=sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c \
+    --hash=sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da \
+    --hash=sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573 \
+    --hash=sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58 \
+    --hash=sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec \
+    --hash=sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b \
+    --hash=sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6 \
+    --hash=sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16 \
+    --hash=sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016 \
+    --hash=sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0 \
+    --hash=sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f
+    # via mobiletransformers
+packaging==25.0 \
+    --hash=sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484 \
+    --hash=sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f
+    # via
+    #   huggingface-hub
+    #   pytest
+pathspec==1.1.1 \
+    --hash=sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+    # via mypy
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+protobuf==7.35.1 \
+    --hash=sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799 \
+    --hash=sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87 \
+    --hash=sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6 \
+    --hash=sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30 \
+    --hash=sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9 \
+    --hash=sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4 \
+    --hash=sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4 \
+    --hash=sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a
+    # via onnx
+pydantic==2.13.4 \
+    --hash=sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba \
+    --hash=sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6
+    # via mobiletransformers
+pydantic-core==2.46.4 \
+    --hash=sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0 \
+    --hash=sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262 \
+    --hash=sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda \
+    --hash=sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0 \
+    --hash=sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b \
+    --hash=sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594 \
+    --hash=sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2 \
+    --hash=sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c \
+    --hash=sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d \
+    --hash=sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398 \
+    --hash=sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d \
+    --hash=sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3 \
+    --hash=sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f \
+    --hash=sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7 \
+    --hash=sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4 \
+    --hash=sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d \
+    --hash=sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df \
+    --hash=sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2 \
+    --hash=sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd \
+    --hash=sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7 \
+    --hash=sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3 \
+    --hash=sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a \
+    --hash=sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987 \
+    --hash=sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e \
+    --hash=sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712 \
+    --hash=sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008 \
+    --hash=sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1 \
+    --hash=sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be \
+    --hash=sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea \
+    --hash=sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292 \
+    --hash=sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33 \
+    --hash=sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826 \
+    --hash=sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7 \
+    --hash=sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d \
+    --hash=sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf \
+    --hash=sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc \
+    --hash=sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3 \
+    --hash=sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b \
+    --hash=sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04 \
+    --hash=sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c \
+    --hash=sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b \
+    --hash=sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce \
+    --hash=sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4 \
+    --hash=sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a \
+    --hash=sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f \
+    --hash=sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894 \
+    --hash=sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9 \
+    --hash=sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76 \
+    --hash=sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb \
+    --hash=sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109 \
+    --hash=sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4 \
+    --hash=sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848 \
+    --hash=sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526 \
+    --hash=sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01 \
+    --hash=sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458 \
+    --hash=sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba \
+    --hash=sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39 \
+    --hash=sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b \
+    --hash=sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf \
+    --hash=sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4 \
+    --hash=sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd \
+    --hash=sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30 \
+    --hash=sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983 \
+    --hash=sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5 \
+    --hash=sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4 \
+    --hash=sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7 \
+    --hash=sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c \
+    --hash=sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3 \
+    --hash=sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89 \
+    --hash=sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50 \
+    --hash=sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76 \
+    --hash=sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b \
+    --hash=sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d \
+    --hash=sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4 \
+    --hash=sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c \
+    --hash=sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e
+    # via pydantic
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==9.1.1 \
+    --hash=sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313 \
+    --hash=sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c
+python-dotenv==1.2.2 \
+    --hash=sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a \
+    --hash=sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3
+    # via mobiletransformers
+pyyaml==6.0.3 \
+    --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \
+    --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \
+    --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \
+    --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \
+    --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \
+    --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \
+    --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \
+    --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \
+    --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via
+    #   huggingface-hub
+    #   mobiletransformers
+requests==2.34.2 \
+    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
+    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
+    # via huggingface-hub
+ruff==0.15.21 \
+    --hash=sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075 \
+    --hash=sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be \
+    --hash=sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd \
+    --hash=sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd \
+    --hash=sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86 \
+    --hash=sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341 \
+    --hash=sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd \
+    --hash=sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67 \
+    --hash=sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41 \
+    --hash=sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d \
+    --hash=sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d \
+    --hash=sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8 \
+    --hash=sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233 \
+    --hash=sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8 \
+    --hash=sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500 \
+    --hash=sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3 \
+    --hash=sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646 \
+    --hash=sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f
+tokenizers==0.22.2 \
+    --hash=sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e \
+    --hash=sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001 \
+    --hash=sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7 \
+    --hash=sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd \
+    --hash=sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4 \
+    --hash=sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67 \
+    --hash=sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a \
+    --hash=sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5 \
+    --hash=sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917 \
+    --hash=sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c \
+    --hash=sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195 \
+    --hash=sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4 \
+    --hash=sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a \
+    --hash=sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc \
+    --hash=sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92 \
+    --hash=sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5 \
+    --hash=sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48 \
+    --hash=sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b \
+    --hash=sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c \
+    --hash=sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5
+    # via mobiletransformers
+tomli==2.4.1 ; python_full_version < '3.11' \
+    --hash=sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe \
+    --hash=sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5 \
+    --hash=sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd \
+    --hash=sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54 \
+    --hash=sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c \
+    --hash=sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a \
+    --hash=sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd \
+    --hash=sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5 \
+    --hash=sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9 \
+    --hash=sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9 \
+    --hash=sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1 \
+    --hash=sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585 \
+    --hash=sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e \
+    --hash=sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f \
+    --hash=sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085 \
+    --hash=sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36 \
+    --hash=sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076 \
+    --hash=sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece \
+    --hash=sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a \
+    --hash=sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897 \
+    --hash=sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d \
+    --hash=sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917 \
+    --hash=sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a \
+    --hash=sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc \
+    --hash=sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f \
+    --hash=sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257 \
+    --hash=sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30 \
+    --hash=sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9 \
+    --hash=sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049
+    # via
+    #   mypy
+    #   pytest
+tqdm==4.68.4 \
+    --hash=sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520 \
+    --hash=sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2
+    # via huggingface-hub
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via
+    #   exceptiongroup
+    #   huggingface-hub
+    #   mypy
+    #   onnx
+    #   pydantic
+    #   pydantic-core
+    #   typing-inspection
+typing-inspection==0.4.2 \
+    --hash=sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7 \
+    --hash=sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464
+    # via pydantic
+urllib3==2.7.0 \
+    --hash=sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c \
+    --hash=sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897
+    # via requests
diff --git a/requirements/requirements-export.lock.txt b/requirements/requirements-export.lock.txt
new file mode 100644
index 0000000..1f96b4a
--- /dev/null
+++ b/requirements/requirements-export.lock.txt
@@ -0,0 +1,1100 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-emit-project --extra export --format requirements.txt -o requirements/requirements-export.lock.txt
+annotated-types==0.7.0 \
+    --hash=sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 \
+    --hash=sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89
+    # via pydantic
+ast-serialize==0.6.0 \
+    --hash=sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596 \
+    --hash=sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e \
+    --hash=sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a \
+    --hash=sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a \
+    --hash=sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790 \
+    --hash=sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e \
+    --hash=sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1 \
+    --hash=sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b \
+    --hash=sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe \
+    --hash=sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b \
+    --hash=sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32 \
+    --hash=sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081 \
+    --hash=sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b \
+    --hash=sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e \
+    --hash=sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77 \
+    --hash=sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b \
+    --hash=sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7 \
+    --hash=sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad
+    # via mypy
+certifi==2026.6.17 \
+    --hash=sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432 \
+    --hash=sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db
+    # via requests
+charset-normalizer==3.4.9 \
+    --hash=sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62 \
+    --hash=sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c \
+    --hash=sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5 \
+    --hash=sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99 \
+    --hash=sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec \
+    --hash=sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698 \
+    --hash=sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3 \
+    --hash=sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2 \
+    --hash=sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a \
+    --hash=sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419 \
+    --hash=sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da \
+    --hash=sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe \
+    --hash=sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381 \
+    --hash=sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614 \
+    --hash=sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0 \
+    --hash=sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29 \
+    --hash=sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0 \
+    --hash=sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9 \
+    --hash=sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63 \
+    --hash=sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd \
+    --hash=sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde \
+    --hash=sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012 \
+    --hash=sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1 \
+    --hash=sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15 \
+    --hash=sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b \
+    --hash=sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993 \
+    --hash=sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5 \
+    --hash=sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8 \
+    --hash=sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35 \
+    --hash=sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642 \
+    --hash=sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2 \
+    --hash=sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d \
+    --hash=sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9 \
+    --hash=sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33 \
+    --hash=sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db \
+    --hash=sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee \
+    --hash=sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84 \
+    --hash=sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44 \
+    --hash=sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9 \
+    --hash=sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8 \
+    --hash=sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b \
+    --hash=sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39 \
+    --hash=sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0 \
+    --hash=sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616 \
+    --hash=sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d \
+    --hash=sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2 \
+    --hash=sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b \
+    --hash=sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9 \
+    --hash=sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b \
+    --hash=sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209 \
+    --hash=sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a \
+    --hash=sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b \
+    --hash=sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9 \
+    --hash=sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115
+    # via requests
+colorama==0.4.6 ; sys_platform == 'win32' \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via
+    #   pytest
+    #   tqdm
+exceptiongroup==1.3.1 ; python_full_version < '3.11' \
+    --hash=sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219 \
+    --hash=sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598
+    # via pytest
+filelock==3.29.7 \
+    --hash=sha256:5b481979797ae69e72f0b389d89a80bdd585c260c5b3f1fb9c0a5ba9bb3f195d \
+    --hash=sha256:987db6f789a3a2a59f55081801b2b3697cb97e2a736b5f1a9e99b559285fbc51
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+flatbuffers==24.3.25 \
+    --hash=sha256:8dbdec58f935f3765e4f7f3cf635ac3a77f83568138d6a2311f524ec96364812 \
+    --hash=sha256:de2ec5b203f21441716617f38443e0a8ebf3d25bf0d9c0bb0ce68fa00ad546a4
+    # via onnxruntime
+fsspec==2026.6.0 \
+    --hash=sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1 \
+    --hash=sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a
+    # via
+    #   huggingface-hub
+    #   torch
+hf-xet==1.5.1 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' \
+    --hash=sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6 \
+    --hash=sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6 \
+    --hash=sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf \
+    --hash=sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e \
+    --hash=sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947 \
+    --hash=sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d \
+    --hash=sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350 \
+    --hash=sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e \
+    --hash=sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e \
+    --hash=sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283 \
+    --hash=sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4 \
+    --hash=sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8 \
+    --hash=sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577 \
+    --hash=sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43 \
+    --hash=sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff \
+    --hash=sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342 \
+    --hash=sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5
+    # via huggingface-hub
+huggingface-hub==0.36.2 \
+    --hash=sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a \
+    --hash=sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270
+    # via
+    #   mobiletransformers
+    #   optimum
+    #   tokenizers
+    #   transformers
+idna==3.18 \
+    --hash=sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2 \
+    --hash=sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848
+    # via requests
+iniconfig==2.3.0 \
+    --hash=sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730 \
+    --hash=sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12
+    # via pytest
+jinja2==3.1.6 \
+    --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \
+    --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67
+    # via torch
+librt==0.13.0 ; platform_python_implementation != 'PyPy' \
+    --hash=sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b \
+    --hash=sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd \
+    --hash=sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a \
+    --hash=sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6 \
+    --hash=sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7 \
+    --hash=sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1 \
+    --hash=sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082 \
+    --hash=sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781 \
+    --hash=sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac \
+    --hash=sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2 \
+    --hash=sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0 \
+    --hash=sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c \
+    --hash=sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14 \
+    --hash=sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5 \
+    --hash=sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde \
+    --hash=sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f \
+    --hash=sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628 \
+    --hash=sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c \
+    --hash=sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db \
+    --hash=sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650 \
+    --hash=sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b \
+    --hash=sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40 \
+    --hash=sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348 \
+    --hash=sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588 \
+    --hash=sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd \
+    --hash=sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927 \
+    --hash=sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89 \
+    --hash=sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3 \
+    --hash=sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5 \
+    --hash=sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9 \
+    --hash=sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176 \
+    --hash=sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a \
+    --hash=sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7 \
+    --hash=sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8 \
+    --hash=sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3 \
+    --hash=sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7 \
+    --hash=sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c \
+    --hash=sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03 \
+    --hash=sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d \
+    --hash=sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1 \
+    --hash=sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9 \
+    --hash=sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b \
+    --hash=sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566 \
+    --hash=sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc \
+    --hash=sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82 \
+    --hash=sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547 \
+    --hash=sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1 \
+    --hash=sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa \
+    --hash=sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a \
+    --hash=sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929 \
+    --hash=sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79 \
+    --hash=sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e \
+    --hash=sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21
+    # via mypy
+markupsafe==3.0.3 \
+    --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \
+    --hash=sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a \
+    --hash=sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf \
+    --hash=sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19 \
+    --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \
+    --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \
+    --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \
+    --hash=sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1 \
+    --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \
+    --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \
+    --hash=sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695 \
+    --hash=sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad \
+    --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \
+    --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \
+    --hash=sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa \
+    --hash=sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559 \
+    --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \
+    --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \
+    --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \
+    --hash=sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c \
+    --hash=sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a \
+    --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \
+    --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \
+    --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \
+    --hash=sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50 \
+    --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \
+    --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \
+    --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \
+    --hash=sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115 \
+    --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \
+    --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \
+    --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \
+    --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \
+    --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \
+    --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \
+    --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \
+    --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \
+    --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \
+    --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \
+    --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \
+    --hash=sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f \
+    --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \
+    --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \
+    --hash=sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c \
+    --hash=sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8 \
+    --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \
+    --hash=sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6 \
+    --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \
+    --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \
+    --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \
+    --hash=sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01 \
+    --hash=sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419 \
+    --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795 \
+    --hash=sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1 \
+    --hash=sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591 \
+    --hash=sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a
+    # via jinja2
+ml-dtypes==0.5.4 \
+    --hash=sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483 \
+    --hash=sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6 \
+    --hash=sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175 \
+    --hash=sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270 \
+    --hash=sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1 \
+    --hash=sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2 \
+    --hash=sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298 \
+    --hash=sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d \
+    --hash=sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de \
+    --hash=sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d \
+    --hash=sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90 \
+    --hash=sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb \
+    --hash=sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453 \
+    --hash=sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48 \
+    --hash=sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff \
+    --hash=sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460 \
+    --hash=sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac \
+    --hash=sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900 \
+    --hash=sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a \
+    --hash=sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c \
+    --hash=sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040 \
+    --hash=sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7 \
+    --hash=sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6 \
+    --hash=sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b \
+    --hash=sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328
+    # via
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+mpmath==1.3.0 \
+    --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \
+    --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c
+    # via sympy
+mypy==2.3.0 \
+    --hash=sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491 \
+    --hash=sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5 \
+    --hash=sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd \
+    --hash=sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc \
+    --hash=sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3 \
+    --hash=sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5 \
+    --hash=sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329 \
+    --hash=sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3 \
+    --hash=sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805 \
+    --hash=sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e \
+    --hash=sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7 \
+    --hash=sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494 \
+    --hash=sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88 \
+    --hash=sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee \
+    --hash=sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2 \
+    --hash=sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757 \
+    --hash=sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a \
+    --hash=sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b \
+    --hash=sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461 \
+    --hash=sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97 \
+    --hash=sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117 \
+    --hash=sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36 \
+    --hash=sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac \
+    --hash=sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c \
+    --hash=sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568 \
+    --hash=sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595 \
+    --hash=sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f \
+    --hash=sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1 \
+    --hash=sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6 \
+    --hash=sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c
+mypy-extensions==1.1.0 \
+    --hash=sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505 \
+    --hash=sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558
+    # via mypy
+networkx==3.4.2 ; python_full_version < '3.11' \
+    --hash=sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1 \
+    --hash=sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f
+    # via torch
+networkx==3.6.1 ; python_full_version >= '3.11' \
+    --hash=sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509 \
+    --hash=sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762
+    # via torch
+numpy==2.2.6 ; python_full_version < '3.11' \
+    --hash=sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff \
+    --hash=sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47 \
+    --hash=sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84 \
+    --hash=sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d \
+    --hash=sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6 \
+    --hash=sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f \
+    --hash=sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b \
+    --hash=sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49 \
+    --hash=sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163 \
+    --hash=sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571 \
+    --hash=sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42 \
+    --hash=sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff \
+    --hash=sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491 \
+    --hash=sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4 \
+    --hash=sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566 \
+    --hash=sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf \
+    --hash=sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40 \
+    --hash=sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd \
+    --hash=sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06 \
+    --hash=sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282 \
+    --hash=sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680 \
+    --hash=sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db \
+    --hash=sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3 \
+    --hash=sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90 \
+    --hash=sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1 \
+    --hash=sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289 \
+    --hash=sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab \
+    --hash=sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c \
+    --hash=sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d \
+    --hash=sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb \
+    --hash=sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d \
+    --hash=sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a \
+    --hash=sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf \
+    --hash=sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1 \
+    --hash=sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2 \
+    --hash=sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a \
+    --hash=sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543 \
+    --hash=sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00 \
+    --hash=sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c \
+    --hash=sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f \
+    --hash=sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd \
+    --hash=sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868 \
+    --hash=sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303 \
+    --hash=sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83 \
+    --hash=sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3 \
+    --hash=sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d \
+    --hash=sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87 \
+    --hash=sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa \
+    --hash=sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f \
+    --hash=sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae \
+    --hash=sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda \
+    --hash=sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915 \
+    --hash=sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249 \
+    --hash=sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de \
+    --hash=sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxruntime
+    #   onnxscript
+    #   optimum
+    #   transformers
+numpy==2.4.6 ; python_full_version == '3.11.*' \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxruntime
+    #   onnxscript
+    #   optimum
+    #   transformers
+numpy==2.5.1 ; python_full_version >= '3.12' \
+    --hash=sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2 \
+    --hash=sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1 \
+    --hash=sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b \
+    --hash=sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd \
+    --hash=sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e \
+    --hash=sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277 \
+    --hash=sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6 \
+    --hash=sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7 \
+    --hash=sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1 \
+    --hash=sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9 \
+    --hash=sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca \
+    --hash=sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d \
+    --hash=sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75 \
+    --hash=sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74 \
+    --hash=sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0 \
+    --hash=sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a \
+    --hash=sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3 \
+    --hash=sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1 \
+    --hash=sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6 \
+    --hash=sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9 \
+    --hash=sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3 \
+    --hash=sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2 \
+    --hash=sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107
+    # via
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxruntime
+    #   onnxscript
+    #   optimum
+    #   transformers
+nvidia-cublas-cu12==12.6.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb \
+    --hash=sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668 \
+    --hash=sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.6.80 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc \
+    --hash=sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4 \
+    --hash=sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132 \
+    --hash=sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73 \
+    --hash=sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53 \
+    --hash=sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13 \
+    --hash=sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a
+    # via torch
+nvidia-cuda-runtime-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd \
+    --hash=sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f \
+    --hash=sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8 \
+    --hash=sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7 \
+    --hash=sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e
+    # via torch
+nvidia-cudnn-cu12==9.5.1.17 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2 \
+    --hash=sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def \
+    --hash=sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8
+    # via torch
+nvidia-cufft-cu12==11.3.0.4 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464 \
+    --hash=sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca \
+    --hash=sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb \
+    --hash=sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5 \
+    --hash=sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6
+    # via torch
+nvidia-cufile-cu12==1.11.1.6 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db \
+    --hash=sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159
+    # via torch
+nvidia-curand-cu12==10.3.7.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905 \
+    --hash=sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8 \
+    --hash=sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e \
+    --hash=sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117 \
+    --hash=sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf
+    # via torch
+nvidia-cusolver-cu12==11.7.1.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0 \
+    --hash=sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7 \
+    --hash=sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6 \
+    --hash=sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e \
+    --hash=sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c
+    # via torch
+nvidia-cusparse-cu12==12.5.4.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f \
+    --hash=sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20 \
+    --hash=sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73 \
+    --hash=sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1 \
+    --hash=sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.6.3 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7 \
+    --hash=sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1 \
+    --hash=sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46
+    # via torch
+nvidia-nccl-cu12==2.26.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522 \
+    --hash=sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6
+    # via torch
+nvidia-nvjitlink-cu12==12.6.85 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41 \
+    --hash=sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c \
+    --hash=sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvtx-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0 \
+    --hash=sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1 \
+    --hash=sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059 \
+    --hash=sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2 \
+    --hash=sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b
+    # via torch
+onnx==1.22.0 \
+    --hash=sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5 \
+    --hash=sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c \
+    --hash=sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914 \
+    --hash=sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc \
+    --hash=sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103 \
+    --hash=sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b \
+    --hash=sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4 \
+    --hash=sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a \
+    --hash=sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c \
+    --hash=sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da \
+    --hash=sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573 \
+    --hash=sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58 \
+    --hash=sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec \
+    --hash=sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b \
+    --hash=sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6 \
+    --hash=sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16 \
+    --hash=sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016 \
+    --hash=sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0 \
+    --hash=sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f
+    # via
+    #   mobiletransformers
+    #   onnx-ir
+    #   onnxscript
+    #   optimum-onnx
+onnx-ir==0.2.1 \
+    --hash=sha256:8b8b10a93f43e65962104de6070c43c5dacb0e3cdfefc7c8059dd83c9db64f35 \
+    --hash=sha256:c7285da889312f91882de2092e298a9eeeefbfc1d1951c49d983992967eb09a7
+    # via onnxscript
+onnxruntime==1.24.3 ; python_full_version < '3.11' \
+    --hash=sha256:0a9847b870b6cb462652b547bc98c49e0efb67553410a082fde1918a38707452 \
+    --hash=sha256:0d244227dc5e00a9ae15a7ac1eba4c4460d7876dfecafe73fb00db9f1d914d91 \
+    --hash=sha256:1fd2ec7bb0fabe42f55e8337cfc9b1969d0d14622711aac73d69b4bd5abb5ed7 \
+    --hash=sha256:2d3706719be6ad41d38a2250998b1d87758a20f6ea4546962e21dc79f1f1fd2b \
+    --hash=sha256:34a0ea5ff191d8420d9c1332355644148b1bf1a0d10c411af890a63a9f662aa7 \
+    --hash=sha256:3e6456801c66b095c5cd68e690ca25db970ea5202bd0c5b84a2c3ef7731c5a3c \
+    --hash=sha256:44ea708c34965439170d811267c51281d3897ecfc4aa0087fa25d4a4c3eb2e4a \
+    --hash=sha256:48d1092b44ca2ba6f9543892e7c422c15a568481403c10440945685faf27a8d8 \
+    --hash=sha256:72f956634bc2e4bd2e8b006bef111849bd42c42dea37bd0a4c728404fdaf4d34 \
+    --hash=sha256:78d1f25eed4ab9959db70a626ed50ee24cf497e60774f59f1207ac8556399c4d \
+    --hash=sha256:8b2ebc54c6d8281dccff78d4b06e47d4cf07535937584ab759448390a70f4978 \
+    --hash=sha256:a8f761857ebaf58a85b9e42422d03207f1d39e6bb8fecfdbf613bac5b9710723 \
+    --hash=sha256:b082f3ba9519f0a1a1e754556bc7e635c7526ef81b98b3f78da4455d25f0437b \
+    --hash=sha256:b354afce3333f2859c7e8706d84b6c552beac39233bcd3141ce7ab77b4cabb5d \
+    --hash=sha256:c958222ef9eff54018332beecd32d5d94a3ab079d8821937b333811bf4da0d39 \
+    --hash=sha256:df8e70e732fe26346faaeec9147fa38bef35d232d2495d27e93dd221a2d473a9 \
+    --hash=sha256:fb56575d7794bf0781156955610c9e651c9504c64d42ec880784b6106244882d
+    # via optimum-onnx
+onnxruntime==1.27.0 ; python_full_version >= '3.11' \
+    --hash=sha256:1b215aa662c8f983f7d6dedafe65a9be72c26e5338e0fe98b3e0422c32c85428 \
+    --hash=sha256:20c321cf187ba496e648acf6b4cf90b4d398b0d17c2a77fdaeba365b908cc1c1 \
+    --hash=sha256:2eb083321af8a236a84c7c140a7f4cecbfa2a987a18c07c78db471c20cd390ef \
+    --hash=sha256:2fdfa9df40a0ded0028ce6f9cd863264237f3970559dea2b81456e9ac4622b94 \
+    --hash=sha256:48b3d87eb560ff6a772240506f3c78d6d27c63cafedd5c775672e1194f968cfd \
+    --hash=sha256:54c0c4e9202c36c4ecdb1f3443f5dfbfd5ee3b54d1362c4b4c6134110e74fb32 \
+    --hash=sha256:6872443f236a554921cda6f318c900e2d0c226792cf3534d00e5057c6926e5d2 \
+    --hash=sha256:75fbc1e1fb43a39a856c8209c544cca7817b5de7ac16b15b1bdf55d1cc67b9df \
+    --hash=sha256:760021bca514d64a811837820d351a08a41741f16f8b4c26450da708fecf14e6 \
+    --hash=sha256:7c65a7438632d55dfbc8a02ee60bd6cf7dd9d1ba05a43d4b851452f32338e194 \
+    --hash=sha256:8ba14a38c570087f3cdb8cfba33f7a38a1e826c1e5b29e17c28ceda0cc910016 \
+    --hash=sha256:a14c2ce45312def86b77aea651f46565e45960cf5f0721bfdff449165086ab76 \
+    --hash=sha256:b3e5b58b8c89c2b20e086e890aa9527377e5c240dc3ecc1640d18e07705eeb1c \
+    --hash=sha256:c6fddce0539a4898c7bef35b052ffd37935b2190e35488eab99ce91887743ea1 \
+    --hash=sha256:d0d1f68868e2ef30ef70998ba9bbbc5c305e9b17041e3936751c1b8aa6aade06 \
+    --hash=sha256:e4f7b0e90d2d212e2c2deaa6c8291616183ab815d3ec558ea12d3ac8b26d36f4 \
+    --hash=sha256:ff050e4f6bf7f12918fa14dcb047c0b02e295f35e86d42532552be4b3d54e977
+    # via optimum-onnx
+onnxscript==0.7.1 \
+    --hash=sha256:309fb86484b11fa4ded90dba580e0d63f1a0827588e521cecaf2eeddb46d6e86 \
+    --hash=sha256:544763b7fdef49940cdd9412ff5135cbae96d59ac6bc1921457f21280f40f4b7
+    # via mobiletransformers
+optimum==2.1.0 \
+    --hash=sha256:0a2a13f91500e41d34863ffdb08fcb886b3ce68a84a386e59653e3064a45dd4b \
+    --hash=sha256:bc3af32e1236a9b2c2ca1d27ed9d3ab1b6591e24c6bcd47f9671a8198a30ea88
+    # via optimum-onnx
+optimum-onnx==0.1.0 \
+    --hash=sha256:0301ec7a6ec5c77a57581e9970d380a6dc104bdb8f15b282e05af40d829c2eda \
+    --hash=sha256:182c54b25eddaded1618af7b58516da34749393a987ec7111f74677f249676f9
+    # via mobiletransformers
+packaging==25.0 \
+    --hash=sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484 \
+    --hash=sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f
+    # via
+    #   huggingface-hub
+    #   onnxruntime
+    #   onnxscript
+    #   optimum
+    #   pytest
+    #   transformers
+pathspec==1.1.1 \
+    --hash=sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+    # via mypy
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+protobuf==7.35.1 \
+    --hash=sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799 \
+    --hash=sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87 \
+    --hash=sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6 \
+    --hash=sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30 \
+    --hash=sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9 \
+    --hash=sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4 \
+    --hash=sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4 \
+    --hash=sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a
+    # via
+    #   onnx
+    #   onnxruntime
+pydantic==2.13.4 \
+    --hash=sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba \
+    --hash=sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6
+    # via mobiletransformers
+pydantic-core==2.46.4 \
+    --hash=sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0 \
+    --hash=sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262 \
+    --hash=sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda \
+    --hash=sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0 \
+    --hash=sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b \
+    --hash=sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594 \
+    --hash=sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2 \
+    --hash=sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c \
+    --hash=sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d \
+    --hash=sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398 \
+    --hash=sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d \
+    --hash=sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3 \
+    --hash=sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f \
+    --hash=sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7 \
+    --hash=sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4 \
+    --hash=sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d \
+    --hash=sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df \
+    --hash=sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2 \
+    --hash=sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd \
+    --hash=sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7 \
+    --hash=sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3 \
+    --hash=sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a \
+    --hash=sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987 \
+    --hash=sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e \
+    --hash=sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712 \
+    --hash=sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008 \
+    --hash=sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1 \
+    --hash=sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be \
+    --hash=sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea \
+    --hash=sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292 \
+    --hash=sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33 \
+    --hash=sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826 \
+    --hash=sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7 \
+    --hash=sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d \
+    --hash=sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf \
+    --hash=sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc \
+    --hash=sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3 \
+    --hash=sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b \
+    --hash=sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04 \
+    --hash=sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c \
+    --hash=sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b \
+    --hash=sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce \
+    --hash=sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4 \
+    --hash=sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a \
+    --hash=sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f \
+    --hash=sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894 \
+    --hash=sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9 \
+    --hash=sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76 \
+    --hash=sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb \
+    --hash=sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109 \
+    --hash=sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4 \
+    --hash=sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848 \
+    --hash=sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526 \
+    --hash=sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01 \
+    --hash=sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458 \
+    --hash=sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba \
+    --hash=sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39 \
+    --hash=sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b \
+    --hash=sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf \
+    --hash=sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4 \
+    --hash=sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd \
+    --hash=sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30 \
+    --hash=sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983 \
+    --hash=sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5 \
+    --hash=sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4 \
+    --hash=sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7 \
+    --hash=sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c \
+    --hash=sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3 \
+    --hash=sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89 \
+    --hash=sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50 \
+    --hash=sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76 \
+    --hash=sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b \
+    --hash=sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d \
+    --hash=sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4 \
+    --hash=sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c \
+    --hash=sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e
+    # via pydantic
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==9.1.1 \
+    --hash=sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313 \
+    --hash=sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c
+python-dotenv==1.2.2 \
+    --hash=sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a \
+    --hash=sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3
+    # via mobiletransformers
+pyyaml==6.0.3 \
+    --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \
+    --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \
+    --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \
+    --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \
+    --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \
+    --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \
+    --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \
+    --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \
+    --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via
+    #   huggingface-hub
+    #   mobiletransformers
+    #   transformers
+regex==2026.7.10 \
+    --hash=sha256:0639b2488b775a0109f55a5a2172deebdedb4b6c5ab0d48c90b43cbf5de58d17 \
+    --hash=sha256:081acf191b4d614d573a56cab69f948b6864daa5e3cc69f209ee92e26e454c2f \
+    --hash=sha256:1050fedf0a8a92e843971120c2f57c3a99bea86c0dfa1d63a9fac053fe54b135 \
+    --hash=sha256:13fba679fe035037e9d5286620f88bbfd105df4d5fcd975942edd282ab986775 \
+    --hash=sha256:14d27f6bd04beb01f6a25a1153d73e58c290fd45d92ba56af1bb44199fd1010d \
+    --hash=sha256:1f0d4ccf70b1d13711242de0ba78967db5c35d12ac408378c70e06295c3f6644 \
+    --hash=sha256:21150500b970b12202879dfd82e7fd809d8e853140fff84d08e57a90cf1e154e \
+    --hash=sha256:221f2771cb780186b94bbf125a151bbeb242fa1a971da6ad59d7b0370f19de9a \
+    --hash=sha256:234f8e0d65cf1df9becadae98648f74030ee85a8f12edcb5eb0f60a22a602197 \
+    --hash=sha256:28a0973eeffff4292f5a7ee498ab65d5e94ee8cc9cea364239251eb4a260a0f1 \
+    --hash=sha256:2b93eafd92c4128bab2f93500e8912cc9ecb3d3765f6685b902c6820d0909b6b \
+    --hash=sha256:2bc350e1c5fa250f30ab0c3e38e5cfdffcd82cb8af224df69955cab4e3003812 \
+    --hash=sha256:2c66a8a1969cfd506d1e203c0005fd0fc3fe6efc83c945606566b6f9611d4851 \
+    --hash=sha256:2f98ef73a13791a387d5c841416ad7f52040ae5caf10bcf46fa12bd2b3d63745 \
+    --hash=sha256:31fa17378b29519bfd0a1b8ba4e9c10cf0baf1cf4099b39b0689429e7dc2c795 \
+    --hash=sha256:3750c42d47712e362158a04d0fd80131f73a55e8c715b2885442a0ff6f9fc3fc \
+    --hash=sha256:396ea70e4ea1f19571940add3bad9fd3eb6a19dc610d0d01f692bc1ba0c10cb4 \
+    --hash=sha256:3d8ef9df02c8083c7b4b855e3cb87c8e0ebbcfea088d98c7a886aaefdf88d837 \
+    --hash=sha256:3e23458d8903e33e7d27196d7a311523dc4e2f4137a5f34e4dbd30c8d37ff33e \
+    --hash=sha256:3f03b92fb6ec739df042e45b06423fc717ecf0063e07ffe2897f7b2d5735e1e8 \
+    --hash=sha256:41a47c2b28d9421e2509a4583a22510dc31d83212fcf38e1508a7013140f71a8 \
+    --hash=sha256:4574feca202f8c470bf678aed8b5d89df04aaf8dc677f3b83d92825051301c0f \
+    --hash=sha256:4db009b4fc533d79af3e841d6c8538730423f82ea8508e353a3713725de7901c \
+    --hash=sha256:53bbbd6c610489700f7110db1d85f3623924c3f7c760f987eca033867360788a \
+    --hash=sha256:53f54993b462f3f91fea0f2076b46deb6619a5f45d70dbd1f543f789d8b900ef \
+    --hash=sha256:58a4571b2a093f6f6ee4fd281faa8ebf645abcf575f758173ea2605c7a1e1ecb \
+    --hash=sha256:5c363de7c0339d39341b6181839ed32509820b85ef506deafcf2e7e43baadab4 \
+    --hash=sha256:5e792367e5f9b4ffb8cad93f1beaa91837056b94da98aa5c65a0db0c1b474927 \
+    --hash=sha256:617e8f10472e34a8477931f978ff3a88d46ae2ba0e41927e580b933361f60948 \
+    --hash=sha256:64722a5031aeace7f6c8d5ea9a9b22d9368af0d6e8fa532585da8158549ea963 \
+    --hash=sha256:65ee5d1ac3cd541325f5ac92625b1c1505f4d171520dd931bda7952895c5321a \
+    --hash=sha256:66d2c35587cd601c95965d5c0415058ba5cfd6ffbab7624ce198bd967102b341 \
+    --hash=sha256:6cbedeb5112f59dbd169385459b9943310bdd241c6966c19c5f6e2295055c93a \
+    --hash=sha256:724ee9379568658ec06362cf24325c5315cc5a67f61dfe585bfeff58300a355b \
+    --hash=sha256:7252b48b0c60100095088fbeb281fca9a4fcf678a4e04b1c520c3f8613c952c4 \
+    --hash=sha256:732c19e5828eb287d01edb83b2eb87f283ba8e5fc3441c732709d3e8cbd14aaa \
+    --hash=sha256:74ae61d8573ecd51b5eeee7be2218e4c56e99c14fa8fcf97cf7519611d4be92e \
+    --hash=sha256:799a369bdab91dcf0eb424ebd7aa9650897025ce22f729248d8f2c72002c4daa \
+    --hash=sha256:80151ca5bfc6c4524186b3e08b499e97319b2001fc265ed2d4fc12c0d5692cdf \
+    --hash=sha256:82ab8330e7e2e416c2d42fcec67f02c242393b8681014750d4b70b3f158e1f08 \
+    --hash=sha256:8331484450b3894298bef8abecce532171ff6ac60b71f999eed10f2c01941a8a \
+    --hash=sha256:87794549a3f5c1c2bdfba2380c1bf87b931e375f4133d929da44f95e396bf5fe \
+    --hash=sha256:87b776cf2890e356e4ab104b9df846e169da3eb5b0f110975547091f4e51854e \
+    --hash=sha256:8e26a075fa9945b9e44a3d02cc83d776c3b76bb1ff4b133bbfa620d5650131da \
+    --hash=sha256:91b916d495db3e1b473c7c8e68733beec4dce8e487442db61764fff94f59740e \
+    --hash=sha256:948dfc62683a6947b9b486c4598d8f6e3ecc542478b6767b87d52be68aeb55c6 \
+    --hash=sha256:982d07727c809b42a3968785354f11c3728414e4e90af0754345b431b2c32561 \
+    --hash=sha256:9a094ed44a22f9da497453137c3118b531fd783866ab524b0b0fc146e7395e1d \
+    --hash=sha256:9d028d189d8f38d7ff292f22187c0df37f2317f554d2ed9a2908ada330af57c0 \
+    --hash=sha256:a2d6d30be35ddd70ce0f8ee259a4c25f24d6d689a45a5ac440f03e6bcc5a21d1 \
+    --hash=sha256:a68b637451d64ba30ed8ae125c973fa834cc2d37dfa7f154c2b479015d477ba8 \
+    --hash=sha256:aa34473fbcc108fea403074f3f45091461b18b2047d136f16ffaa4c65ad46a68 \
+    --hash=sha256:ab2fb1f7a2deb4ca3ddebbae6b93905d21480a3b4e11de28d79d9fb0d316fcf8 \
+    --hash=sha256:ab39d2c967aae3b48a412bff9cdbe7cd7559cd1e277599aceaeada7bc82b7200 \
+    --hash=sha256:b04583e8867136ae66353fa274f45121ab3ec3166dc45aaff3655a5db90d9f0e \
+    --hash=sha256:b1963ec5ba4d52788fb0eac6aca6eb8040e8e318c7e47ebbdfc09440c802919c \
+    --hash=sha256:b56416091bfd7a429f958f69aaf6823c517be9a49cb5bf1daa3767ce8bf8095e \
+    --hash=sha256:b96341cb29a3faa5db05aff29c77d141d827414f145330e5d8846892119351c1 \
+    --hash=sha256:bb52e10e453b5493afe1f7702a2973bc10f4dd8901c0f2ed869ffaa3f8319296 \
+    --hash=sha256:bb5aab464a0c5e03a97abad5bdf54517061ebbf72340d576e99ff661a42575cc \
+    --hash=sha256:be4223af640d0aa04c05db81d5d96ada3ead9c09187d892fd37f4f97829480be \
+    --hash=sha256:c2cbd385d82f63bb35edb60b09b08abad3619bd0a4a492ae59e55afaf98e1b9d \
+    --hash=sha256:c57b6ad3f7a1bdd101b2966f29dc161adf49727b1e8d3e1e89db2eda8a75c344 \
+    --hash=sha256:c622f4c638a725c39abcb2e680b1bd592663c83b672a4ed350a17f806d75618e \
+    --hash=sha256:cae27622c094558e519abf3242cf4272db961d12c5c9a9ffb7a1b44b2627d5c6 \
+    --hash=sha256:cfcec18f7da682c4e2d82112829ce906569cb8d69fa6c26f3a50dfbed5ceb682 \
+    --hash=sha256:d0834c84ae8750ae1c4cede59b0afd4d2f775be958e11b18a3eea24ed9d0d9f1 \
+    --hash=sha256:d3c75d57a00109255e60bc9c623b6ececaf7905eaab845c79f036670ed4750a2 \
+    --hash=sha256:da6ef4cb8d457aab0482b50120136ae94238aaa421863eaa7d599759742c72d6 \
+    --hash=sha256:e21e888a6b471b2bb1cdd4247e8d86632672232f29be583e7eafaa5f4634d34c \
+    --hash=sha256:e37aba1994d73b4944053ab65a15f313bd5c28c885dd7f0d494a11749d89db6e \
+    --hash=sha256:e6b6a11bf898cca3ce7bfaa17b646901107f3975677fbd5097f36e5eb5641983 \
+    --hash=sha256:eac1207936555aa691ce32df1432b478f2729d54e6d93a1f4db9215bcd8eb47d \
+    --hash=sha256:ebbf0d83ed5271991d666e54bb6c90ac2c55fb2ef3a88740c6af85dc85de2402 \
+    --hash=sha256:ecae626449d00db8c08f8f1fc00047a32d6d7eb5402b3976f5c3fda2b80a7a4f \
+    --hash=sha256:ed7c886a2fcbf14493ceaf9579394b33521730c161ebb8dad7db9c3e9fcab1a8 \
+    --hash=sha256:ee877b6d78f9dff1da94fef51ae8cf9cce0967e043fdcc864c40b85cf293c192 \
+    --hash=sha256:f0192e5f1cfc70e3cb35347135dd02e7497b3e7d83e378aa226d8b3e53a93f19 \
+    --hash=sha256:f3463a5f26be513a49e4d497debcf1b252a2db7b92c77d89621aa90b83d2dd38 \
+    --hash=sha256:f6222cafe00e072bb2b8f14142cd969637411fbc4dd3b1d73a90a3b817fa046f \
+    --hash=sha256:fadb07dbe36a541283ff454b1a268afd54b077d917043f2e1e5615372cb5f200 \
+    --hash=sha256:fe7ff456c22725c9d9017f7a2a7df2b51af6df77314176760b22e2d05278e181
+    # via transformers
+requests==2.34.2 \
+    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
+    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
+    # via
+    #   huggingface-hub
+    #   transformers
+ruff==0.15.21 \
+    --hash=sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075 \
+    --hash=sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be \
+    --hash=sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd \
+    --hash=sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd \
+    --hash=sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86 \
+    --hash=sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341 \
+    --hash=sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd \
+    --hash=sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67 \
+    --hash=sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41 \
+    --hash=sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d \
+    --hash=sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d \
+    --hash=sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8 \
+    --hash=sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233 \
+    --hash=sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8 \
+    --hash=sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500 \
+    --hash=sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3 \
+    --hash=sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646 \
+    --hash=sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f
+safetensors==0.8.0 \
+    --hash=sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358 \
+    --hash=sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f \
+    --hash=sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d \
+    --hash=sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d \
+    --hash=sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0 \
+    --hash=sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc \
+    --hash=sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235 \
+    --hash=sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98 \
+    --hash=sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4 \
+    --hash=sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846 \
+    --hash=sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca \
+    --hash=sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0 \
+    --hash=sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25 \
+    --hash=sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452 \
+    --hash=sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d \
+    --hash=sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78 \
+    --hash=sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774
+    # via transformers
+setuptools==83.0.0 ; (python_full_version >= '3.12' and platform_machine != 'x86_64') or (python_full_version >= '3.12' and sys_platform != 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') \
+    --hash=sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef \
+    --hash=sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3
+    # via
+    #   torch
+    #   triton
+sympy==1.14.0 \
+    --hash=sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517 \
+    --hash=sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5
+    # via
+    #   onnx-ir
+    #   onnxruntime
+    #   torch
+tokenizers==0.22.2 \
+    --hash=sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e \
+    --hash=sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001 \
+    --hash=sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7 \
+    --hash=sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd \
+    --hash=sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4 \
+    --hash=sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67 \
+    --hash=sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a \
+    --hash=sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5 \
+    --hash=sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917 \
+    --hash=sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c \
+    --hash=sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195 \
+    --hash=sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4 \
+    --hash=sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a \
+    --hash=sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc \
+    --hash=sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92 \
+    --hash=sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5 \
+    --hash=sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48 \
+    --hash=sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b \
+    --hash=sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c \
+    --hash=sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5
+    # via
+    #   mobiletransformers
+    #   transformers
+tomli==2.4.1 ; python_full_version < '3.11' \
+    --hash=sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe \
+    --hash=sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5 \
+    --hash=sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd \
+    --hash=sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54 \
+    --hash=sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c \
+    --hash=sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a \
+    --hash=sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd \
+    --hash=sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5 \
+    --hash=sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9 \
+    --hash=sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9 \
+    --hash=sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1 \
+    --hash=sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585 \
+    --hash=sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e \
+    --hash=sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f \
+    --hash=sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085 \
+    --hash=sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36 \
+    --hash=sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076 \
+    --hash=sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece \
+    --hash=sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a \
+    --hash=sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897 \
+    --hash=sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d \
+    --hash=sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917 \
+    --hash=sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a \
+    --hash=sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc \
+    --hash=sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f \
+    --hash=sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257 \
+    --hash=sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30 \
+    --hash=sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9 \
+    --hash=sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049
+    # via
+    #   mypy
+    #   pytest
+torch==2.7.1 \
+    --hash=sha256:03563603d931e70722dce0e11999d53aa80a375a3d78e6b39b9f6805ea0a8d28 \
+    --hash=sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1 \
+    --hash=sha256:0da4f4dba9f65d0d203794e619fe7ca3247a55ffdcbd17ae8fb83c8b2dc9b585 \
+    --hash=sha256:23660443e13995ee93e3d844786701ea4ca69f337027b05182f5ba053ce43b38 \
+    --hash=sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2 \
+    --hash=sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa \
+    --hash=sha256:30207f672328a42df4f2174b8f426f354b2baa0b7cca3a0adb3d6ab5daf00dc8 \
+    --hash=sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb \
+    --hash=sha256:79042feca1c634aaf6603fe6feea8c6b30dfa140a6bbc0b973e2260c7e79a22e \
+    --hash=sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52 \
+    --hash=sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162 \
+    --hash=sha256:988b0cbc4333618a1056d2ebad9eb10089637b659eb645434d0809d8d937b946 \
+    --hash=sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f \
+    --hash=sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730 \
+    --hash=sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc \
+    --hash=sha256:d632f5417b6980f61404a125b999ca6ebd0b8b4bbdbb5fbbba44374ab619a412 \
+    --hash=sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c \
+    --hash=sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b \
+    --hash=sha256:e08d7e6f21a617fe38eeb46dd2213ded43f27c072e9165dc27300c9ef9570934 \
+    --hash=sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d
+    # via optimum
+tqdm==4.68.4 \
+    --hash=sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520 \
+    --hash=sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2
+    # via
+    #   huggingface-hub
+    #   transformers
+transformers==4.57.6 \
+    --hash=sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550 \
+    --hash=sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3
+    # via
+    #   mobiletransformers
+    #   optimum
+    #   optimum-onnx
+triton==3.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43 \
+    --hash=sha256:a3198adb9d78b77818a5388bff89fa72ff36f9da0bc689db2f0a651a67ce6a42 \
+    --hash=sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b \
+    --hash=sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e \
+    --hash=sha256:b89d846b5a4198317fec27a5d3a609ea96b6d557ff44b56c23176546023c4240
+    # via torch
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via
+    #   exceptiongroup
+    #   huggingface-hub
+    #   mypy
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+    #   pydantic
+    #   pydantic-core
+    #   torch
+    #   typing-inspection
+typing-inspection==0.4.2 \
+    --hash=sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7 \
+    --hash=sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464
+    # via pydantic
+urllib3==2.7.0 \
+    --hash=sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c \
+    --hash=sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897
+    # via requests
diff --git a/requirements/requirements-rag.lock.txt b/requirements/requirements-rag.lock.txt
new file mode 100644
index 0000000..8911619
--- /dev/null
+++ b/requirements/requirements-rag.lock.txt
@@ -0,0 +1,2248 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-emit-project --extra rag --format requirements.txt -o requirements/requirements-rag.lock.txt
+aiohappyeyeballs==2.7.1 \
+    --hash=sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d \
+    --hash=sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472
+    # via aiohttp
+aiohttp==3.14.1 \
+    --hash=sha256:03ab4530fdcb3a543a122ba4b65ac9919da9fe9f78a03d328a6e38ff962f7aa5 \
+    --hash=sha256:092e4ce3619a7c6dee52a6bdabda973d9b34b66781f840ce93c7e0cec30cf521 \
+    --hash=sha256:1ac8531b638959718e18c2207fbfe297819875da46a740b29dfa29beba64355a \
+    --hash=sha256:1b9748363260121d2927704f5d4fc498150669ca3ae93625986ee89c8f80dcd4 \
+    --hash=sha256:1c1421eb01d4fd608d88cc8290211d177a58532b55ad94076fb349c5bf467f0a \
+    --hash=sha256:1c1af67559445498b502030c35c59db59966f47041ca9de5b4e707f86bd10b5f \
+    --hash=sha256:1d459b98a932296c6f0e94f87511a0b1b90a8a02c30a50e60a297619cd5a58ee \
+    --hash=sha256:23119f8fd4f5d16902ed459b63b100bcd269628075162bddac56cc7b5273b3fb \
+    --hash=sha256:24ba13339fed9251d9b1a1bec8c7ab84c0d1675d79d33501e11f94f8b9a84e05 \
+    --hash=sha256:250d14af67f6b6a1a4a811049b1afa69d61d617fca6bf33149b3ab1a6dbcf7b8 \
+    --hash=sha256:269b76ac5394092b95bc4a098f4fc6c191c083c3bd12775d1e30e663132f6a09 \
+    --hash=sha256:27fd7c91e51729b4f7e1577865fa6d34c9adccbc39aabe9000285b48af9f0ec2 \
+    --hash=sha256:2a73f487ab8ef5abbb24b7aa9b73e98eaba9e9e031804ff2416f02eca315ccaf \
+    --hash=sha256:2aa92c87868cd13674989f9ee83e5f9f7ea4237589b728048e1f0c8f6caa3271 \
+    --hash=sha256:2c840c90759922cb5e6dda94596e079a30fb5a5ba548e7e0dc00574703940847 \
+    --hash=sha256:2f73e01dc37122325caf079982621262f96d74823c179038a82fddfc50359264 \
+    --hash=sha256:2fbc3ed048b3475b9f0cbcb9978e9d2d3511acd91ead203af26ed9f0056004cf \
+    --hash=sha256:2fe3607e71acc6ebb0ec8e492a247bf7a291226192dc0084236dfc12478916f6 \
+    --hash=sha256:30099eda75a53c32efb0920e9c33c195314d2cc1c680fbfd30894932ac5f27df \
+    --hash=sha256:307f2cff90a764d329e77040603fa032db89c5c24fdad50c4c15334cba744035 \
+    --hash=sha256:313701e488100074ce99850404ee36e741abf6330179fec908a1944ecf570126 \
+    --hash=sha256:317acd9f8602858dc7d59679812c376c7f0b97bcbbf16e0d6237f54141d8a8a6 \
+    --hash=sha256:34b257ec41345c1e8f2df68fa908a7952f5de932723871eb633ecbbff396c9a4 \
+    --hash=sha256:3e6fc1a85fa7194a1a7d19f44e8609180f4a8eb5fa4c7ed8b4355f080fad235c \
+    --hash=sha256:486f7d16ed54c39c2cbd7ca71fd8ba2b8bb7860df65bd7b6ed640bab96a38a8b \
+    --hash=sha256:4cd96b5ba05d67ed0cf00b5b405c8cd99586d8e3481e8ee0a831057591af7621 \
+    --hash=sha256:4dfd6e47d3c44c2279907607f73a4240b88c69eb8b90da7e2441a8045dfd21da \
+    --hash=sha256:4f7215cb3933784f79ed20e5f050e15984f390424339b22375d5a53c933a0491 \
+    --hash=sha256:52cdac9432d8b4a719f35094a818d95adcae0f0b4fe9b9b921909e0c87de9e7d \
+    --hash=sha256:5663ee9257cfa1add7253a7da3035a02f31b6600ec48261585e1800a81533080 \
+    --hash=sha256:57fc6745a4b7d0f5a9eb4f40a69718be6c0bc1b8368cc9fe89e90118719f4f42 \
+    --hash=sha256:5a837f49d901f9e368651b676912bff1104ed8c1a83b280bcd7b29adccef5c9c \
+    --hash=sha256:5c0b3e614340c889d575451696374c9d17affd54cd607ca0babed8f8c37b9397 \
+    --hash=sha256:5f2504bc0322437c9a1ff6d3333ca56c7477b727c995f036b976ae17b98372c8 \
+    --hash=sha256:603a2c834142172ffddc054067f5ec0ca65d57a0aa98a71bc81952573208e345 \
+    --hash=sha256:64c567bf9eaf664280116a8688f63016e6b32db2505908e2bdaca1b6438142f2 \
+    --hash=sha256:672ac254412a24d0d0cf00a9e6c238877e4be5e5fa2d188832c1244f45f31966 \
+    --hash=sha256:672b9d65f42eb877f5c3f234a4547e4e1a226ca8c2eed879bb34670a0ce51192 \
+    --hash=sha256:686b6c0d3911ec387b444ddf5dc62fb7f7c0a7d5186a7861626496a5ab4aff95 \
+    --hash=sha256:6f71173be42d3241d428f760122febb748de0623f44308a6f120d0dd9ec572e3 \
+    --hash=sha256:6fd35beba67c4183b09375c5fff9accb47524191a244a99f95fd4472f5402c2b \
+    --hash=sha256:73f05ea02013e02512c3bf42714f1208c57168c779cc6fe23516e4543089d0a6 \
+    --hash=sha256:764457a7be60825fb770a644852ff717bcbb5042f189f2bd16df61a81b3f6573 \
+    --hash=sha256:797457503c2d426bee06eef808d07b31ede30b65e054444e7de64cad0061b7af \
+    --hash=sha256:7fb4bdf95b0561a79f259f9d28fbc109728c5ee7f27aff6391f0ca703a329abe \
+    --hash=sha256:86a6dab78b0e43e2897a3bbe15745aa60dc5423ca437b7b0b164c069bf91b876 \
+    --hash=sha256:87a5eea1b2a5e21e1ebdbb33ad4165359189327e63fc4e4894693e7f821ac817 \
+    --hash=sha256:8f6bb621e5863cfe8fe5ff5468002d200ec31f30f1280b259dc505b02595099e \
+    --hash=sha256:915fbb7b41b115192259f8c9ae58f3ddc444d2b5579917270211858e606a4afd \
+    --hash=sha256:93b032b5ec3255473c143627d21a69ac74ae12f7f33974cb587c564d11b1066f \
+    --hash=sha256:94da27378da0610e341c4d30de29a191672683cc82b8f9556e8f7c7212a020fe \
+    --hash=sha256:97e704dcd26271f5bda3fa07c3ce0fb76d6d3f8659f4baa1a24442cc9ba177ca \
+    --hash=sha256:9af6779bfb46abf124068327abcdf9ce95c9ef8287a3e8da76ccf2d0f16c28fa \
+    --hash=sha256:aa00140699487bd435fde4342d85c94cb256b7cd3a5b9c3396c67f19922afda2 \
+    --hash=sha256:b238af795833d5731d049d82bc84b768ae6f8f97f0495963b3ed9935c5901cc3 \
+    --hash=sha256:b3a03285a7f9c7b016324574a6d92a1c895da6b978cb8f1deee3ac72bc6da178 \
+    --hash=sha256:b6feea921016eb3d4e04d65fc4e9ca402d1a3801f562aef94989f54694917af3 \
+    --hash=sha256:b821a1f7dedf7e37450654e620038ac3b2e81e8fa6ea269337e97101978ec730 \
+    --hash=sha256:bb2c0c80d431c0d03f2c7dbf125150fedd4f0de17366a7ca33f7ccb822391842 \
+    --hash=sha256:bb33777ea21e8b7ecde0e6fc84f598be0a1192eab1a63bc746d75aa75d38e7bd \
+    --hash=sha256:bcfb80a2cc36fba2534e5e5b5264dc7ae6fcd9bf15256da3e53d2f499e6fa29d \
+    --hash=sha256:bd869c427324e5cb15195793de951295710db28be7d818247f3097b4ab5d4b96 \
+    --hash=sha256:bedb0cd073cc2dc035e30aeb99444389d3cd2113afe4ef9fcd23d439f5bade85 \
+    --hash=sha256:c6fa4dc7ad6f8109c70bb1499e589f76b0b792baf39f9b017eb92c8a81d0a199 \
+    --hash=sha256:cb21957bb8aca671c1765e32f58164cf0c50e6bf41c0bbbd16da20732ecaf588 \
+    --hash=sha256:d35143e27778b4bb0fb189562d7f275bff79c62ab8e98459717c0ea617ff2480 \
+    --hash=sha256:d3b1a184a9a8f548a6b73f1e26b96b052193e4b3175ed7342aaf1151a1f00a04 \
+    --hash=sha256:d44ec478e713ee7f29b439f7eb8dc2b9d4079e11ae114d2c2ac3d5daf30516c8 \
+    --hash=sha256:d9d4e294455b23a68c9b8f042d0e8e377a265bcb15332753695f6e5b6819e0ce \
+    --hash=sha256:de538791a80e5d862addbc183f70f0158ac9b9bb872bb147f1fd2a683691e087 \
+    --hash=sha256:e4e5e0ae56914ecdbf446493addefc0159053dd53962cef37d7839f37f73d505 \
+    --hash=sha256:e509a55f681e6158c20f70f102f9cf61fb20fbc382272bc6d94b7343f2582780 \
+    --hash=sha256:ec8dc383ee57ea3e883477dcca3f11b65d58199f1080acaf4cd6ad9a99698be4 \
+    --hash=sha256:f234b4deb12f3ad59127e037bc57c40c21e45b45282df7d3a55a0f409f595296 \
+    --hash=sha256:f380468b09d2a81633ee863b0ec5648d364bd17bb8ecfb8c2f387f7ac1faf42c \
+    --hash=sha256:f5e6ff2bdbb8f4cd3fbe41f99e25bbcd58e3bf9f13d3dd31a11e7917251cc77a \
+    --hash=sha256:f7a16ef45b081454ef844502d87a848876c490c4cb5c650c230f6ec79ed2c1e7 \
+    --hash=sha256:faccab372e66bc76d5731525e7f1143c922271725b9d38c9f97edcc66266b451
+    # via langchain-community
+aiosignal==1.4.0 \
+    --hash=sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e \
+    --hash=sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7
+    # via aiohttp
+annotated-types==0.7.0 \
+    --hash=sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 \
+    --hash=sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89
+    # via pydantic
+anyio==4.14.2 \
+    --hash=sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494 \
+    --hash=sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f
+    # via
+    #   httpx
+    #   langsmith
+ast-serialize==0.6.0 \
+    --hash=sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596 \
+    --hash=sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e \
+    --hash=sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a \
+    --hash=sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a \
+    --hash=sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790 \
+    --hash=sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e \
+    --hash=sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1 \
+    --hash=sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b \
+    --hash=sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe \
+    --hash=sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b \
+    --hash=sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32 \
+    --hash=sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081 \
+    --hash=sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b \
+    --hash=sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e \
+    --hash=sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77 \
+    --hash=sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b \
+    --hash=sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7 \
+    --hash=sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad
+    # via mypy
+async-timeout==4.0.3 ; python_full_version < '3.11' \
+    --hash=sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f \
+    --hash=sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028
+    # via
+    #   aiohttp
+    #   langchain-classic
+attrs==26.1.0 \
+    --hash=sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 \
+    --hash=sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32
+    # via aiohttp
+certifi==2026.6.17 \
+    --hash=sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432 \
+    --hash=sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.9 \
+    --hash=sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62 \
+    --hash=sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c \
+    --hash=sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5 \
+    --hash=sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99 \
+    --hash=sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec \
+    --hash=sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698 \
+    --hash=sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3 \
+    --hash=sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2 \
+    --hash=sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a \
+    --hash=sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419 \
+    --hash=sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da \
+    --hash=sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe \
+    --hash=sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381 \
+    --hash=sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614 \
+    --hash=sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0 \
+    --hash=sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29 \
+    --hash=sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0 \
+    --hash=sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9 \
+    --hash=sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63 \
+    --hash=sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd \
+    --hash=sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde \
+    --hash=sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012 \
+    --hash=sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1 \
+    --hash=sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15 \
+    --hash=sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b \
+    --hash=sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993 \
+    --hash=sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5 \
+    --hash=sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8 \
+    --hash=sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35 \
+    --hash=sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642 \
+    --hash=sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2 \
+    --hash=sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d \
+    --hash=sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9 \
+    --hash=sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33 \
+    --hash=sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db \
+    --hash=sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee \
+    --hash=sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84 \
+    --hash=sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44 \
+    --hash=sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9 \
+    --hash=sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8 \
+    --hash=sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b \
+    --hash=sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39 \
+    --hash=sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0 \
+    --hash=sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616 \
+    --hash=sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d \
+    --hash=sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2 \
+    --hash=sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b \
+    --hash=sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9 \
+    --hash=sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b \
+    --hash=sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209 \
+    --hash=sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a \
+    --hash=sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b \
+    --hash=sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9 \
+    --hash=sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115
+    # via requests
+colorama==0.4.6 ; sys_platform == 'win32' \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via
+    #   pytest
+    #   tqdm
+distro==1.9.0 \
+    --hash=sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed \
+    --hash=sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2
+    # via langsmith
+exceptiongroup==1.3.1 ; python_full_version < '3.11' \
+    --hash=sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219 \
+    --hash=sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598
+    # via
+    #   anyio
+    #   pytest
+filelock==3.29.7 \
+    --hash=sha256:5b481979797ae69e72f0b389d89a80bdd585c260c5b3f1fb9c0a5ba9bb3f195d \
+    --hash=sha256:987db6f789a3a2a59f55081801b2b3697cb97e2a736b5f1a9e99b559285fbc51
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+flatbuffers==24.3.25 \
+    --hash=sha256:8dbdec58f935f3765e4f7f3cf635ac3a77f83568138d6a2311f524ec96364812 \
+    --hash=sha256:de2ec5b203f21441716617f38443e0a8ebf3d25bf0d9c0bb0ce68fa00ad546a4
+    # via objectbox
+frozenlist==1.8.0 \
+    --hash=sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0 \
+    --hash=sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121 \
+    --hash=sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c \
+    --hash=sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84 \
+    --hash=sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d \
+    --hash=sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b \
+    --hash=sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967 \
+    --hash=sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4 \
+    --hash=sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9 \
+    --hash=sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd \
+    --hash=sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7 \
+    --hash=sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed \
+    --hash=sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b \
+    --hash=sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f \
+    --hash=sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25 \
+    --hash=sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143 \
+    --hash=sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e \
+    --hash=sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746 \
+    --hash=sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8 \
+    --hash=sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad \
+    --hash=sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82 \
+    --hash=sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29 \
+    --hash=sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c \
+    --hash=sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf \
+    --hash=sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62 \
+    --hash=sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383 \
+    --hash=sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52 \
+    --hash=sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d \
+    --hash=sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1 \
+    --hash=sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714 \
+    --hash=sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65 \
+    --hash=sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506 \
+    --hash=sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888 \
+    --hash=sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6 \
+    --hash=sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41 \
+    --hash=sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608 \
+    --hash=sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa \
+    --hash=sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1 \
+    --hash=sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186 \
+    --hash=sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e \
+    --hash=sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52 \
+    --hash=sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231 \
+    --hash=sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450 \
+    --hash=sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496 \
+    --hash=sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a \
+    --hash=sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3 \
+    --hash=sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695 \
+    --hash=sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7 \
+    --hash=sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4 \
+    --hash=sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad \
+    --hash=sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b \
+    --hash=sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a \
+    --hash=sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51 \
+    --hash=sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011 \
+    --hash=sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8 \
+    --hash=sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b \
+    --hash=sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042 \
+    --hash=sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e \
+    --hash=sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b \
+    --hash=sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef \
+    --hash=sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d \
+    --hash=sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567 \
+    --hash=sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e \
+    --hash=sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a \
+    --hash=sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52 \
+    --hash=sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1 \
+    --hash=sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94 \
+    --hash=sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f \
+    --hash=sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff \
+    --hash=sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822 \
+    --hash=sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11 \
+    --hash=sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581 \
+    --hash=sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51 \
+    --hash=sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565 \
+    --hash=sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40 \
+    --hash=sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92 \
+    --hash=sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2 \
+    --hash=sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5 \
+    --hash=sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4 \
+    --hash=sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93 \
+    --hash=sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027 \
+    --hash=sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2026.6.0 \
+    --hash=sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1 \
+    --hash=sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a
+    # via
+    #   huggingface-hub
+    #   torch
+greenlet==3.5.3 ; platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64' \
+    --hash=sha256:0909f9355a9f24845d3299f3112e266a06afb68302041989fd26bd68894933db \
+    --hash=sha256:0f41e4a05a3c0cb31b17023eff28dd111e1d16bf7d7d00406cd7df23f31398a7 \
+    --hash=sha256:0f6ff50ff8dbd51fae9b37f4101648b04ea0df19b3f50ab2beb5061e7716a5c8 \
+    --hash=sha256:0f71be4920368fe1fabeeaa53d1e3548337e2b223d9565f8ad5e392a75ba23fc \
+    --hash=sha256:1c514a468149bf8fbbab874188a3535cd8a48a3e353eb53a3d424296f8dbacd3 \
+    --hash=sha256:1dae6e0091eae084317e411f047f0b7cb241c6db570f7c45fd6b900a274914ce \
+    --hash=sha256:215275b1b49320987352e6c1b054acca0064f965a2c66992bed9a6f7d913f149 \
+    --hash=sha256:2ecda9ec22edf38fa389369eaed8c3d37c05f3c54e69f69438dbb2cc1de1458b \
+    --hash=sha256:37bf9c538f5ae6e63d643f88dec37c0c83bdf0e2ebc62961dedcf458822f7b71 \
+    --hash=sha256:483d08c11181c83a6ce1a7a61df0f624a208ec40817a3bb2302714592eee4f04 \
+    --hash=sha256:4d77e67f65f98449e3fb83f795b5d0a8437aead2f874ca89c96576caf4be3af6 \
+    --hash=sha256:5121af01cf911e70056c00d4b46d5e9b5d1415550038573d744138bacb59e6b8 \
+    --hash=sha256:5795cd1101371140551c645f2d408b8d3c01a5a29cf8a9bce6e759c983682d23 \
+    --hash=sha256:6b1b0eed82364b0e32c4ea0f221452d33e6bb17ae094d9f72aed9851812747ea \
+    --hash=sha256:719757059f5a53fd0dde23f78cffeafcdd97b21c850ddb7ca684a3c1a1f122e2 \
+    --hash=sha256:73f152c895e09907e0dbe24f6c2db37beb085cd63db91c3825a0fcd0064124a8 \
+    --hash=sha256:766cfd421c13e450feb340cd472a3ed9957d438727b7b4593ad7c76c5d2b0deb \
+    --hash=sha256:7ef56fe650f50575bf843acde967b9c567687f3c22340941a899b7bc56e956a8 \
+    --hash=sha256:7faba15ac005376e02a0384504e0243be3370ce010296a44a820feb342b505ab \
+    --hash=sha256:8540f1e6205bd13ca0ce685581037219ca54a1b41a0a15d228c6c9b8ad5903d7 \
+    --hash=sha256:87142215824be6ac05e2e8e2786eec307ccbc27c36723c3881959df654af6861 \
+    --hash=sha256:8bdb43e1a1d1873721acab2be99c5befd4d2044ddfd52e4d610801019880a702 \
+    --hash=sha256:915f887cf2682b66419b879423a2e072634aa7b7dce6f3ada4957cfced3f1e9a \
+    --hash=sha256:9ad04dd75458c6300b047c61b8639092433d205a25a14e310d6582a480efcca1 \
+    --hash=sha256:9bcd2d72ccd70a1ec68ba6ef93e7fbb4420ef9997dabc7010d893bd4015e0bec \
+    --hash=sha256:a2d185dd1621757e70c3861cceffd5317ab4e7ed7eb09c82994828468527ade5 \
+    --hash=sha256:a61efc018fd3eb317eeca31aba90ee9e7f26f22884a79b6c6ec715bf71bb62f1 \
+    --hash=sha256:aca9b4ce85b152b5524ef7d88170efdff80dc0032aa8b75f9aaf7f3479ea95b4 \
+    --hash=sha256:af4923b3096e26a36d7e9cf24ab88083a20f97d191e3b97f253731ce9b41b28c \
+    --hash=sha256:afaabdd554cd7ae9bbb3ca070b0d7fdfd207dbf1d16865f7233837709d354bda \
+    --hash=sha256:c180d22d325fb613956b443c3c6f4406eb70e6defc70d3974da2a7b59e06f48c \
+    --hash=sha256:c4e7b79d83805475f0102008843f6eb45fd3bb0b2e88c774adab5fbaab27117d \
+    --hash=sha256:c82304750f057167ff60d188df1d0cc1764ce9567eadf03e6a7443bcedd0b30b \
+    --hash=sha256:c8d87c2134d871df96ecdea9cec7cbaab286dadab0f56476e57aaf9e8ac11550 \
+    --hash=sha256:cde8adafa2365676f74a979744629589999093bc86e2484214f58e61df08902c \
+    --hash=sha256:d27c0c653a60d9535f690226474a5cc1036a8b0d7b57504d1c4f89c44a07a80c \
+    --hash=sha256:dc133a1569ee667b2a6ef56ce551084aeefd87a5acbc4736d336d1e2edc6cfc4 \
+    --hash=sha256:e18619ba655ac05d78d80fc83cac4ba892bd6927b99e3b8237aee861aaacc8bb \
+    --hash=sha256:ec6f1af59f6b5f3fc9678e2ea062d8377d22ac644f7844cb7a292910cf12ff44 \
+    --hash=sha256:efa9f765dd09f9d0cdac651ffdf631ee59ec5dc6ee7a73e0c012ba9c52fbdf5b
+    # via sqlalchemy
+h11==0.16.0 \
+    --hash=sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1 \
+    --hash=sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86
+    # via httpcore
+hf-xet==1.5.1 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' \
+    --hash=sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6 \
+    --hash=sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6 \
+    --hash=sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf \
+    --hash=sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e \
+    --hash=sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947 \
+    --hash=sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d \
+    --hash=sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350 \
+    --hash=sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e \
+    --hash=sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e \
+    --hash=sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283 \
+    --hash=sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4 \
+    --hash=sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8 \
+    --hash=sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577 \
+    --hash=sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43 \
+    --hash=sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff \
+    --hash=sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342 \
+    --hash=sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5
+    # via huggingface-hub
+httpcore==1.0.9 \
+    --hash=sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55 \
+    --hash=sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8
+    # via httpx
+httpx==0.28.1 \
+    --hash=sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc \
+    --hash=sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad
+    # via langsmith
+httpx-sse==0.4.3 \
+    --hash=sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc \
+    --hash=sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d
+    # via langchain-community
+huggingface-hub==0.36.2 \
+    --hash=sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a \
+    --hash=sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270
+    # via
+    #   langchain-huggingface
+    #   mobiletransformers
+    #   sentence-transformers
+    #   tokenizers
+    #   transformers
+idna==3.18 \
+    --hash=sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2 \
+    --hash=sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+iniconfig==2.3.0 \
+    --hash=sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730 \
+    --hash=sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12
+    # via pytest
+jinja2==3.1.6 \
+    --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \
+    --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67
+    # via torch
+joblib==1.5.3 \
+    --hash=sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713 \
+    --hash=sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3
+    # via scikit-learn
+jsonpatch==1.33 \
+    --hash=sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade \
+    --hash=sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c
+    # via langchain-core
+jsonpointer==3.1.1 \
+    --hash=sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900 \
+    --hash=sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca
+    # via jsonpatch
+langchain-classic==1.0.8 \
+    --hash=sha256:1a11ea7fbe630c4f2af2f3873d27718ceac9488cf32d0821030be7cf039a6213 \
+    --hash=sha256:ada0cc341a8a5b80fb24d73bdfaaeb849056ee2d8a41cc468355163fd3667484
+    # via langchain-community
+langchain-community==0.4.2 \
+    --hash=sha256:84dd8c5122532394d5b6849a5fc9995ef28e4f77227daeb09f24b3d942e9e466 \
+    --hash=sha256:a99308160d53d7e9b5965ee665e5173709914338210089fd5788ad724432c21e
+    # via mobiletransformers
+langchain-core==0.3.86 \
+    --hash=sha256:671cbc96a325fe47f7dbab421236ada2d437bc4bfad0038102264885d0b462e2 \
+    --hash=sha256:7d2a1c50d2d2a139dbc6465cd339f32d14aa43db5ac9bd232e5b567a238709e8
+    # via
+    #   langchain-classic
+    #   langchain-community
+    #   langchain-huggingface
+    #   langchain-objectbox
+    #   langchain-text-splitters
+langchain-huggingface==1.2.2 \
+    --hash=sha256:1dd91ec415190d2704e93ec149618e3145075863ba37e74afc9080d685dc2743 \
+    --hash=sha256:f94944b0c0d5afc687568d426c87ed5236907464c41e72108ed76eee1a690f6d
+    # via mobiletransformers
+langchain-objectbox==0.1.0 \
+    --hash=sha256:672d2457d51e73b5714ac583e65f6450de5ccff793a6583fec55119d628bc382 \
+    --hash=sha256:e516a007a6f6e07c747138d40eac3237fa776a178d93d084445531f212258759
+    # via mobiletransformers
+langchain-text-splitters==1.1.2 \
+    --hash=sha256:782a723db0a4746ac91e251c7c1d57fd23636e4f38ed733074e28d7a86f41627 \
+    --hash=sha256:a2de0d799ff31886429fd6e2e0032df275b60ec817c19059a7b46181cc1c2f10
+    # via langchain-classic
+langsmith==0.10.2 \
+    --hash=sha256:9aa685383fbdec07a0df51dafc333ab0d4b6b995771172a232c3364714eb17a6 \
+    --hash=sha256:c2a3929055758ac1831582f0939fafc0973cc08432365bbad335c336338ec37c
+    # via
+    #   langchain-classic
+    #   langchain-community
+    #   langchain-core
+librt==0.13.0 ; platform_python_implementation != 'PyPy' \
+    --hash=sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b \
+    --hash=sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd \
+    --hash=sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a \
+    --hash=sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6 \
+    --hash=sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7 \
+    --hash=sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1 \
+    --hash=sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082 \
+    --hash=sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781 \
+    --hash=sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac \
+    --hash=sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2 \
+    --hash=sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0 \
+    --hash=sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c \
+    --hash=sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14 \
+    --hash=sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5 \
+    --hash=sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde \
+    --hash=sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f \
+    --hash=sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628 \
+    --hash=sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c \
+    --hash=sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db \
+    --hash=sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650 \
+    --hash=sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b \
+    --hash=sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40 \
+    --hash=sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348 \
+    --hash=sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588 \
+    --hash=sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd \
+    --hash=sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927 \
+    --hash=sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89 \
+    --hash=sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3 \
+    --hash=sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5 \
+    --hash=sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9 \
+    --hash=sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176 \
+    --hash=sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a \
+    --hash=sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7 \
+    --hash=sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8 \
+    --hash=sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3 \
+    --hash=sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7 \
+    --hash=sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c \
+    --hash=sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03 \
+    --hash=sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d \
+    --hash=sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1 \
+    --hash=sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9 \
+    --hash=sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b \
+    --hash=sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566 \
+    --hash=sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc \
+    --hash=sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82 \
+    --hash=sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547 \
+    --hash=sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1 \
+    --hash=sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa \
+    --hash=sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a \
+    --hash=sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929 \
+    --hash=sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79 \
+    --hash=sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e \
+    --hash=sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21
+    # via mypy
+markupsafe==3.0.3 \
+    --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \
+    --hash=sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a \
+    --hash=sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf \
+    --hash=sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19 \
+    --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \
+    --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \
+    --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \
+    --hash=sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1 \
+    --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \
+    --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \
+    --hash=sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695 \
+    --hash=sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad \
+    --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \
+    --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \
+    --hash=sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa \
+    --hash=sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559 \
+    --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \
+    --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \
+    --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \
+    --hash=sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c \
+    --hash=sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a \
+    --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \
+    --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \
+    --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \
+    --hash=sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50 \
+    --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \
+    --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \
+    --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \
+    --hash=sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115 \
+    --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \
+    --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \
+    --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \
+    --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \
+    --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \
+    --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \
+    --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \
+    --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \
+    --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \
+    --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \
+    --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \
+    --hash=sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f \
+    --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \
+    --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \
+    --hash=sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c \
+    --hash=sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8 \
+    --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \
+    --hash=sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6 \
+    --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \
+    --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \
+    --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \
+    --hash=sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01 \
+    --hash=sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419 \
+    --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795 \
+    --hash=sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1 \
+    --hash=sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591 \
+    --hash=sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a
+    # via jinja2
+ml-dtypes==0.5.4 \
+    --hash=sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483 \
+    --hash=sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6 \
+    --hash=sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175 \
+    --hash=sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270 \
+    --hash=sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1 \
+    --hash=sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2 \
+    --hash=sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298 \
+    --hash=sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d \
+    --hash=sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de \
+    --hash=sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d \
+    --hash=sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90 \
+    --hash=sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb \
+    --hash=sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453 \
+    --hash=sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48 \
+    --hash=sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff \
+    --hash=sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460 \
+    --hash=sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac \
+    --hash=sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900 \
+    --hash=sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a \
+    --hash=sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c \
+    --hash=sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040 \
+    --hash=sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7 \
+    --hash=sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6 \
+    --hash=sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b \
+    --hash=sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328
+    # via onnx
+mpmath==1.3.0 \
+    --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \
+    --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c
+    # via sympy
+multidict==6.7.1 \
+    --hash=sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9 \
+    --hash=sha256:067343c68cd6612d375710f895337b3a98a033c94f14b9a99eff902f205424e2 \
+    --hash=sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3 \
+    --hash=sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43 \
+    --hash=sha256:0d17522c37d03e85c8098ec8431636309b2682cf12e58f4dbc76121fb50e4962 \
+    --hash=sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c \
+    --hash=sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa \
+    --hash=sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6 \
+    --hash=sha256:17207077e29342fdc2c9a82e4b306f1127bf1ea91f8b71e02d4798a70bb99991 \
+    --hash=sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd \
+    --hash=sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d \
+    --hash=sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3 \
+    --hash=sha256:24c0cf81544ca5e17cfcb6e482e7a82cd475925242b308b890c9452a074d4505 \
+    --hash=sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0 \
+    --hash=sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292 \
+    --hash=sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed \
+    --hash=sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511 \
+    --hash=sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23 \
+    --hash=sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e \
+    --hash=sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582 \
+    --hash=sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0 \
+    --hash=sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e \
+    --hash=sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65 \
+    --hash=sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a \
+    --hash=sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd \
+    --hash=sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d \
+    --hash=sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108 \
+    --hash=sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177 \
+    --hash=sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144 \
+    --hash=sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060 \
+    --hash=sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56 \
+    --hash=sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df \
+    --hash=sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963 \
+    --hash=sha256:5884a04f4ff56c6120f6ccf703bdeb8b5079d808ba604d4d53aec0d55dc33568 \
+    --hash=sha256:59bc83d3f66b41dac1e7460aac1d196edc70c9ba3094965c467715a70ecb46db \
+    --hash=sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118 \
+    --hash=sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84 \
+    --hash=sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71 \
+    --hash=sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7 \
+    --hash=sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8 \
+    --hash=sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49 \
+    --hash=sha256:7dfb78d966b2c906ae1d28ccf6e6712a3cd04407ee5088cd276fe8cb42186190 \
+    --hash=sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d \
+    --hash=sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e \
+    --hash=sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2 \
+    --hash=sha256:8affcf1c98b82bc901702eb73b6947a1bfa170823c153fe8a47b5f5f02e48e40 \
+    --hash=sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3 \
+    --hash=sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c \
+    --hash=sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445 \
+    --hash=sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a \
+    --hash=sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5 \
+    --hash=sha256:974e72a2474600827abaeda71af0c53d9ebbc3c2eb7da37b37d7829ae31232d8 \
+    --hash=sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33 \
+    --hash=sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca \
+    --hash=sha256:9b0d9b91d1aa44db9c1f1ecd0d9d2ae610b2f4f856448664e01a3b35899f3f92 \
+    --hash=sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733 \
+    --hash=sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429 \
+    --hash=sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6 \
+    --hash=sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172 \
+    --hash=sha256:a9fc4caa29e2e6ae408d1c450ac8bf19892c5fca83ee634ecd88a53332c59981 \
+    --hash=sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52 \
+    --hash=sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7 \
+    --hash=sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6 \
+    --hash=sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf \
+    --hash=sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b \
+    --hash=sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961 \
+    --hash=sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3 \
+    --hash=sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b \
+    --hash=sha256:c5f0c21549ab432b57dcc82130f388d84ad8179824cc3f223d5e7cfbfd4143f6 \
+    --hash=sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1 \
+    --hash=sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c \
+    --hash=sha256:c93c3db7ea657dd4637d57e74ab73de31bccefe144d3d4ce370052035bc85fb5 \
+    --hash=sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53 \
+    --hash=sha256:cdea2e7b2456cfb6694fb113066fd0ec7ea4d67e3a35e1f4cbeea0b448bf5872 \
+    --hash=sha256:cf37cbe5ced48d417ba045aca1b21bafca67489452debcde94778a576666a1df \
+    --hash=sha256:d4f49cb5661344764e4c7c7973e92a47a59b8fc19b6523649ec9dc4960e58a03 \
+    --hash=sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8 \
+    --hash=sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a \
+    --hash=sha256:d82dd730a95e6643802f4454b8fdecdf08667881a9c5670db85bc5a56693f122 \
+    --hash=sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a \
+    --hash=sha256:dd96c01a9dcd4889dcfcf9eb5544ca0c77603f239e3ffab0524ec17aea9a93ee \
+    --hash=sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32 \
+    --hash=sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3 \
+    --hash=sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23 \
+    --hash=sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34 \
+    --hash=sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75 \
+    --hash=sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8 \
+    --hash=sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d \
+    --hash=sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855 \
+    --hash=sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4 \
+    --hash=sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba \
+    --hash=sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19
+    # via
+    #   aiohttp
+    #   yarl
+mypy==2.3.0 \
+    --hash=sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491 \
+    --hash=sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5 \
+    --hash=sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd \
+    --hash=sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc \
+    --hash=sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3 \
+    --hash=sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5 \
+    --hash=sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329 \
+    --hash=sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3 \
+    --hash=sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805 \
+    --hash=sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e \
+    --hash=sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7 \
+    --hash=sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494 \
+    --hash=sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88 \
+    --hash=sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee \
+    --hash=sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2 \
+    --hash=sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757 \
+    --hash=sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a \
+    --hash=sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b \
+    --hash=sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461 \
+    --hash=sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97 \
+    --hash=sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117 \
+    --hash=sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36 \
+    --hash=sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac \
+    --hash=sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c \
+    --hash=sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568 \
+    --hash=sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595 \
+    --hash=sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f \
+    --hash=sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1 \
+    --hash=sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6 \
+    --hash=sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c
+mypy-extensions==1.1.0 \
+    --hash=sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505 \
+    --hash=sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558
+    # via mypy
+narwhals==2.24.0 ; python_full_version >= '3.11' \
+    --hash=sha256:42fdedf44e5b2ca7505630d45b4ac3058f38d8485cba9fe1652ca23152df7489 \
+    --hash=sha256:b5c0f684ccd9d7475b564111e319a4964abcf2baf79d3cf6b1003d06ac9b828d
+    # via scikit-learn
+networkx==3.4.2 ; python_full_version < '3.11' \
+    --hash=sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1 \
+    --hash=sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f
+    # via torch
+networkx==3.6.1 ; python_full_version >= '3.11' \
+    --hash=sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509 \
+    --hash=sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762
+    # via torch
+numpy==2.2.6 ; python_full_version < '3.11' \
+    --hash=sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff \
+    --hash=sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47 \
+    --hash=sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84 \
+    --hash=sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d \
+    --hash=sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6 \
+    --hash=sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f \
+    --hash=sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b \
+    --hash=sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49 \
+    --hash=sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163 \
+    --hash=sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571 \
+    --hash=sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42 \
+    --hash=sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff \
+    --hash=sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491 \
+    --hash=sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4 \
+    --hash=sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566 \
+    --hash=sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf \
+    --hash=sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40 \
+    --hash=sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd \
+    --hash=sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06 \
+    --hash=sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282 \
+    --hash=sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680 \
+    --hash=sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db \
+    --hash=sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3 \
+    --hash=sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90 \
+    --hash=sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1 \
+    --hash=sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289 \
+    --hash=sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab \
+    --hash=sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c \
+    --hash=sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d \
+    --hash=sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb \
+    --hash=sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d \
+    --hash=sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a \
+    --hash=sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf \
+    --hash=sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1 \
+    --hash=sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2 \
+    --hash=sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a \
+    --hash=sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543 \
+    --hash=sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00 \
+    --hash=sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c \
+    --hash=sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f \
+    --hash=sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd \
+    --hash=sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868 \
+    --hash=sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303 \
+    --hash=sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83 \
+    --hash=sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3 \
+    --hash=sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d \
+    --hash=sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87 \
+    --hash=sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa \
+    --hash=sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f \
+    --hash=sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae \
+    --hash=sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda \
+    --hash=sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915 \
+    --hash=sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249 \
+    --hash=sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de \
+    --hash=sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8
+    # via
+    #   langchain-community
+    #   ml-dtypes
+    #   mobiletransformers
+    #   objectbox
+    #   onnx
+    #   scikit-learn
+    #   scipy
+    #   sentence-transformers
+    #   transformers
+numpy==2.4.6 ; python_full_version == '3.11.*' \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via
+    #   langchain-community
+    #   ml-dtypes
+    #   mobiletransformers
+    #   objectbox
+    #   onnx
+    #   scikit-learn
+    #   scipy
+    #   sentence-transformers
+    #   transformers
+numpy==2.5.1 ; python_full_version >= '3.12' \
+    --hash=sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2 \
+    --hash=sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1 \
+    --hash=sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b \
+    --hash=sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd \
+    --hash=sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e \
+    --hash=sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277 \
+    --hash=sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6 \
+    --hash=sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7 \
+    --hash=sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1 \
+    --hash=sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9 \
+    --hash=sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca \
+    --hash=sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d \
+    --hash=sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75 \
+    --hash=sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74 \
+    --hash=sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0 \
+    --hash=sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a \
+    --hash=sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3 \
+    --hash=sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1 \
+    --hash=sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6 \
+    --hash=sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9 \
+    --hash=sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3 \
+    --hash=sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2 \
+    --hash=sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107
+    # via
+    #   langchain-community
+    #   ml-dtypes
+    #   mobiletransformers
+    #   objectbox
+    #   onnx
+    #   scikit-learn
+    #   scipy
+    #   sentence-transformers
+    #   transformers
+nvidia-cublas-cu12==12.6.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb \
+    --hash=sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668 \
+    --hash=sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.6.80 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc \
+    --hash=sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4 \
+    --hash=sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132 \
+    --hash=sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73 \
+    --hash=sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53 \
+    --hash=sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13 \
+    --hash=sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a
+    # via torch
+nvidia-cuda-runtime-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd \
+    --hash=sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f \
+    --hash=sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8 \
+    --hash=sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7 \
+    --hash=sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e
+    # via torch
+nvidia-cudnn-cu12==9.5.1.17 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2 \
+    --hash=sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def \
+    --hash=sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8
+    # via torch
+nvidia-cufft-cu12==11.3.0.4 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464 \
+    --hash=sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca \
+    --hash=sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb \
+    --hash=sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5 \
+    --hash=sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6
+    # via torch
+nvidia-cufile-cu12==1.11.1.6 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db \
+    --hash=sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159
+    # via torch
+nvidia-curand-cu12==10.3.7.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905 \
+    --hash=sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8 \
+    --hash=sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e \
+    --hash=sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117 \
+    --hash=sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf
+    # via torch
+nvidia-cusolver-cu12==11.7.1.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0 \
+    --hash=sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7 \
+    --hash=sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6 \
+    --hash=sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e \
+    --hash=sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c
+    # via torch
+nvidia-cusparse-cu12==12.5.4.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f \
+    --hash=sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20 \
+    --hash=sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73 \
+    --hash=sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1 \
+    --hash=sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.6.3 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7 \
+    --hash=sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1 \
+    --hash=sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46
+    # via torch
+nvidia-nccl-cu12==2.26.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522 \
+    --hash=sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6
+    # via torch
+nvidia-nvjitlink-cu12==12.6.85 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41 \
+    --hash=sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c \
+    --hash=sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvtx-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0 \
+    --hash=sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1 \
+    --hash=sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059 \
+    --hash=sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2 \
+    --hash=sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b
+    # via torch
+objectbox==4.0.0 \
+    --hash=sha256:eb1281660ede3923501c47a68c6ad97e551c44061828530731525c7b271cfb2f
+    # via langchain-objectbox
+onnx==1.22.0 \
+    --hash=sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5 \
+    --hash=sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c \
+    --hash=sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914 \
+    --hash=sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc \
+    --hash=sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103 \
+    --hash=sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b \
+    --hash=sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4 \
+    --hash=sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a \
+    --hash=sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c \
+    --hash=sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da \
+    --hash=sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573 \
+    --hash=sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58 \
+    --hash=sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec \
+    --hash=sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b \
+    --hash=sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6 \
+    --hash=sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16 \
+    --hash=sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016 \
+    --hash=sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0 \
+    --hash=sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f
+    # via mobiletransformers
+orjson==3.11.9 ; platform_python_implementation != 'PyPy' \
+    --hash=sha256:011382e2a60fda9d46f1cdee31068cfc52ffe952b587d683ec0463002802a0f4 \
+    --hash=sha256:03db380e3780fa0015ed776a90f20e8e20bb11dde13b216ce19e5718e3dfba62 \
+    --hash=sha256:051b102c93b4f634e89f3866b07b9a9a98915ada541f4ec30f177067b2694979 \
+    --hash=sha256:0b34789fa0da61cf7bef0546b09c738fb195331e017e477096d129e9105ab03d \
+    --hash=sha256:0e4eed3b200023042814d2fc8a5d2e880f13b52e1ed2485e83da4f3962f7dc1a \
+    --hash=sha256:115ab5f5f4a0f203cc2a5f0fb09aee503a3f771aa08392949ab5ca230c4fbdbd \
+    --hash=sha256:135869ef917b8704ea0a94e01620e0c05021c15c52036e4663baffe75e72f8ce \
+    --hash=sha256:147302878da387104b66bb4a8b0227d1d487e976ce41a8501916161072ed87b1 \
+    --hash=sha256:14ed654580c1ed2bc217352ec82f91b047aef82951aa71c7f64e0dcb03c0e180 \
+    --hash=sha256:16969c9d369c98eb084889c6e4d2d39b77c7eb38ceccf8da2a9fff62ae908980 \
+    --hash=sha256:19b72ed11572a2ee51a67a903afbe5af504f84ed6f529c0fe44b0ab3fb5cc697 \
+    --hash=sha256:231742b4a11dad8d5380a435962c57e91b7c37b79be858f4ef1c0df1a259897e \
+    --hash=sha256:26a473dbb4162108b27901492546f83c76fdcea3d0eadff00ae7a07e18dcce09 \
+    --hash=sha256:277fefe9d76ee17eb14debf399e3533d4d63b5f677a4d3719eb763536af1f4bd \
+    --hash=sha256:2d057a602cdd19a0ad680417527c45b6961a095081c0f46fe0e03e304aac6470 \
+    --hash=sha256:33d7d766701847dc6729846362dc27895d2f2d2251264f9d10e7cb9878194877 \
+    --hash=sha256:34fd2317602587321faab75ab76c623a0117e80841a6413654f04e47f339a8fb \
+    --hash=sha256:3513550321f8c8c811a7c3297b8a630e82dc08e4c10216d07703c997776236cd \
+    --hash=sha256:380cdce7ba24989af81d0a7013d0aaec5d0e2a21734c0e2681b1bc4f141957fe \
+    --hash=sha256:3a81d52442a7c99b3662333235b3adf96a1715864658b35bb797212be7bddb97 \
+    --hash=sha256:3ebca4179031ee716ed076ffadc29428e900512f6fccee8614c9983157fcf19c \
+    --hash=sha256:48ee05097750de0ff69ed5b7bbcf0732182fd57a24043dcc2a1da780a5ead3a5 \
+    --hash=sha256:4bab1b2d6141fe7b32ae71dac905666ece4f94936efbfb13d55bb7739a3a6021 \
+    --hash=sha256:4d4e98d6f3b8afed8bc8cd9718ec0cdf46661826beefb53fe8eafb37f2bf0362 \
+    --hash=sha256:4d7fde5501b944f83b3e665e1b31343ff6e154b15560a16b7130ea1e594a4206 \
+    --hash=sha256:4da3c38a2083ca4aaf9c2a36776cce3e9328e6647b10d118948f3cfb4913ffe4 \
+    --hash=sha256:4e39364e726a8fff737309aff059ff67d8a8c8d5b677be7bb49a8b3e84b7e218 \
+    --hash=sha256:4fd66214623f1b17501df9f0543bef0b833979ab5b6ded1e1d123222866aa8c9 \
+    --hash=sha256:4fef17e1f8722c11587a6ef18e35902450221da0028e65dbaaa543619e68e48f \
+    --hash=sha256:53b50b0e14084b8f7e29c5ce84c5af0f1160169b30d8a6914231d97d2fe297d4 \
+    --hash=sha256:57ea77fb70a448ce87d18fca050193202a3da5e54598f6501ca5476fb66cfe02 \
+    --hash=sha256:59e403b1cc5a676da8eaf31f6254801b7341b3e29efa85f92b48d272637e77be \
+    --hash=sha256:63e0efbc991250c0b3143488fa57d95affcabbfc63c99c48d625dd37779aafe2 \
+    --hash=sha256:71e63adb0e1f1ed5d9e168f50a91ceb93ae6420731d222dc7da5c69409aa47aa \
+    --hash=sha256:71f3db16e69b667b132e0f305a833d5497da302d801508cbb051ed9a9819da47 \
+    --hash=sha256:844417969855fc7a41be124aafe83dc424592a7f77cd4501900c67307122b92c \
+    --hash=sha256:8697ab6a080a5c46edaad50e2bc5bd8c7ca5c66442d24104fa44ec74910a8244 \
+    --hash=sha256:87e4d4ab280b0c87424d47695bec2182caf8cfc17879ea78dab76680194abc13 \
+    --hash=sha256:8aff7da9952a5ad1cef8e68017724d96c7b9a66e99e91d6252e1b133d67a7b10 \
+    --hash=sha256:8ecc30f10465fa1e0ce13fd01d9e22c316e5053a719a8d915d4545a09a5ff677 \
+    --hash=sha256:97d0d932803c1b164fde11cb542a9efcb1e0f63b184537cca65887147906ff48 \
+    --hash=sha256:97db4c94a7db398a5bd636273324f0b3fd58b350bbbac8bb380ceb825a9b40f4 \
+    --hash=sha256:9af678d6488357948f1f84c6cd1c1d397c014e1ae2f98ae082a44eb48f602624 \
+    --hash=sha256:9ef6fe90aadef185c7b128859f40beb24720b4ecea95379fc9000931179c3a49 \
+    --hash=sha256:9f78cf8fec5bd627f4082b8dfeac7871b43d7f3274904492a43dab39f18a19a0 \
+    --hash=sha256:a6082706765a95a6680d812e1daf1c0cfe8adec7831b3ff3b625693f3b461b1c \
+    --hash=sha256:a8f5f8bc7ce7d59f08d9f99fa510c06496164a24cb5f3d34537dbd9ca30132e2 \
+    --hash=sha256:ace6c58523302d3b97b6ac5c38a5298a54b473762b6be82726b4265c41029f92 \
+    --hash=sha256:b3afcf569c15577a9fe64627292daa3e6b3a70f4fb77a5df246a87ec21681b94 \
+    --hash=sha256:be4fa4f0af7fa18951f7ab3fc2148e223af211bf03f59e1c6034ec3f97f21d61 \
+    --hash=sha256:c2d3dc759490128c5c1711a53eeaa8ee1d437fd0038ffd2b6008abf46db3f882 \
+    --hash=sha256:c5d001196b89fa9cf0a4ab79766cd835b991a166e4b621ba95089edc50c429ff \
+    --hash=sha256:cce9127885941bd28f080cecf1f1d288336b7e0d812c345b08be88b572796254 \
+    --hash=sha256:cde1a448023ba7d5bb4c01c5afb48894380b5e4956e0627266526587ef4e535f \
+    --hash=sha256:d4087e5c0209a0a8efe4de3303c234b9c44d1174161dcd851e8eea07c7560b32 \
+    --hash=sha256:d8ea516b3726d190e1b4297e6f4e7a8650347ae053868a18163b4dd3641d1fff \
+    --hash=sha256:e5c9b8f28e726e97d97696c826bc7bea5d71cecd63576dba92924a32c1961291 \
+    --hash=sha256:f01c4818b3fc9b0da8e096722a84318071eaa118df35f6ed2344da0e73a5444f \
+    --hash=sha256:ffe02797b5e9f3a9d8292ddcd289b474ad13e81ad83cd1891a240811f1d2cb81
+    # via langsmith
+packaging==25.0 \
+    --hash=sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484 \
+    --hash=sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f
+    # via
+    #   huggingface-hub
+    #   langchain-core
+    #   langsmith
+    #   pytest
+    #   transformers
+pathspec==1.1.1 \
+    --hash=sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+    # via mypy
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+propcache==0.5.2 \
+    --hash=sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427 \
+    --hash=sha256:04dc2390d9edbbaef7461f33322555976ffddf0b650a038649d026358714e6c5 \
+    --hash=sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa \
+    --hash=sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7 \
+    --hash=sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a \
+    --hash=sha256:0fd59b5af35f74da48d905dcbad55449ba13be91823cb05a9bd590bbf5b61660 \
+    --hash=sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94 \
+    --hash=sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42 \
+    --hash=sha256:1ca071adabaab6e9219924bbe00af821f1ee7de113a9eca1cdc292de3d120f4d \
+    --hash=sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33 \
+    --hash=sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a \
+    --hash=sha256:2293949b855ce597f2826452d17c2d545fb5622379c4ea6fdf525e9b8e8a2511 \
+    --hash=sha256:26a4dca084132874e639895c3135dfad5eb20bae209f62d1aeb31b03e601c3c0 \
+    --hash=sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84 \
+    --hash=sha256:29cbaac5ea0212663e6845e04b5e188d5a6ae6dd919810ac835bf1d3b42c3f4c \
+    --hash=sha256:29f9309a2e42b0d273be006fdb4be2d6c39a47f6f57d8fb1cf9f81481df81b66 \
+    --hash=sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb \
+    --hash=sha256:2f8ea531c794b9d6274acd4e8d2c2ebcac590a4361d27482edd3010b79f1325e \
+    --hash=sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853 \
+    --hash=sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55 \
+    --hash=sha256:3b199b9b2b3d6a7edf3183ba8a9a137a22b97f7df525feb5ae1eccf026d2a9c6 \
+    --hash=sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704 \
+    --hash=sha256:44e488ef40dbb452700b2b1f8188934121f6648f52c295055662d2191959ff82 \
+    --hash=sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f \
+    --hash=sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64 \
+    --hash=sha256:4621064bbf28fa77ff64dd5d94367c04684c67d3a5bf1dff25f0cd0d98a38f3b \
+    --hash=sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d \
+    --hash=sha256:54adaa85a22078d1e306304a40984dc5be99d599bf3dc0a24dc98f7daeab89ab \
+    --hash=sha256:552ffadf6ad409844bc5919c42a0a83d88314cedddaea0e41e80a8b8fffe881f \
+    --hash=sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba \
+    --hash=sha256:5aaa2b923c1944ac8febd6609cb373540a5563e7cbcb0fd770f75dace2eb817b \
+    --hash=sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144 \
+    --hash=sha256:5fcb98e7598b1ee0addab320d90f65b530297a867dbfe9de52ea838077e16e3d \
+    --hash=sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e \
+    --hash=sha256:66ea454f095ddf5b6b14f56c064c0941c4788be11e18d2464cf643bf7203ff67 \
+    --hash=sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117 \
+    --hash=sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa \
+    --hash=sha256:6bf3be92233808fcd338eba0fb4d0b59ec5772af4f4ecfcec450d1bfc0f8b5eb \
+    --hash=sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96 \
+    --hash=sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476 \
+    --hash=sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191 \
+    --hash=sha256:74b70780220e2dd89175ca24b81b68b67c83db499ae611e7f2313cb329801c78 \
+    --hash=sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a \
+    --hash=sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba \
+    --hash=sha256:8114f28879e0904748e831c3a7774261bd9e75f49be089f389a76f959dcd13fe \
+    --hash=sha256:823581fd5cb08b12a48bfa11fe962a7916766b6170c17b028fbdf762b85eb9bf \
+    --hash=sha256:85341b12b9d55bad0bded24cac341bb34289469e03a11f3f583ea1cc1db0326c \
+    --hash=sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9 \
+    --hash=sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031 \
+    --hash=sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913 \
+    --hash=sha256:949c91d1a990cf3b2e8188dfcfb25005e0b834a06c63fa4ef9f360878ce21ecf \
+    --hash=sha256:95f1e3f4760d404b13c9976c0229b2b49a3c8e2c62a9ce92efdd2b11ada75e3f \
+    --hash=sha256:a0e399a2eccb91ed18721f86aa85757727400b6865c89e88934781deb9c8498b \
+    --hash=sha256:a4840ab0ae0216d952f4b53dc6d0b992bfc2bedbfe360bdd9b548bc184c08959 \
+    --hash=sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d \
+    --hash=sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4 \
+    --hash=sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f \
+    --hash=sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836 \
+    --hash=sha256:b05d643f944a8c3c4bd86d65ffd87bf3264b617f87791940302bc474d2ff5274 \
+    --hash=sha256:b96db7141a592cbc968daf1feea83a118e6ab378af4abbc72b248c895414c22d \
+    --hash=sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f \
+    --hash=sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe \
+    --hash=sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1 \
+    --hash=sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a \
+    --hash=sha256:c6844ba6364fb12f403928a82cfd295ab103a2b315c77c747b2dbe4a41894ea7 \
+    --hash=sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a \
+    --hash=sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164 \
+    --hash=sha256:cc1177027eda740fdb152706bd215a3f124e3eea15afc39f2cb9fe351b50619e \
+    --hash=sha256:cd416c1de191973c52ff1a12a57446bfc7642797b282d7caf2162d7d1b8aa9a0 \
+    --hash=sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568 \
+    --hash=sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4 \
+    --hash=sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2 \
+    --hash=sha256:d5a81be28596d6559f6131ef33e10200de6e17643b3c74ce03f9eb103be6ae8b \
+    --hash=sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42 \
+    --hash=sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a \
+    --hash=sha256:decfca4c79dd53ebab484b00cc4b6717d8c369f86e74aa4ca395a64ac651495e \
+    --hash=sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757 \
+    --hash=sha256:e4294d04a94dcab1b3bccd8b66d962dcad411a1d19414b2a41d1445f1de32ad0 \
+    --hash=sha256:e59bc9e66329185b93dab73f210f1a37f81cb40f321501db8017c9aea15dba27 \
+    --hash=sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf \
+    --hash=sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f \
+    --hash=sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d \
+    --hash=sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc \
+    --hash=sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c \
+    --hash=sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7 \
+    --hash=sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098 \
+    --hash=sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751
+    # via
+    #   aiohttp
+    #   yarl
+protobuf==7.35.1 \
+    --hash=sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799 \
+    --hash=sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87 \
+    --hash=sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6 \
+    --hash=sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30 \
+    --hash=sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9 \
+    --hash=sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4 \
+    --hash=sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4 \
+    --hash=sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a
+    # via onnx
+pydantic==2.13.4 \
+    --hash=sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba \
+    --hash=sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6
+    # via
+    #   langchain-classic
+    #   langchain-core
+    #   langsmith
+    #   mobiletransformers
+    #   pydantic-settings
+pydantic-core==2.46.4 \
+    --hash=sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0 \
+    --hash=sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262 \
+    --hash=sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda \
+    --hash=sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0 \
+    --hash=sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b \
+    --hash=sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594 \
+    --hash=sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2 \
+    --hash=sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c \
+    --hash=sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d \
+    --hash=sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398 \
+    --hash=sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d \
+    --hash=sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3 \
+    --hash=sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f \
+    --hash=sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7 \
+    --hash=sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4 \
+    --hash=sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d \
+    --hash=sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df \
+    --hash=sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2 \
+    --hash=sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd \
+    --hash=sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7 \
+    --hash=sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3 \
+    --hash=sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a \
+    --hash=sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987 \
+    --hash=sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e \
+    --hash=sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712 \
+    --hash=sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008 \
+    --hash=sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1 \
+    --hash=sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be \
+    --hash=sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea \
+    --hash=sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292 \
+    --hash=sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33 \
+    --hash=sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826 \
+    --hash=sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7 \
+    --hash=sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d \
+    --hash=sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf \
+    --hash=sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc \
+    --hash=sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3 \
+    --hash=sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b \
+    --hash=sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04 \
+    --hash=sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c \
+    --hash=sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b \
+    --hash=sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce \
+    --hash=sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4 \
+    --hash=sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a \
+    --hash=sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f \
+    --hash=sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894 \
+    --hash=sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9 \
+    --hash=sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76 \
+    --hash=sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb \
+    --hash=sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109 \
+    --hash=sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4 \
+    --hash=sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848 \
+    --hash=sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526 \
+    --hash=sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01 \
+    --hash=sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458 \
+    --hash=sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba \
+    --hash=sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39 \
+    --hash=sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b \
+    --hash=sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf \
+    --hash=sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4 \
+    --hash=sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd \
+    --hash=sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30 \
+    --hash=sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983 \
+    --hash=sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5 \
+    --hash=sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4 \
+    --hash=sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7 \
+    --hash=sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c \
+    --hash=sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3 \
+    --hash=sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89 \
+    --hash=sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50 \
+    --hash=sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76 \
+    --hash=sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b \
+    --hash=sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d \
+    --hash=sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4 \
+    --hash=sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c \
+    --hash=sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e
+    # via pydantic
+pydantic-settings==2.14.2 \
+    --hash=sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440 \
+    --hash=sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f
+    # via langchain-community
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==9.1.1 \
+    --hash=sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313 \
+    --hash=sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c
+python-dotenv==1.2.2 \
+    --hash=sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a \
+    --hash=sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3
+    # via
+    #   mobiletransformers
+    #   pydantic-settings
+pyyaml==6.0.3 \
+    --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \
+    --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \
+    --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \
+    --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \
+    --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \
+    --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \
+    --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \
+    --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \
+    --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via
+    #   huggingface-hub
+    #   langchain-classic
+    #   langchain-community
+    #   langchain-core
+    #   mobiletransformers
+    #   transformers
+regex==2026.7.10 \
+    --hash=sha256:0639b2488b775a0109f55a5a2172deebdedb4b6c5ab0d48c90b43cbf5de58d17 \
+    --hash=sha256:081acf191b4d614d573a56cab69f948b6864daa5e3cc69f209ee92e26e454c2f \
+    --hash=sha256:1050fedf0a8a92e843971120c2f57c3a99bea86c0dfa1d63a9fac053fe54b135 \
+    --hash=sha256:13fba679fe035037e9d5286620f88bbfd105df4d5fcd975942edd282ab986775 \
+    --hash=sha256:14d27f6bd04beb01f6a25a1153d73e58c290fd45d92ba56af1bb44199fd1010d \
+    --hash=sha256:1f0d4ccf70b1d13711242de0ba78967db5c35d12ac408378c70e06295c3f6644 \
+    --hash=sha256:21150500b970b12202879dfd82e7fd809d8e853140fff84d08e57a90cf1e154e \
+    --hash=sha256:221f2771cb780186b94bbf125a151bbeb242fa1a971da6ad59d7b0370f19de9a \
+    --hash=sha256:234f8e0d65cf1df9becadae98648f74030ee85a8f12edcb5eb0f60a22a602197 \
+    --hash=sha256:28a0973eeffff4292f5a7ee498ab65d5e94ee8cc9cea364239251eb4a260a0f1 \
+    --hash=sha256:2b93eafd92c4128bab2f93500e8912cc9ecb3d3765f6685b902c6820d0909b6b \
+    --hash=sha256:2bc350e1c5fa250f30ab0c3e38e5cfdffcd82cb8af224df69955cab4e3003812 \
+    --hash=sha256:2c66a8a1969cfd506d1e203c0005fd0fc3fe6efc83c945606566b6f9611d4851 \
+    --hash=sha256:2f98ef73a13791a387d5c841416ad7f52040ae5caf10bcf46fa12bd2b3d63745 \
+    --hash=sha256:31fa17378b29519bfd0a1b8ba4e9c10cf0baf1cf4099b39b0689429e7dc2c795 \
+    --hash=sha256:3750c42d47712e362158a04d0fd80131f73a55e8c715b2885442a0ff6f9fc3fc \
+    --hash=sha256:396ea70e4ea1f19571940add3bad9fd3eb6a19dc610d0d01f692bc1ba0c10cb4 \
+    --hash=sha256:3d8ef9df02c8083c7b4b855e3cb87c8e0ebbcfea088d98c7a886aaefdf88d837 \
+    --hash=sha256:3e23458d8903e33e7d27196d7a311523dc4e2f4137a5f34e4dbd30c8d37ff33e \
+    --hash=sha256:3f03b92fb6ec739df042e45b06423fc717ecf0063e07ffe2897f7b2d5735e1e8 \
+    --hash=sha256:41a47c2b28d9421e2509a4583a22510dc31d83212fcf38e1508a7013140f71a8 \
+    --hash=sha256:4574feca202f8c470bf678aed8b5d89df04aaf8dc677f3b83d92825051301c0f \
+    --hash=sha256:4db009b4fc533d79af3e841d6c8538730423f82ea8508e353a3713725de7901c \
+    --hash=sha256:53bbbd6c610489700f7110db1d85f3623924c3f7c760f987eca033867360788a \
+    --hash=sha256:53f54993b462f3f91fea0f2076b46deb6619a5f45d70dbd1f543f789d8b900ef \
+    --hash=sha256:58a4571b2a093f6f6ee4fd281faa8ebf645abcf575f758173ea2605c7a1e1ecb \
+    --hash=sha256:5c363de7c0339d39341b6181839ed32509820b85ef506deafcf2e7e43baadab4 \
+    --hash=sha256:5e792367e5f9b4ffb8cad93f1beaa91837056b94da98aa5c65a0db0c1b474927 \
+    --hash=sha256:617e8f10472e34a8477931f978ff3a88d46ae2ba0e41927e580b933361f60948 \
+    --hash=sha256:64722a5031aeace7f6c8d5ea9a9b22d9368af0d6e8fa532585da8158549ea963 \
+    --hash=sha256:65ee5d1ac3cd541325f5ac92625b1c1505f4d171520dd931bda7952895c5321a \
+    --hash=sha256:66d2c35587cd601c95965d5c0415058ba5cfd6ffbab7624ce198bd967102b341 \
+    --hash=sha256:6cbedeb5112f59dbd169385459b9943310bdd241c6966c19c5f6e2295055c93a \
+    --hash=sha256:724ee9379568658ec06362cf24325c5315cc5a67f61dfe585bfeff58300a355b \
+    --hash=sha256:7252b48b0c60100095088fbeb281fca9a4fcf678a4e04b1c520c3f8613c952c4 \
+    --hash=sha256:732c19e5828eb287d01edb83b2eb87f283ba8e5fc3441c732709d3e8cbd14aaa \
+    --hash=sha256:74ae61d8573ecd51b5eeee7be2218e4c56e99c14fa8fcf97cf7519611d4be92e \
+    --hash=sha256:799a369bdab91dcf0eb424ebd7aa9650897025ce22f729248d8f2c72002c4daa \
+    --hash=sha256:80151ca5bfc6c4524186b3e08b499e97319b2001fc265ed2d4fc12c0d5692cdf \
+    --hash=sha256:82ab8330e7e2e416c2d42fcec67f02c242393b8681014750d4b70b3f158e1f08 \
+    --hash=sha256:8331484450b3894298bef8abecce532171ff6ac60b71f999eed10f2c01941a8a \
+    --hash=sha256:87794549a3f5c1c2bdfba2380c1bf87b931e375f4133d929da44f95e396bf5fe \
+    --hash=sha256:87b776cf2890e356e4ab104b9df846e169da3eb5b0f110975547091f4e51854e \
+    --hash=sha256:8e26a075fa9945b9e44a3d02cc83d776c3b76bb1ff4b133bbfa620d5650131da \
+    --hash=sha256:91b916d495db3e1b473c7c8e68733beec4dce8e487442db61764fff94f59740e \
+    --hash=sha256:948dfc62683a6947b9b486c4598d8f6e3ecc542478b6767b87d52be68aeb55c6 \
+    --hash=sha256:982d07727c809b42a3968785354f11c3728414e4e90af0754345b431b2c32561 \
+    --hash=sha256:9a094ed44a22f9da497453137c3118b531fd783866ab524b0b0fc146e7395e1d \
+    --hash=sha256:9d028d189d8f38d7ff292f22187c0df37f2317f554d2ed9a2908ada330af57c0 \
+    --hash=sha256:a2d6d30be35ddd70ce0f8ee259a4c25f24d6d689a45a5ac440f03e6bcc5a21d1 \
+    --hash=sha256:a68b637451d64ba30ed8ae125c973fa834cc2d37dfa7f154c2b479015d477ba8 \
+    --hash=sha256:aa34473fbcc108fea403074f3f45091461b18b2047d136f16ffaa4c65ad46a68 \
+    --hash=sha256:ab2fb1f7a2deb4ca3ddebbae6b93905d21480a3b4e11de28d79d9fb0d316fcf8 \
+    --hash=sha256:ab39d2c967aae3b48a412bff9cdbe7cd7559cd1e277599aceaeada7bc82b7200 \
+    --hash=sha256:b04583e8867136ae66353fa274f45121ab3ec3166dc45aaff3655a5db90d9f0e \
+    --hash=sha256:b1963ec5ba4d52788fb0eac6aca6eb8040e8e318c7e47ebbdfc09440c802919c \
+    --hash=sha256:b56416091bfd7a429f958f69aaf6823c517be9a49cb5bf1daa3767ce8bf8095e \
+    --hash=sha256:b96341cb29a3faa5db05aff29c77d141d827414f145330e5d8846892119351c1 \
+    --hash=sha256:bb52e10e453b5493afe1f7702a2973bc10f4dd8901c0f2ed869ffaa3f8319296 \
+    --hash=sha256:bb5aab464a0c5e03a97abad5bdf54517061ebbf72340d576e99ff661a42575cc \
+    --hash=sha256:be4223af640d0aa04c05db81d5d96ada3ead9c09187d892fd37f4f97829480be \
+    --hash=sha256:c2cbd385d82f63bb35edb60b09b08abad3619bd0a4a492ae59e55afaf98e1b9d \
+    --hash=sha256:c57b6ad3f7a1bdd101b2966f29dc161adf49727b1e8d3e1e89db2eda8a75c344 \
+    --hash=sha256:c622f4c638a725c39abcb2e680b1bd592663c83b672a4ed350a17f806d75618e \
+    --hash=sha256:cae27622c094558e519abf3242cf4272db961d12c5c9a9ffb7a1b44b2627d5c6 \
+    --hash=sha256:cfcec18f7da682c4e2d82112829ce906569cb8d69fa6c26f3a50dfbed5ceb682 \
+    --hash=sha256:d0834c84ae8750ae1c4cede59b0afd4d2f775be958e11b18a3eea24ed9d0d9f1 \
+    --hash=sha256:d3c75d57a00109255e60bc9c623b6ececaf7905eaab845c79f036670ed4750a2 \
+    --hash=sha256:da6ef4cb8d457aab0482b50120136ae94238aaa421863eaa7d599759742c72d6 \
+    --hash=sha256:e21e888a6b471b2bb1cdd4247e8d86632672232f29be583e7eafaa5f4634d34c \
+    --hash=sha256:e37aba1994d73b4944053ab65a15f313bd5c28c885dd7f0d494a11749d89db6e \
+    --hash=sha256:e6b6a11bf898cca3ce7bfaa17b646901107f3975677fbd5097f36e5eb5641983 \
+    --hash=sha256:eac1207936555aa691ce32df1432b478f2729d54e6d93a1f4db9215bcd8eb47d \
+    --hash=sha256:ebbf0d83ed5271991d666e54bb6c90ac2c55fb2ef3a88740c6af85dc85de2402 \
+    --hash=sha256:ecae626449d00db8c08f8f1fc00047a32d6d7eb5402b3976f5c3fda2b80a7a4f \
+    --hash=sha256:ed7c886a2fcbf14493ceaf9579394b33521730c161ebb8dad7db9c3e9fcab1a8 \
+    --hash=sha256:ee877b6d78f9dff1da94fef51ae8cf9cce0967e043fdcc864c40b85cf293c192 \
+    --hash=sha256:f0192e5f1cfc70e3cb35347135dd02e7497b3e7d83e378aa226d8b3e53a93f19 \
+    --hash=sha256:f3463a5f26be513a49e4d497debcf1b252a2db7b92c77d89621aa90b83d2dd38 \
+    --hash=sha256:f6222cafe00e072bb2b8f14142cd969637411fbc4dd3b1d73a90a3b817fa046f \
+    --hash=sha256:fadb07dbe36a541283ff454b1a268afd54b077d917043f2e1e5615372cb5f200 \
+    --hash=sha256:fe7ff456c22725c9d9017f7a2a7df2b51af6df77314176760b22e2d05278e181
+    # via transformers
+requests==2.34.2 \
+    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
+    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
+    # via
+    #   huggingface-hub
+    #   langchain-classic
+    #   langchain-community
+    #   langsmith
+    #   requests-toolbelt
+    #   transformers
+requests-toolbelt==1.0.0 \
+    --hash=sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6 \
+    --hash=sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06
+    # via langsmith
+ruff==0.15.21 \
+    --hash=sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075 \
+    --hash=sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be \
+    --hash=sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd \
+    --hash=sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd \
+    --hash=sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86 \
+    --hash=sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341 \
+    --hash=sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd \
+    --hash=sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67 \
+    --hash=sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41 \
+    --hash=sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d \
+    --hash=sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d \
+    --hash=sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8 \
+    --hash=sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233 \
+    --hash=sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8 \
+    --hash=sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500 \
+    --hash=sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3 \
+    --hash=sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646 \
+    --hash=sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f
+safetensors==0.8.0 \
+    --hash=sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358 \
+    --hash=sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f \
+    --hash=sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d \
+    --hash=sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d \
+    --hash=sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0 \
+    --hash=sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc \
+    --hash=sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235 \
+    --hash=sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98 \
+    --hash=sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4 \
+    --hash=sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846 \
+    --hash=sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca \
+    --hash=sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0 \
+    --hash=sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25 \
+    --hash=sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452 \
+    --hash=sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d \
+    --hash=sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78 \
+    --hash=sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774
+    # via transformers
+scikit-learn==1.7.2 ; python_full_version < '3.11' \
+    --hash=sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1 \
+    --hash=sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7 \
+    --hash=sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c \
+    --hash=sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda \
+    --hash=sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a \
+    --hash=sha256:36749fb62b3d961b1ce4fedf08fa57a1986cd409eff2d783bca5d4b9b5fce51c \
+    --hash=sha256:4a847fea807e278f821a0406ca01e387f97653e284ecbd9750e3ee7c90347f18 \
+    --hash=sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f \
+    --hash=sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973 \
+    --hash=sha256:6088aa475f0785e01bcf8529f55280a3d7d298679f50c0bb70a2364a82d0b290 \
+    --hash=sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c \
+    --hash=sha256:6b33579c10a3081d076ab403df4a4190da4f4432d443521674637677dc91e61f \
+    --hash=sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0 \
+    --hash=sha256:7a58814265dfc52b3295b1900cfb5701589d30a8bb026c7540f1e9d3499d5ec8 \
+    --hash=sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d \
+    --hash=sha256:8d91a97fa2b706943822398ab943cde71858a50245e31bc71dba62aab1d60a96 \
+    --hash=sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1 \
+    --hash=sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c \
+    --hash=sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8 \
+    --hash=sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1 \
+    --hash=sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe \
+    --hash=sha256:acbc0f5fd2edd3432a22c69bed78e837c70cf896cd7993d71d51ba6708507476 \
+    --hash=sha256:b4d6e9deed1a47aca9fe2f267ab8e8fe82ee20b4526b2c0cd9e135cea10feb44 \
+    --hash=sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e \
+    --hash=sha256:ca250e6836d10e6f402436d6463d6c0e4d8e0234cfb6a9a47835bd392b852ce5 \
+    --hash=sha256:e5bf3d930aee75a65478df91ac1225ff89cd28e9ac7bd1196853a9229b6adb0b
+    # via sentence-transformers
+scikit-learn==1.9.0 ; python_full_version >= '3.11' \
+    --hash=sha256:056c92bb67ad4c28463c2f2653d9701449201e7e7a9e94e321be0f71c4fef2b8 \
+    --hash=sha256:26e22435f63bcdcf396b574273f29f13dd531f5ea035801f5be10ba1540a4e60 \
+    --hash=sha256:2bd41b0d201bc81575531b96b713d3eb5e5f50fb0b82101ff0f92294fdc236ac \
+    --hash=sha256:366652351f092b219c248f1e72821e841960a63d8f358f1dcfd54dc1cbdbbc28 \
+    --hash=sha256:38c3dcb9a1ffb85505ec53d54c7b4aea0cff70050425a7760c2af661ac85df05 \
+    --hash=sha256:4306775fad04cc4b472a1b15af1ae9cede1540fbfcc17fbce3767cd8dc7ae283 \
+    --hash=sha256:5808d98f15c6bf6d9d96d2348c1997392a5888ce7097e664105f930c4bca1277 \
+    --hash=sha256:5b934c45c252844a91d69fda3a34cff5e7307e1db10d77cb10a3980312c74713 \
+    --hash=sha256:5be45aa4a42a68a533913a6ed736cf309de2226411c79ef8d609a5456f1939b1 \
+    --hash=sha256:5dc1818c77575d149e25fce9ef82dd7b7263ae372f03494158668ad632a69759 \
+    --hash=sha256:5e50ed4da51974e86e940690e9a3d82e729b62b5a49f7c9bac534d515d39d86f \
+    --hash=sha256:80746d63bd4b6eaca54d36fe5feaf4d28bb38dc6f9470f81c7cad7c40155f119 \
+    --hash=sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557 \
+    --hash=sha256:9db6f4d34e68c8899e4cab27fdf8eafe6ed21f2ba52ceb25ea250cd237f8e47b \
+    --hash=sha256:d77f54c017633791bc0225a43e2f8d03745fdcfe4880268fcc4df15f505dec2e \
+    --hash=sha256:da76d09304a4706db7cc1e3ebaa3b6b98a67365cc11d2996c4f1e58ba47df714 \
+    --hash=sha256:f401448645a3e7bc115aa3c094097865155b34bff1cba8101857d9104e99074c \
+    --hash=sha256:f7e254636164090da847715a27f8e5478feb98c40a9e0ee90cbd277de9e5ceb8 \
+    --hash=sha256:fd3a8ef0c758555a3b23c03adaa858af32f7736785ded50ad5991f59c4ed03fa
+    # via sentence-transformers
+scipy==1.15.3 ; python_full_version < '3.11' \
+    --hash=sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477 \
+    --hash=sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c \
+    --hash=sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723 \
+    --hash=sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730 \
+    --hash=sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539 \
+    --hash=sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb \
+    --hash=sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6 \
+    --hash=sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594 \
+    --hash=sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92 \
+    --hash=sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82 \
+    --hash=sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49 \
+    --hash=sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759 \
+    --hash=sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba \
+    --hash=sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982 \
+    --hash=sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8 \
+    --hash=sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65 \
+    --hash=sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4 \
+    --hash=sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e \
+    --hash=sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed \
+    --hash=sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c \
+    --hash=sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5 \
+    --hash=sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5 \
+    --hash=sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019 \
+    --hash=sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e \
+    --hash=sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1 \
+    --hash=sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889 \
+    --hash=sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca \
+    --hash=sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825 \
+    --hash=sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9 \
+    --hash=sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62 \
+    --hash=sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb \
+    --hash=sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b \
+    --hash=sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13 \
+    --hash=sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb \
+    --hash=sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40 \
+    --hash=sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c \
+    --hash=sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253 \
+    --hash=sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb \
+    --hash=sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f \
+    --hash=sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163 \
+    --hash=sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45 \
+    --hash=sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7 \
+    --hash=sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11 \
+    --hash=sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf \
+    --hash=sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e \
+    --hash=sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126
+    # via
+    #   scikit-learn
+    #   sentence-transformers
+scipy==1.17.1 ; python_full_version == '3.11.*' \
+    --hash=sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0 \
+    --hash=sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458 \
+    --hash=sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e \
+    --hash=sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec \
+    --hash=sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6 \
+    --hash=sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce \
+    --hash=sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8 \
+    --hash=sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448 \
+    --hash=sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87 \
+    --hash=sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4 \
+    --hash=sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b \
+    --hash=sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082 \
+    --hash=sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464 \
+    --hash=sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87 \
+    --hash=sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c \
+    --hash=sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369 \
+    --hash=sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f \
+    --hash=sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c \
+    --hash=sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475 \
+    --hash=sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd \
+    --hash=sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d \
+    --hash=sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6 \
+    --hash=sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb \
+    --hash=sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca \
+    --hash=sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0 \
+    --hash=sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d \
+    --hash=sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee \
+    --hash=sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49 \
+    --hash=sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950 \
+    --hash=sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b \
+    --hash=sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086 \
+    --hash=sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444 \
+    --hash=sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff \
+    --hash=sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a \
+    --hash=sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50 \
+    --hash=sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696 \
+    --hash=sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21 \
+    --hash=sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c \
+    --hash=sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3 \
+    --hash=sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea \
+    --hash=sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76
+    # via
+    #   scikit-learn
+    #   sentence-transformers
+scipy==1.18.0 ; python_full_version >= '3.12' \
+    --hash=sha256:09143f676d157d9f546d663504ef9c1becb819824f1afc018814176411942446 \
+    --hash=sha256:0d13bca67c096d89fb95ced0d8921807300fce0275643aef9533cc63a0773468 \
+    --hash=sha256:1afac4a847207c7ff8efd321734a50b06d0280b3b2a2c0fc2f413101747ad7c7 \
+    --hash=sha256:1f55797419e16e7f30cf88ffb3113ce0467f00cfe3f70d5c281730b21769bfc2 \
+    --hash=sha256:265915e79107de9f946b855e50d7470d5893ec3f54b342e1aa6201cbdcd8bb6b \
+    --hash=sha256:4a55985d54c769c872e64b7f4c8a81cc30ef700cc04296abbbf3705439c126de \
+    --hash=sha256:52a96e21517c7292375c0e27dd796a811f03fcea5fd4d108fdfea8145dcf17ab \
+    --hash=sha256:5aba46108853ddfc77906b6557aac839d2b52e900c1d72a1180adaaab58d265f \
+    --hash=sha256:5efe260f69417b97ddae455bfb5a95e8359f7f66ad7fa9522a60feb66f169520 \
+    --hash=sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378 \
+    --hash=sha256:68363b7eaacd8b5dd426df56d782cc156468ac79a127a1b87ca597d6e2e82197 \
+    --hash=sha256:71ccc8faa2dd16ac310233203474a8b5cb67f10dedd54a3116d34943f4b19132 \
+    --hash=sha256:7bd21faaf5a1a3b2eff922d02db5f191b99a6518db9078a8fb23169f6d22259a \
+    --hash=sha256:97b6cddaaee0a779ef6b5ca83c9604b27cc16b2b8fc22c142652df8793319fb8 \
+    --hash=sha256:9ab7b758be6940954a713ee466e2043e9f6e2ed965c1fce5c91039f4be3d90a9 \
+    --hash=sha256:a46f9273dbd0eb1cefba61c9b8648b4dfe3cbc14a080176f9a73e44b8336dc7f \
+    --hash=sha256:ad033410e2e0672ffdc1042110cef20e1c46f8fd0616cee1d44d8d58fad8fc11 \
+    --hash=sha256:b6f758e35f12757b5d95c00bc6de2438e229c2664b7a92e96f205959d9f2dfa4 \
+    --hash=sha256:c5557d8be5da8e41353fcd4d21491fdbab83b062fc579e94dc09a7c8ab4f669b \
+    --hash=sha256:c5dbddf60e58c2312316d097271a8e73d40eaf2eabfa4d95ed7d3695bbf2ce7b \
+    --hash=sha256:d88363fd9d8fbd3511bd273f1a49efb2a540773ddf92a91d57498ce7dd7f3e76
+    # via
+    #   scikit-learn
+    #   sentence-transformers
+sentence-transformers==5.6.0 \
+    --hash=sha256:0e7164d051e416c1853ade7c274ff52af3f9da0f4be7f0b83d734c27699e1057 \
+    --hash=sha256:d2075b5e687a1611005e20ab04a6846994d51adfcf39610aed066af3c0c0b81f
+    # via mobiletransformers
+setuptools==83.0.0 ; (python_full_version >= '3.12' and platform_machine != 'x86_64') or (python_full_version >= '3.12' and sys_platform != 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') \
+    --hash=sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef \
+    --hash=sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3
+    # via
+    #   torch
+    #   triton
+sniffio==1.3.1 \
+    --hash=sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2 \
+    --hash=sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc
+    # via langsmith
+sqlalchemy==2.0.51 \
+    --hash=sha256:0592bdadf86ddcabfd72d9ab66ea8a5d8d2cc6be1cc51fa7e66c03868ac5eac1 \
+    --hash=sha256:0e8203d2fbd5c6254692ef0a72c740d75b2f3c7ca345404f4c1a4604813c77c0 \
+    --hash=sha256:0f053118c30e53161857a953e4de667d90e274980dccbe5dd3829bbbeece72a5 \
+    --hash=sha256:1181256e0f16479691b5616d36375dc2620ad8332b25978763c3d206ad3f3f1d \
+    --hash=sha256:1aa10c0daee6705294d181daadaa793221e1a59ed55000a3fab1d42b088ce4ba \
+    --hash=sha256:1af05726b3d0cdba1c55284bf408fd3b792e690fe2399bfb8304565551cda652 \
+    --hash=sha256:1bed1ee8b01da6088210aa9412023326fb98a599ba502e6118308601dcbef77f \
+    --hash=sha256:1d21ce524ab86c23046e992a5b81cb54c21079c6df6e78b8fc77d77cac70a6b9 \
+    --hash=sha256:1e47b1199c2e832e325eacabc8d32d2487f58c9358f97e9a00f5eb93c5680d84 \
+    --hash=sha256:2cf39aabdf48e87c1c2c2ed6d20d33ffa0733b3071ce9c5f66357947dd009080 \
+    --hash=sha256:2e54ff2dd657f2e3e0fbf2b097db1182f7bfea263eca4353f00065bae2a67c3d \
+    --hash=sha256:436728ce18a80f6951a1e11cc6112c2ede9faf20766f1a26195a7c441ca12dbd \
+    --hash=sha256:483b11bd46bf35fc14c52faf338b04300c9e6ce554bce9b11be85bfec3bc3195 \
+    --hash=sha256:4a011ea4510683319ce4ed274b56ee05194b39b6da9d09ca7a39388f0fa84dcc \
+    --hash=sha256:581921d849d6e6f994d560389192955e80e2950e18fcdfe2ccea863e01158e6e \
+    --hash=sha256:72ca54c952107ba5cd58854b67a5a6268631289d21651a1235396f3b98b47400 \
+    --hash=sha256:740cf6f35351b1ac3d82369152acf1d51d37e3dcf85d4dc0a22ca01410eabe2a \
+    --hash=sha256:7c2056838b6685b72fdb36c99996cf862753461a62f2e84f4196371d3b2d6a07 \
+    --hash=sha256:7d78702b26ba1c18b2d0fb2ea940ba7f17a9581b42e8361ff93920ebbee1235a \
+    --hash=sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9 \
+    --hash=sha256:9f380393be5abeb6815f68fd39271b95127173511b6706b0a630a9995d53f8f5 \
+    --hash=sha256:a5b2ed6d828f1f09bd812861f4f59ca3bc3803f9df871f4555187f0faf018604 \
+    --hash=sha256:a6d26094615306d116dd5e4a51b0304c99dd2356fc569eed6922a80a6bd3b265 \
+    --hash=sha256:b3e693d15533a45cd5906f0589f9c35090bef6ef45bf1e8195c424aa0ae06a8d \
+    --hash=sha256:b93ab07b5292dbe7e6b8da89475275e7042744283921344b56105f3eeb0f828b \
+    --hash=sha256:bb024d8b621d0be75f4f44ecc7c950450026e76d66dc8f791bb5331d7fed59d5 \
+    --hash=sha256:c5d98a2709840027f5a347c3af0a7c3d5f6c1ff93af2ca1c54494e23cba8f389 \
+    --hash=sha256:c68568f3facf8f66fa76c60e0ced69b67666ffa9941d1d0a3756fda196049080 \
+    --hash=sha256:ca8435d13829b92f4a97362d91975154a4015db3a2634154e1754e9a915e6b86 \
+    --hash=sha256:dc261707bf5739aea8a541593f3cc1d463c2701fb05fbcbba0ce031b69a21260
+    # via
+    #   langchain-classic
+    #   langchain-community
+sympy==1.14.0 \
+    --hash=sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517 \
+    --hash=sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5
+    # via torch
+tenacity==9.1.4 \
+    --hash=sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55 \
+    --hash=sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a
+    # via
+    #   langchain-community
+    #   langchain-core
+threadpoolctl==3.6.0 \
+    --hash=sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb \
+    --hash=sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e
+    # via scikit-learn
+tokenizers==0.22.2 \
+    --hash=sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e \
+    --hash=sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001 \
+    --hash=sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7 \
+    --hash=sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd \
+    --hash=sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4 \
+    --hash=sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67 \
+    --hash=sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a \
+    --hash=sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5 \
+    --hash=sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917 \
+    --hash=sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c \
+    --hash=sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195 \
+    --hash=sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4 \
+    --hash=sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a \
+    --hash=sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc \
+    --hash=sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92 \
+    --hash=sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5 \
+    --hash=sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48 \
+    --hash=sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b \
+    --hash=sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c \
+    --hash=sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5
+    # via
+    #   langchain-huggingface
+    #   mobiletransformers
+    #   transformers
+tomli==2.4.1 ; python_full_version < '3.11' \
+    --hash=sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe \
+    --hash=sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5 \
+    --hash=sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd \
+    --hash=sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54 \
+    --hash=sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c \
+    --hash=sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a \
+    --hash=sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd \
+    --hash=sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5 \
+    --hash=sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9 \
+    --hash=sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9 \
+    --hash=sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1 \
+    --hash=sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585 \
+    --hash=sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e \
+    --hash=sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f \
+    --hash=sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085 \
+    --hash=sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36 \
+    --hash=sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076 \
+    --hash=sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece \
+    --hash=sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a \
+    --hash=sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897 \
+    --hash=sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d \
+    --hash=sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917 \
+    --hash=sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a \
+    --hash=sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc \
+    --hash=sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f \
+    --hash=sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257 \
+    --hash=sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30 \
+    --hash=sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9 \
+    --hash=sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049
+    # via
+    #   mypy
+    #   pytest
+torch==2.7.1 \
+    --hash=sha256:03563603d931e70722dce0e11999d53aa80a375a3d78e6b39b9f6805ea0a8d28 \
+    --hash=sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1 \
+    --hash=sha256:0da4f4dba9f65d0d203794e619fe7ca3247a55ffdcbd17ae8fb83c8b2dc9b585 \
+    --hash=sha256:23660443e13995ee93e3d844786701ea4ca69f337027b05182f5ba053ce43b38 \
+    --hash=sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2 \
+    --hash=sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa \
+    --hash=sha256:30207f672328a42df4f2174b8f426f354b2baa0b7cca3a0adb3d6ab5daf00dc8 \
+    --hash=sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb \
+    --hash=sha256:79042feca1c634aaf6603fe6feea8c6b30dfa140a6bbc0b973e2260c7e79a22e \
+    --hash=sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52 \
+    --hash=sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162 \
+    --hash=sha256:988b0cbc4333618a1056d2ebad9eb10089637b659eb645434d0809d8d937b946 \
+    --hash=sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f \
+    --hash=sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730 \
+    --hash=sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc \
+    --hash=sha256:d632f5417b6980f61404a125b999ca6ebd0b8b4bbdbb5fbbba44374ab619a412 \
+    --hash=sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c \
+    --hash=sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b \
+    --hash=sha256:e08d7e6f21a617fe38eeb46dd2213ded43f27c072e9165dc27300c9ef9570934 \
+    --hash=sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d
+    # via sentence-transformers
+tqdm==4.68.4 \
+    --hash=sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520 \
+    --hash=sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2
+    # via
+    #   huggingface-hub
+    #   sentence-transformers
+    #   transformers
+transformers==4.57.6 \
+    --hash=sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550 \
+    --hash=sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3
+    # via sentence-transformers
+triton==3.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43 \
+    --hash=sha256:a3198adb9d78b77818a5388bff89fa72ff36f9da0bc689db2f0a651a67ce6a42 \
+    --hash=sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b \
+    --hash=sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e \
+    --hash=sha256:b89d846b5a4198317fec27a5d3a609ea96b6d557ff44b56c23176546023c4240
+    # via torch
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via
+    #   aiohttp
+    #   aiosignal
+    #   anyio
+    #   exceptiongroup
+    #   huggingface-hub
+    #   langchain-core
+    #   langsmith
+    #   multidict
+    #   mypy
+    #   onnx
+    #   pydantic
+    #   pydantic-core
+    #   sentence-transformers
+    #   sqlalchemy
+    #   torch
+    #   typing-inspection
+typing-inspection==0.4.2 \
+    --hash=sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7 \
+    --hash=sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464
+    # via
+    #   pydantic
+    #   pydantic-settings
+urllib3==2.7.0 \
+    --hash=sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c \
+    --hash=sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897
+    # via requests
+uuid-utils==0.17.0 \
+    --hash=sha256:03815cea572c8a693cab5475b9d750cc161470961c7defa27e9286cad62f38f5 \
+    --hash=sha256:04452640d8b6920c480c16e5afe91ff896d236e0c972830f9247e0898d38c803 \
+    --hash=sha256:09a55b7a5ae764985cb46467496a1787678d0a1400356157a080ad95b1a36869 \
+    --hash=sha256:0bc4c431ccd59c764080ceb43b126043325fe17861b87759d026a0cdd8423bb2 \
+    --hash=sha256:0f3729e839209f3457d0d8b6a35a376fdf65577a5aecaf4cc3587d3305759ba6 \
+    --hash=sha256:0fcca4e838af9ac9243b3358d7c14afa4dca286a87781124c272d6c4cad9c968 \
+    --hash=sha256:1019476b6bdc047216ef7414be5babe0fa5ccfde977c0cac4fd6c75ddec66ff7 \
+    --hash=sha256:14dc2f46abb1091260c0d203fcbdf4e045042cc07e49183fd3b255904b95eb70 \
+    --hash=sha256:1edf2f8732e4ed95bd7b65f2658f4aa072efaaff321144f4e0d4bf6a22709263 \
+    --hash=sha256:21c79b61ff750abcf057163dd764ccb6196cde7a26cda1b31b45cd97769e03b3 \
+    --hash=sha256:237722b6581bb5b4eb4cefbcbe5c6e2980a440aabe781fbe50ebf1cb71eee4cc \
+    --hash=sha256:29179ffb7b317239b6d6afb100d14c439c728770460718280b9c0a42d2561ec2 \
+    --hash=sha256:2db386941cfdecdd0b5a8ceeed5cf7479c83d1730dcf64a48d43cfa018cc3310 \
+    --hash=sha256:2dd4a21baaac9a88486f0dd166c5793feb101a0bb9f006f2c401657fff5a1343 \
+    --hash=sha256:309a35f12d99dde19032bc2259cda6431c85eeac0879134dc777cc3087d7e1cb \
+    --hash=sha256:32abaafc8e91928b3d9f4d82e42d2094041e38ad6bb964066faadff28e4162f1 \
+    --hash=sha256:32df1944808877702ceea398c103881c09a679bb672a215e01c2a84231266bf9 \
+    --hash=sha256:344f7c755e280ea0ba6aeb08022190d867a80000b1715cacded54fc4b5633607 \
+    --hash=sha256:351462debd866f1f25e4d4f5c7fac89525b52151f0102a1bdfe94a999b046f5f \
+    --hash=sha256:3dac0ad0cd9a2818d1775215365a4e8c2f8ada215529dd26f3f8cceeb67a6988 \
+    --hash=sha256:4134353bfe3026ddab8e886002dc52bc5a0ab04611aabb0eaae23c32e6e57f64 \
+    --hash=sha256:46a73cacdf512f473a81f65dbf84186e08cfe6e9118fa582b6c6b33a8288a30d \
+    --hash=sha256:4bf4d9cd1e80e73922073b9b27c143bedeb109d65f94cd12712e2c87118f2b7d \
+    --hash=sha256:4e2ac1c0b56f2c91b6f158e29ed96b1503223fe8aa6e79b1be1dc55bd8a5131c \
+    --hash=sha256:52db0e471d3d2632d35445af352591f40a8f32959a412981d9f51e068bb9514b \
+    --hash=sha256:53ce348ef4c6e98c02c19c522af01334fe94476ce9af0db8c4482f9f142ae9c1 \
+    --hash=sha256:56aa6488b931246fae11924e4bd0e2b32677e63945eecb71c29e3c2ca0dc3131 \
+    --hash=sha256:570db214f6d8507587a8faa968a3fe65e957daeb7bc48b27dc7f69bc3ecdd6f1 \
+    --hash=sha256:589d9da7de8fa7f739bb970ac4632c9a268213117d634e1c4a58c1c1e821ca05 \
+    --hash=sha256:5a4370089c8b2e42f1db51d76408c7fa8eaa2934bf854d17983d16179c07c098 \
+    --hash=sha256:622cdde768300591ac79bfcd7bb3468e4b191b1105d5dbfe8d87c39d8f63dd46 \
+    --hash=sha256:6a019a31bc4db89a0903a3e4f6b218571f3a6ff0ad4b3d3fe1c8f91a05ff6e3e \
+    --hash=sha256:6c142bd0cb4dba31c10babe00d59f7ef6460f0ef55eaa9c1a9da270684af996a \
+    --hash=sha256:75d7411e8eb9259764dd60310738540649057cda4509b4af14b36b7f663bfeb0 \
+    --hash=sha256:793229621e1ad6cac55f015cfa9f4eff102accbc3da25d607b91c6b0bec167fb \
+    --hash=sha256:7a49f47ac26df3e431c56b825c1bae8e6d3d591fdbb7438c227cc9845a7e3d73 \
+    --hash=sha256:7b9044ce4acbf392d4b3a503fe377641f4deff82e6c341c36ef27af0dea76cdf \
+    --hash=sha256:7c89359affecebe2e39e6a116d069b363c936511a9572b308402489a26957d89 \
+    --hash=sha256:84ed3a2d5cd3ae6db87af20bfed3331116195ba4757ad7177fc8f12c1bbce2a9 \
+    --hash=sha256:89a0980d49683c00539c59cd9f46b1908c538e6b5b0a48ad12187bb856d0f391 \
+    --hash=sha256:8b72c2002202038666bf647f9a790906214c7c11cd0d6efef77b7d07bef3034a \
+    --hash=sha256:8eb3e5caca8d3a6f72ea4cce024583f989f6f2e9186f98800213fff0176e8bcc \
+    --hash=sha256:9205068badf453d2f0821fd5d340389b4679992d7ff79d4f3e5608996dd1b287 \
+    --hash=sha256:981cc10163988defea96e8d6c507df151eab8f483e7df9ae543d5a41a4be073b \
+    --hash=sha256:98c88d3edd08e7245562e9815996dbc6f0bd4745e1c76462f24af5ae4e187dd1 \
+    --hash=sha256:9a91c4814c7150a4d798da691b7804eacd78c4b84fb392a60fa0de21341861eb \
+    --hash=sha256:9e311f908d2f842fca4c7dcebc4f10306b8089b204ef04cf6704b4332c9ff6ff \
+    --hash=sha256:9e753e81457241e2200c56a898e268e8fa25796271af0489c608f24d8e631eed \
+    --hash=sha256:abb5667a36119019b3fa320c4d10c21ebccfcc87c8a739e6a0056cee7f48dde2 \
+    --hash=sha256:b3131a82d0c7611f0aa480a6d36929e001a3f54ba0fc029a8118a5863cce513c \
+    --hash=sha256:b776c7fc8755c7de06dd5a22b47c40ae84f67d13277ebb233cc84933ba4dcbcd \
+    --hash=sha256:c00d182e31034250690f417b9068b78eab423c10d76766664e82d9860c340479 \
+    --hash=sha256:c351737e2e65497c7200ab4ffb8af97e9f48be6488309abdd265fe08d66ee92f \
+    --hash=sha256:c4f845166b09acc65c5213a35551a7f81c17fa010ab467229b5813f79d17fe13 \
+    --hash=sha256:c589f5023d471ce75dd2cce61acb25ed6347e562041588a1a366808f22d7176c \
+    --hash=sha256:cee808b405e9095506f4e4e89924bec7ea77eac3129b6fe36eda04364b3b343b \
+    --hash=sha256:d11a7bc1e02da8984d32e6de9e0826c6edac00eac17de270f372bf32f9a0af63 \
+    --hash=sha256:d2d9a63a9e6f2416ace8c109043a9280d6b34f34bb2e5421903e149403db40a6 \
+    --hash=sha256:d561a4c5747a1e6c7fa7c49a0292e78b4e8c456332caa084fc7abad8de828652 \
+    --hash=sha256:dd741c73440b328f937dc53b344ecadc46bc4f0cec0333a8f42b55f3468ce7ec \
+    --hash=sha256:de1064663aa7c839286488a319d2b3b478ca5ab5b2091ade888ed0eeca11a98a \
+    --hash=sha256:e252db239eb41c32248e096e0d170bce5896a4fd3405556362bc3dd83d912206 \
+    --hash=sha256:e59b60a0a4cb7541480e02090d37dc2df3b72df4c2e776fff64ce3a4e3dd4637 \
+    --hash=sha256:e671b2322ef09106ecb1ca0f4c398b134d5e2c1f80d7a4f3336847a3072c0e94 \
+    --hash=sha256:f9b093cb3b6c9d6233ef45a05cab064d2aa0a8cb3c5777084c9e20fcb77c2371
+    # via
+    #   langchain-core
+    #   langsmith
+websockets==16.1 \
+    --hash=sha256:00d50c0a27098fcb7ab47b3d99a1b1159b534dbcd959fbf05113ebc37e5f927b \
+    --hash=sha256:0352f5b38b40e857b6428d468fa21dbb4dd4a567d933c26d9831b4efe1b92f43 \
+    --hash=sha256:0b8d13ceabc5c60995f201b5211d76876e17e68706ebf5d3bc666b32eefff1a6 \
+    --hash=sha256:0c64c024ddf7a35331b21fcddb562a039c275d2c82e8c2d12939e7da23997270 \
+    --hash=sha256:115fc4695b94bb855995b23fb1abcb66099a5995575d3d5bc5605a616c58d0eb \
+    --hash=sha256:187323204c3b2fc465e8fc2609e60437c521790cb9c1acb49c4c452a33e57f37 \
+    --hash=sha256:1a9f08a0728b0835f1c6abe1d9b746ab3de49b7336a0e1919cf96be1e76273eb \
+    --hash=sha256:1acb698bff1da1782b31aebd8d7a24d7d05453964abcd7d03dbf6e25893908e8 \
+    --hash=sha256:1facd189d8190af30487a55b4c3688484dd50801628a3b5b2ccd26db08e67057 \
+    --hash=sha256:2237081454846fb40403a80ba86d82e2038b9c45865ab96af0abe7d002a91045 \
+    --hash=sha256:23e545ea8ae4263e37cdfd4e22a217f519e48e432728bc461185bbf585f38a83 \
+    --hash=sha256:299468cbe42e2b9981134c7c51d99387d8a7bf562b00183b3eec53f882846dad \
+    --hash=sha256:2bd3e12cd9afbe2baedae0b1eeade8ba64329b60fe2f9abdc966bd10fd2c2ef5 \
+    --hash=sha256:2c1c85f61bc9d5eac57ce705d848dc2d2ce3680638300bf4e1da7d749e2cf4ce \
+    --hash=sha256:2ed64e5a97b0b97a0b66e18bfe281317a75fbbd5afe692f939ea8d14a4292f2c \
+    --hash=sha256:353f3bc6e058ac1ccab4b3588e8598837a8c04cfc8351233e6d523be675d844c \
+    --hash=sha256:35f41979c8623df9bd30d949d82010a8fda5c56ff12cd8508a5b7272b6d4b53a \
+    --hash=sha256:37b0e4d726ffea3776670092d3d13e1cb605076f036a695fd1259de0d9b9fe02 \
+    --hash=sha256:39c7e7730be33b8f0cd6f0aa8e8c82f9cdd1813f159765e073b2ece65f4824b5 \
+    --hash=sha256:3fd3e6a7af2c8fcdcf4ffbeaf7f54a567b91a83267204187797f31faaa2a4efa \
+    --hash=sha256:4e969170c3b08e1d8dabd990fef1fa702c4233aeaabec33f871806e444f6a0e4 \
+    --hash=sha256:5f5218de1ed047385ca53744caba9435d65f75d008364970a3fae95a05812cf9 \
+    --hash=sha256:63339bc8c63c86a463177775cb7c677691f5bcfac7b3b2f01b286d42acd41600 \
+    --hash=sha256:638cf57c48b4ad8ac1ff1e453f4f97db2426b690ddc111e6da96b27b4a340bc3 \
+    --hash=sha256:67b56828712f5fa7852de4c0265c28827311a657a4d275b7312ed0d1a918bee4 \
+    --hash=sha256:6852c9f653966c16109d3b6f31181fd734f7914927e3f0fa1117af7a18c9aa21 \
+    --hash=sha256:6c1eb7df4170d5068892a8834fb5c07b9552353deb0dbeb0bff3820481ae4792 \
+    --hash=sha256:6eb604a4167f0a0d53c2243dfc667a29f0b43c3436057184e070bb82a1000fa2 \
+    --hash=sha256:70bd789afab579602968c39f21cb925466505f3edff22f0ae852bca54978a4f9 \
+    --hash=sha256:7289d899c79e763e6221c8dcb8959361cb43274418538d7c7ad16a43b01d12f9 \
+    --hash=sha256:75c98e3920039d0edff03b74478ada504b7ce3a1bc406db2cabfca84320f7baf \
+    --hash=sha256:81495f9c0085361c582efbc3207fb877174cfe03370f17d9cd70624404aa526f \
+    --hash=sha256:83bdabafef431247e6b11a9aab8a0893fd8e82e1ed95b32e0373625b03ffce4a \
+    --hash=sha256:84c170c6869633536921e4474b1cce7254c0c9b0053ef5725f966cee47e718e4 \
+    --hash=sha256:8fdf0b00d0d1f30d1f06a92cab46fe542eec3eb302a7aee7163f142d0780f216 \
+    --hash=sha256:97f15b6d9ea9c2eaf6ccab964a082b09bfa6634a495bb0c2e9e7ee6943f58976 \
+    --hash=sha256:9a3f125e44c3e34d61d111652e608e0f5b85ce08c225c8d56ad0eb822fa40030 \
+    --hash=sha256:9b3b021d0ed4bc16eea9775f62c9fa71acdacba0fc790b38581754dedf29ca60 \
+    --hash=sha256:9c1cf6f9a936b030b5bed0e800c5ee32069338129084546baf5ff5014dc62fa9 \
+    --hash=sha256:9dba74233c8c3ce368850818c98354dad2570f57231b3fd3bd00d7aa57628881 \
+    --hash=sha256:a089979d6173b27af18026c8d8b0077f83669a9169174482c4651e9f5739a5b6 \
+    --hash=sha256:a24d1f35aef07d794a16c853c688e74956c50239bec37b4f2de080056046419b \
+    --hash=sha256:a3c18dba232ec2b92a68579c9fed8ff5a18f853d1e09fc0b6ca3159e94f689fe \
+    --hash=sha256:a3cd6c9b798218798f4bb7b2e71c38f0e744bb94ca537b13376f88019d46384d \
+    --hash=sha256:a58532c49a851bcb481e58c1be23b315c17fe2fbbed509d75aeea12f543d2c15 \
+    --hash=sha256:a71b73d143991714144e159f767b698f03c4a70b8a65ae1733b650cff488045b \
+    --hash=sha256:a9b1d7a63cba8e6b9b77e499a81eab29d31100298d090ad4507d1048c0b9cae0 \
+    --hash=sha256:ad9411eded8988b879be6038206698bf7106c85a78f642c004485bcb95be17eb \
+    --hash=sha256:b0232ed141cec3df2af5a3959a071c51f40036336b0d37e17faf9ef52fc73e47 \
+    --hash=sha256:b43fcfb521ac2f34ba80b7b8ea16303e4ad82dd8af667bf40839ad3a5d37b164 \
+    --hash=sha256:b6aa3f7ad345cf3862c21f4fbf2ef5e14d911348476c2845e137c091fe3a3f0b \
+    --hash=sha256:b9f5d83f80f4d7c4bba6d97f3755ac05850c784dce0fd2ab371c4e41172f53ff \
+    --hash=sha256:bedbc5efeb96621aa2921d2d92608246691399418cac22acba427eb11877ea1f \
+    --hash=sha256:bef52d327d70fa75dad93ee61ea2cb1d1489aca9f35c188833563f5a3b4df0a5 \
+    --hash=sha256:c14b6634af01541e4efe2954fd8f263386f7aa6d37c01e55dd8109fd17661452 \
+    --hash=sha256:c3e99757f5baafe20fc598e202ea6f5b0b265186ad38d0a17bd8beca16296955 \
+    --hash=sha256:c5149dfe490ec7e5ee5dbf624c642fb725f93a5575c7f00ab594ca9eddb8dd81 \
+    --hash=sha256:c522bd48e625b6d557aa228967258d6d3da031c4cc21d3352fb302479aa9ba0a \
+    --hash=sha256:c54fe94fb2f11e11b48920c5f971e298cec73ac35db56efe57a49db63dfc95d4 \
+    --hash=sha256:cc0c6a6eef613c7da32d4fb068f82ef834b58134f6a16b54e6c1e5bf9529ab3d \
+    --hash=sha256:cce36c80b3f2fede7942f1756d3d885fa6fa086766c8c1bcf00695ab80f0d51a \
+    --hash=sha256:cd68f0914f3b64694895bc5e9b14e8b447e41d7bf5ffaf989bb8dcb5e2dfdce7 \
+    --hash=sha256:d0fb4b46f121eccd539353baebd1083a8767a9a351109453d1d1caecd1ba40c2 \
+    --hash=sha256:d106396927a7f00b0f3a69215c3357f87bf0bca6844247121f7e8291e826a3b1 \
+    --hash=sha256:d71bed12909b8039955536e192867d02d76cd3797cedfd0facf822e7668636c3 \
+    --hash=sha256:dc2c453f3b5f99c56b16e233aad5299860558487d26adb2ed27a00c14ca24b8c \
+    --hash=sha256:dddd27175bf640acae5561fa79b77e8ec71fc445816200523e5c19b6a556fb72 \
+    --hash=sha256:de72a9c611178b15557d98eabd3101c9663c4d68938510478a6d162f99afd213 \
+    --hash=sha256:e22e9e3719f5131bd62da4db63c8da63eb8c91cc99e16c1cbd122f130e1ae07a \
+    --hash=sha256:e2fb33ccb16ee40a95cc676d7b0ff451a9a2632f11a0dbc2e666326892b2e1de \
+    --hash=sha256:eeab6d27f51c7e579023c971f5e6dff200deadf01faf6831beaecd32052dfaef \
+    --hash=sha256:f9f4fb9ae8b802e55609685db98382d48fd3feb1397804e1e774968dea0f28c7 \
+    --hash=sha256:fd847ab82133015afe65d778e7966ab42dba16bd7ad2e5b8a7918db6539f3f94 \
+    --hash=sha256:fef2debfe7f7ebdda12176f26166f95b7af17af05ba06150fcf889032e0213e9 \
+    --hash=sha256:ff9b000064b88787ba9f7a3cb2af2b68a658ca5aad76458a46469e7124b678a0
+    # via langsmith
+xxhash==3.8.1 \
+    --hash=sha256:00de40f3b42240db23a82a5c682b55d7263d84a26a953240c1aee463409660e3 \
+    --hash=sha256:0204701e6d01f64254e0e5ff4255812b1febe027ddd7dda63372e27f98b5e91f \
+    --hash=sha256:027dee4355f3fcc41481650d846cf6cfc895c85a1ab7acd063063821a0df5b4c \
+    --hash=sha256:036a024d8b9c01f70782e09ed98d532e76fd23f950ae7154bd950fe94e90ebec \
+    --hash=sha256:0418ec8b2331b9d4d575fc9284427e8e69449d7172e99e1a86fcdd1f51a0a937 \
+    --hash=sha256:08ea2081f5e88615fec8622a9f87fbe21b8ea58d88cfc02163ca11026ee62a92 \
+    --hash=sha256:095e1323fa108be1292c54c86da3ef3c7a7dc015b105a52133973bc07a6ad11a \
+    --hash=sha256:09a204dd4bb0823daf938cdd0dc8057d5f1e14fe3cbde929424255f23f9de872 \
+    --hash=sha256:0fe37f72a207223d22a4eddc3149d4298993385aa9daef25c039246ca5a309f3 \
+    --hash=sha256:10e4393ec33633c2f05ad01869e546ad080b1a18f2650503731f153774608b31 \
+    --hash=sha256:12eaeaa9ab8b9e6033a1fa5f6b338aaf55ff4df4bee11b59fd6ee03b19186ee4 \
+    --hash=sha256:131324f719957b988861714de7d6ddf57b47abec3b0cc691302ffeaba0e05e10 \
+    --hash=sha256:1b86ae798a976ccbc1d02af6ccb98f5b4d24756b1f65e995f11d10fe071f486f \
+    --hash=sha256:1c332dd48b8cb050da2bb2a3c96d72b1664168650a250ef9718e423df7989e05 \
+    --hash=sha256:1f44275ddb0978b67a58a951501903f04d49335a91f7681c9ce122ecb8ccb329 \
+    --hash=sha256:220d68130f83f7cc86d6edfdeab176adc73d7200bf3a8ec10c629e8cf605c215 \
+    --hash=sha256:2256e80e4960ee282f63428adb349cb7f8bd8efe4db770d88eb815f4b9860724 \
+    --hash=sha256:2666f059a1588a99267e33605365ed89cea92f424b3522806a9f4bd8ad2e3d62 \
+    --hash=sha256:27a9e475157f7315826118e3f3127909a0fe25f1b43d3d3be9c584f9d265f937 \
+    --hash=sha256:27cfc2f1ed76f956f36dfe0c56e5f5a3e94cd91eb78b893f63e2ef2ae404fcdf \
+    --hash=sha256:2bc7113e6f2b6b3922dd61796ca9f36af09da3773898e7003038dc992fc83b8d \
+    --hash=sha256:2e32855b6f9e5b18f449e59d45e3d5778bdeb660632ef2693cca267a11246c75 \
+    --hash=sha256:2f8c25a7061d952de589bd0ea0eaadee32378ff83dd6a677b267f9cd86f401f8 \
+    --hash=sha256:32a94ad2763e0263d9102037d349002c3d3c401e42770542c3eeb4801f311661 \
+    --hash=sha256:32ab1e5432690276e71192be7401b55f96db2d0eedea5d44eb1f164505669cc0 \
+    --hash=sha256:345b07b78e2bf583d71682aa34ae5b5fab575f7a1cb31e10263ebbc6f89f8c42 \
+    --hash=sha256:3557bec8fcb11738a8920eeb68974bc76b75262f6947998d3147954ce0a4b893 \
+    --hash=sha256:36fc69160465ae75c6ec4ac9f781bb2aa16ae7ff869e73c26fee85fbb11b9887 \
+    --hash=sha256:37d5a56c36dcc0b9a87b814cd992598d33863ff683749de6c86081f278d5e629 \
+    --hash=sha256:39c9d5b61508b0bb68f29e54546de0ed2a74943c6a18585535a7e37356f1dd12 \
+    --hash=sha256:3a800912a2e5e975d4128969d645c4a2a80aa886ccd6c9b1c6f44529e327e8cf \
+    --hash=sha256:3c682fcd96eb4bf64be32a4d95f96107e1588005831bd8a741b324fdda01b913 \
+    --hash=sha256:445e0f5a31f2f3546ae0895d4811e159518cdc9d824c11419898d40cfadb677e \
+    --hash=sha256:4482380b462ca9e59994d072a877ecadd1cf51102daeeab2db696f96ab763723 \
+    --hash=sha256:49aa8692507835dcc1e8ad8021f20c74c2dc13d83b5112e87877faa2a0035b20 \
+    --hash=sha256:4b512261801b1e5fde7b6ebf2fef7977339c620cbbca88a0040ad9ad134f4d02 \
+    --hash=sha256:4d365ee1892c1fa803536f8c6ce21d24b29c9718ec75eb856095c07830f8c478 \
+    --hash=sha256:4e0e1b0fb0259c1b75d1251ac0bb4d7ab675d36f7a6bf4ba6aa630dae94f9ffa \
+    --hash=sha256:5013be3bea7612852c62a7437f3302c1cfb91ca7e703b194459db0b2b2e0d792 \
+    --hash=sha256:5177aa44eddaa97c6ef0cc00c6d540edb64d51781d2f8fb941612ec61a92c9ed \
+    --hash=sha256:51f71a6e2ad071e70c937e41fcb6c19f82c3f9f49831eba850ed4a106ffbb647 \
+    --hash=sha256:538f5f865df6cd8c32dd63158a0e5b4f5dd08d732a7da8b7228a5a0776c8ce55 \
+    --hash=sha256:57189a69c0891e4818853feaa521c972d22c880a001453addea015f48e3c3398 \
+    --hash=sha256:5b96f0024e9840f449bd91b2d005c921a4b666055a0d1b6492463799f32aae22 \
+    --hash=sha256:5c566b123dce7e4867ca518434cdfb9f84e5023771235b2e3107a26c9a41cbd8 \
+    --hash=sha256:5d3dfb1f0ff146da7952867a9414f0c7a29762f8825a84879592612fd6139342 \
+    --hash=sha256:5db43f249b4be9f99ef4b967863f37094fb40e67effafb78ba4f0356b6396104 \
+    --hash=sha256:5eed32dad81d6ba8e62dc7b9ffa0500199385d7810a8dd9d4eafaceb8c6e20bb \
+    --hash=sha256:602efcad4a42c184e81d43a2b7e6e4f524d619878f2b6ee2ba469011f47c8147 \
+    --hash=sha256:64af54dd1c3a45a27c04942f9a1a4683322bdd127f4745cca4e02549c1d2d2bb \
+    --hash=sha256:6536d8677d2fff7e64cd0b98b976df9de7aee0e69590044c2af5f51b76b7a170 \
+    --hash=sha256:656256c9f9303e47f07d5cb8ae4468285370adfafd7ba48aea33a458e7697626 \
+    --hash=sha256:6696c8752aded28ff3b16f33ef28ce28fb5d209b80c206746f943199fcf5fd65 \
+    --hash=sha256:714503083a1f2065c9ad15340dd49ac8a8e948a505a705ffa1750cb951519113 \
+    --hash=sha256:72eb5ae575cc7ae2b23f6f8064a8b10f638c7149819ae9cc6d20ebd4d37a1629 \
+    --hash=sha256:7345007c12780985de4fd740148776d1eee18c0d41407c6fa1e48c5450304fe5 \
+    --hash=sha256:77f74e45a1e5574bbbf80181c8027b3a4c65c2248fffbd557bd596fff13102f9 \
+    --hash=sha256:7801b7223db017b9c0c9ccf37e44524edb35a1544a1c032add22c061c6af0276 \
+    --hash=sha256:7dc4bdf008f77c88d544849c48c1a40faf25a5eff6cc466de2e8edc37c191fce \
+    --hash=sha256:81f4ed9ca9644bc95cd976bfe10f7a4cafab8ffdc3aed52877d4600e445be7ef \
+    --hash=sha256:82c0cedd280eab2e8291270e6c04894dbc096f8159a39dcf1807429f026ca3cc \
+    --hash=sha256:8304be0982130954b7fd3aad18e2c6f8ee40254bc3d2e635991c16d77c91e2bd \
+    --hash=sha256:83697b0ea1f10e7f5d8b26a4906fa851393c61546c63839643a2b7fe2d868061 \
+    --hash=sha256:836f11d4474d3228e9909d97216faa4f7505df41cfaf3927eb29809de785a78d \
+    --hash=sha256:83b9130b80b216d56fdf9e87131946b353c9627930c061955a101ea82b09fed9 \
+    --hash=sha256:852bfe059720632e2f16a6a4745e41d20937b2bf2a42a401e2412046bb6971cc \
+    --hash=sha256:868a8dcaff1a84ba78038e1cef14fc88ccf84d9b4d12ea604696e0693296aa56 \
+    --hash=sha256:89b11a5cdd441aa463f6d34ca0241602bc09b001a76994b6059828494108c673 \
+    --hash=sha256:8ea8a141eeced4f6262ab6dd71c681ac546a558c30bb586abe087d814b5f85ea \
+    --hash=sha256:942bc86e9be6fdd6e1175048f5fe8f8fdaaf2309dd1323ef1e155a69cd346780 \
+    --hash=sha256:950ac754d16daea42038f38e7465eb84cda4d08d7343c1c915771b29470f065a \
+    --hash=sha256:98ee81b4b7f3023c9cb04a78cc67610baffcb5812d92f2096cb5a5efc6f19437 \
+    --hash=sha256:9b2ce44bf8f4a1d01f418b3110ff8dff32fd3f3e836c0e06333c3725f243fa6c \
+    --hash=sha256:9df56e6df96a60590935e22373041cccc91fd55858763dcffb55bf63b3a2b396 \
+    --hash=sha256:9e80238259655bf69d7bcd08226a970d7f42605f3157786bfa76dd13472d7fa0 \
+    --hash=sha256:9f23083e1bd9d901f844af7a126727c486e7eada9a1a6791c8f7e73f94fac656 \
+    --hash=sha256:a2489d3a776fa380cb8e71f54c7fda268a9baf3de9b1395093fd280f95735907 \
+    --hash=sha256:a5cd96f6dcdf4fa657b2d95668d71d58455248f98712ecffaa9c528edf40ccae \
+    --hash=sha256:a6617f30641ba0d8baa1635fbefb1dffc5165ec36d26921bd5cee13497cd937a \
+    --hash=sha256:a6e088bd7870775624256a0d84c2a6714afd223b2eeb56b0ca58398e52a32fda \
+    --hash=sha256:a98b2f95cab589e0f5e92c48431afb4d56238b8bf6668edcc66166180e9b509b \
+    --hash=sha256:ad52a0e4bcc0ba956a953a169d1feec2734a64981d689e4fc8f490f7bf91af60 \
+    --hash=sha256:b0093cf7eeb91b84776e8742113afa4bdf47533d36cf719179aaaf1f56f6f8bf \
+    --hash=sha256:b0de4bf3aa66363552d52c6a89003c479911f12098cd48a53d44a0f7a25f7c46 \
+    --hash=sha256:b30e01a0b97a4bc3f519a4d7a82da3dc53251fb0de5eeea8660dcd4ff094c0c2 \
+    --hash=sha256:b3ba794c3d885803db6c3116686923f1ec13bc86e621e169a375282b63ea1cc6 \
+    --hash=sha256:b5196cc2574cfec572a5f3fb7cfa5ade27305ae3d06516a082132441aff4c83a \
+    --hash=sha256:bcab50a389cc04d87f90092af78a6adba2ab3deca63175a3344ca83514045315 \
+    --hash=sha256:bf28f55e427e0483acb1f666bd0d869b6d5e5a716680c216ad7befe3d4cfba2e \
+    --hash=sha256:bfcd82852c62a60e314670a9602de354c4460f8adad916e2e42a20860c7870bc \
+    --hash=sha256:c4ed42965c2cd9081f011be22f69d0e65d3b6165fe7734072fd0c232840bbd4e \
+    --hash=sha256:c85949d02c85adf6d786eb94858e124989a632a4e65739835b2fc5761827fac3 \
+    --hash=sha256:c959f88160b13b4e730b0d75b459b7929fc0d2225c284c9683ac95d6feeeac6a \
+    --hash=sha256:cb3fe820c27593f170770d6c8d791936cf6275d9269405fbb7b30a55363c10c8 \
+    --hash=sha256:d0b48cdf690a64cedf7258c3dc9506cc41fc86edd7739c40e3098952265dc068 \
+    --hash=sha256:d59e71153fe9ff85648d00e18649b07e9b22c797291abb7e27274fa06df8b838 \
+    --hash=sha256:d6a5c0bce213b23b0166fe0d35bcbbe23ce4b968f257cc7eb6fd57cb8e1e6297 \
+    --hash=sha256:daa86e4b68221d38e669bb236ba112d0335353829fb627c82e5909e4bbe8694c \
+    --hash=sha256:db77278a6eddadbf44ce5aae2fee5ebb4d061f026b1ce2130d058cd4d7a7b670 \
+    --hash=sha256:dfe0580fbfd5e4af87d0cc52d2044f155d55ebd8c8a93568758a2ea7d8e15975 \
+    --hash=sha256:e2a845687219ba3214126f14a8a5861f97c9e065a7d0b8252adb6df13eea86fb \
+    --hash=sha256:e3b87cbd974512c0c5fc7b469c36b2cdc9ee6d76e4ec78bccb2c7184611c49b0 \
+    --hash=sha256:e4a6443968c4e8dc69967e12776776a5952c119cc1bd94168ad1c5ad667c2be1 \
+    --hash=sha256:e6e49370822c1f4d8d90e678b06dbcb08b51a026a7c4b55479e7d467f2e813bc \
+    --hash=sha256:e710ad822c493fb80a4fbc1e3d0a807b1422cb90adbe64378f98291b7fa48fef \
+    --hash=sha256:f377012b86c0a23a1df0cf5a1b05aa7187649e472f71c7892e5f2c2815bbe74f \
+    --hash=sha256:fb9e256a357dfcede7818c6d34e70db2d6b664394803d1de4b6984d2de76c0f1
+    # via langsmith
+yarl==1.24.2 \
+    --hash=sha256:044a09d8401fcf8681977faef6d286b8ade1e2d2e9dceda175d1cfa5ca496f30 \
+    --hash=sha256:08d3a33218e0c64393e7610284e770409a9c31c429b078bcb24096ed0a783b8f \
+    --hash=sha256:0a6377060e7927187a42b7eb202090cbe2b34933a4eeaf90e3bd9e33432e5cae \
+    --hash=sha256:15c0b5e49d3c44e2a0b93e6a49476c5edad0a7686b92c395765a7ea775572a75 \
+    --hash=sha256:17076578bce0049a5ce57d14ad1bded391b68a3b213e9b81b0097b090244999a \
+    --hash=sha256:1a97e42c8a2233f2f279ecadd9e4a037bcb5d813b78435e8eedd4db5a9e9708c \
+    --hash=sha256:1e831894be7c2954240e49791fa4b50c05a0dc881de2552cfe3ffd8631c7f461 \
+    --hash=sha256:204e7a61ce99919c0de1bf904ab5d7aa188a129ea8f690a8f76cfb6e2844dc44 \
+    --hash=sha256:246d32a53a947c8f0189f5d699cbd4c7036de45d9359e13ba238d1239678c727 \
+    --hash=sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9 \
+    --hash=sha256:3065657c80a2321225e804048597ad55658a7e76b32d6f5ee4074d04c50401db \
+    --hash=sha256:33a29b5d00ccbf3219bb3e351d7875739c19481e030779f48cc46a7a71681a9b \
+    --hash=sha256:34263e2fa8fb5bb63a0d97706cda38edbad62fddb58c7f12d6acbc092812aa50 \
+    --hash=sha256:349de4701dc3760b6e876628423a8f147ef4f5599d10aba1e10702075d424ed9 \
+    --hash=sha256:36348bebb147b83818b9d7e673ea4debc75970afc6ffdc7e3975ad05ce5a58c1 \
+    --hash=sha256:374423f70754a2c96942ede36a29d37dc6b0cb8f92f8d009ddf3ed78d3da5488 \
+    --hash=sha256:3b075301a2836a0e297b1b658cb6d6135df535d62efefdd60366bd589c2c82f2 \
+    --hash=sha256:3f6d2c216318f8f32038ca3f72501ba08536f0fd18a36e858836b121b2deed9f \
+    --hash=sha256:47a55d6cf6db2f401017a9e96e5288844e5051911fb4e0c8311a3980f5e59a7d \
+    --hash=sha256:49016d82f032b1bd1e10b01078a7d29ae71bf468eeae0ea22df8bab691e60003 \
+    --hash=sha256:491ac9141decf49ee8030199e1ee251cdff0e131f25678817ff6aa5f837a3536 \
+    --hash=sha256:4b156914620f0b9d78dc1adb3751141daee561cfec796088abb89ed49d220f1a \
+    --hash=sha256:4b85b8825e631295ff4bc8943f7471d54c533a9360bbe15ebb38e018b555bb8a \
+    --hash=sha256:50713f1d4d6be6375bb178bb43d140ee1acb8abe589cd723320b7925a275be1e \
+    --hash=sha256:507cc19f0b45454e2d6dcd62ff7d062b9f77a2812404e62dbdaec05b50faa035 \
+    --hash=sha256:5249a113065c2b7a958bc699759e359cd61cfc81e3069662208f48f191b7ed12 \
+    --hash=sha256:5cb0f995a901c36be096ccbf4c673591c2faabbe96279598ffaec8c030f85bf4 \
+    --hash=sha256:5d699376c4ca3cba49bbfae3a05b5b70ded572937171ce1e0b8d87118e2ba294 \
+    --hash=sha256:5ec8356b8a6afcf81fc7aeeef13b1ff7a49dec00f313394bbb9e83830d32ccd7 \
+    --hash=sha256:60de6742447fbbf697f16f070b8a443f1b5fe6ca3826fbef9fe70ecd5328e643 \
+    --hash=sha256:64480fb3e4d4ed9ed71c48a91a477384fc342a50ca30071d2f8a88d51d9c9413 \
+    --hash=sha256:6b208bb939099b4b297438da4e9b25357f0b1c791888669b963e45b203ea9f36 \
+    --hash=sha256:7b54b9c67c2b06bd7b9a77253d242124b9c95d2c02def5a1144001ee547dd9d5 \
+    --hash=sha256:7d37fb7c38f2b6edab0f845c4f85148d4c44204f52bc127021bd2bc9fdbf1656 \
+    --hash=sha256:7dafe10c12ddd4d120d528c4b5599c953bd7b12845347d507b95451195bb6cad \
+    --hash=sha256:7e7ebcdef69dec6c6451e616f32b622a6d4a2e92b445c992f7c8e5274a6bbc4c \
+    --hash=sha256:7f4425fa244fbf530b006d0c5f79ce920114cfff5b4f5f6056e669f8e160fdc0 \
+    --hash=sha256:810e19b685c8c3c5862f6a38160a1f4e4c0916c9390024ec347b6157a45a0992 \
+    --hash=sha256:819ca24f8eafcfb683c1bd5f44f2f488cea1274eb8944731ffd2e1f10f619342 \
+    --hash=sha256:8372a2b976cf70654b2be6619ab6068acabb35f724c0fda7b277fbf53d66a5cf \
+    --hash=sha256:863297ddede92ee49024e9a9b11ecb59f310ca85b60d8537f56bed9bbb5b1986 \
+    --hash=sha256:8ae44649b00947634ab0dab2a374a638f52923a6e67083f2c156cd5cbd1a881d \
+    --hash=sha256:8d027d56f1035e339d1001ac33eceab5b2ec8e42e449787bb75e289fb9a5cd1d \
+    --hash=sha256:91e72cf093fd833483a97ee648e0c053c7c629f51ff4a0e7edd84f806b0c5617 \
+    --hash=sha256:990de4f680b1c217e77ff0d6aa0029f9eb79889c11fb3e9a3942c7eba29c1996 \
+    --hash=sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8 \
+    --hash=sha256:a1cab588b4fa14bea2e55ebea27478adfb05372f47573738e1acc4a36c0b05d2 \
+    --hash=sha256:a9532c57211730c515341af11fef6e9b61d157487272a096d0c04da445642592 \
+    --hash=sha256:abb8ec0323b80161e3802da3150ef660b41d0e9be2048b76a363d93eee992c2b \
+    --hash=sha256:acf93187c3710e422368eb768aee98db551ec7c85adc250207a95c16548ab7ac \
+    --hash=sha256:b3177bc0a768ef3bacceb4f272632990b7bea352f1b2f1eee9d6d6ff16516f92 \
+    --hash=sha256:b32c37a7a337e90822c45797bf3d79d60875cfcccd3ecc80e9f453d87026c122 \
+    --hash=sha256:b975866c184564c827e0877380f0dae57dcca7e52782128381b72feff6dfceb8 \
+    --hash=sha256:c4c17bad5a530912d2111825d3f05e89bab2dd376aaa8cbc77e449e6db63e576 \
+    --hash=sha256:cb84b80d88e19ede158619b80813968713d8d008b0e2497a576e6a0557d50712 \
+    --hash=sha256:cdfcce633b4a4bb8281913c57fcafd4b5933fbc19111a5e3930bbd299d6102f1 \
+    --hash=sha256:d162677af8d5d3d6ebab8394b021f4d041ac107a4b705873148a77a49dc9e1b2 \
+    --hash=sha256:d1dd47a22843b212baa8d74f37796815d43bd046b42a0f41e9da433386c3136b \
+    --hash=sha256:e196952aacaf3b232e265ff02980b64d483dc0972bd49bcb061171ff22ac203a \
+    --hash=sha256:e26acf20c26cb4fefc631fdb75aca2a6b8fa8b7b5d7f204fb6a8f1e63c706f53 \
+    --hash=sha256:e30dd55825dc554ec5b66a94953b8eda8745926514c5089dfcacecb9c99b5bd1 \
+    --hash=sha256:e7977781f83638a4c73e0f88425563d70173e0dfd90ac006a45c65036293ee3c \
+    --hash=sha256:e89418f65eda18f99030386305bd44d7d504e328a7945db1ead514fbe03a0607 \
+    --hash=sha256:ec87ccc31bd21db7ad009d8572c127c1000f268517618a4cc09adba3c2a7f21c \
+    --hash=sha256:f408eace7e22a68b467a0562e0d27d322f91fe3eaaa6f466b962c6cfaea9fa39 \
+    --hash=sha256:f4b0352fd41fd34b6651934606268816afd6914d09626f9bcbbf018edb0afb3f \
+    --hash=sha256:f5f0cbb112838a4a293985b6ed73948a547dadcc1ba6d2089938e7abdedceef8 \
+    --hash=sha256:f5f5c6ec23a9043f2d139cc072f53dd23168d202a334b9b2fda8de4c3e890d90 \
+    --hash=sha256:f8fdbcff8b2c7c9284e60c196f693588598ddcee31e11c18e14949ce44519d45 \
+    --hash=sha256:f9a1e9b622ca284143aab5d885848686dcd85453bb1ca9abcdb7503e64dc0056
+    # via aiohttp
+zstandard==0.25.0 \
+    --hash=sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64 \
+    --hash=sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a \
+    --hash=sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6 \
+    --hash=sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431 \
+    --hash=sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250 \
+    --hash=sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa \
+    --hash=sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f \
+    --hash=sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851 \
+    --hash=sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3 \
+    --hash=sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9 \
+    --hash=sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6 \
+    --hash=sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5 \
+    --hash=sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137 \
+    --hash=sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa \
+    --hash=sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd \
+    --hash=sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701 \
+    --hash=sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0 \
+    --hash=sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1 \
+    --hash=sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611 \
+    --hash=sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b \
+    --hash=sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e \
+    --hash=sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa \
+    --hash=sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0 \
+    --hash=sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7 \
+    --hash=sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf \
+    --hash=sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902 \
+    --hash=sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc \
+    --hash=sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98 \
+    --hash=sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a \
+    --hash=sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097 \
+    --hash=sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea \
+    --hash=sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09 \
+    --hash=sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb \
+    --hash=sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7 \
+    --hash=sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74 \
+    --hash=sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b \
+    --hash=sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b \
+    --hash=sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b \
+    --hash=sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91 \
+    --hash=sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150 \
+    --hash=sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049 \
+    --hash=sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a \
+    --hash=sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00 \
+    --hash=sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd \
+    --hash=sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072 \
+    --hash=sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c \
+    --hash=sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065 \
+    --hash=sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512 \
+    --hash=sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1 \
+    --hash=sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f \
+    --hash=sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab \
+    --hash=sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b \
+    --hash=sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550 \
+    --hash=sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea \
+    --hash=sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277 \
+    --hash=sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778 \
+    --hash=sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2 \
+    --hash=sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d \
+    --hash=sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd \
+    --hash=sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e \
+    --hash=sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f \
+    --hash=sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e \
+    --hash=sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94 \
+    --hash=sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708 \
+    --hash=sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313 \
+    --hash=sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4 \
+    --hash=sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551 \
+    --hash=sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01
+    # via langsmith
diff --git a/requirements/requirements-train-local.lock.txt b/requirements/requirements-train-local.lock.txt
new file mode 100644
index 0000000..a7d46c1
--- /dev/null
+++ b/requirements/requirements-train-local.lock.txt
@@ -0,0 +1,1214 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --python 3.12 --no-emit-project --group ort-training-local --format requirements.txt -o requirements/requirements-train-local.lock.txt
+./third_party/wheels/onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl ; python_full_version == '3.12.*' \
+    --hash=sha256:87e6f3c661b0a4c6bcaa347c3abcb9ebe05943e2b44cae04701fca89bd14c65d
+accelerate==1.14.0 \
+    --hash=sha256:41b9c4377a54e0b460a959b0defa1b736e4ca0a2373252d9a539964c2afe3c8d \
+    --hash=sha256:e94390c2863b873be18f623f9df48a0d8fe5eff13ea7f1a00092b0a7904888c6
+    # via peft
+annotated-types==0.7.0 \
+    --hash=sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 \
+    --hash=sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89
+    # via pydantic
+ast-serialize==0.6.0 \
+    --hash=sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596 \
+    --hash=sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e \
+    --hash=sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a \
+    --hash=sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a \
+    --hash=sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790 \
+    --hash=sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e \
+    --hash=sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1 \
+    --hash=sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b \
+    --hash=sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe \
+    --hash=sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b \
+    --hash=sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32 \
+    --hash=sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081 \
+    --hash=sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b \
+    --hash=sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e \
+    --hash=sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77 \
+    --hash=sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b \
+    --hash=sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7 \
+    --hash=sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad
+    # via mypy
+cerberus==1.3.8 ; python_full_version == '3.12.*' \
+    --hash=sha256:46c029e3e2a4735408ed36bec14ef2cbf3e50d8ebe47fb34ee1e54b2da814df2 \
+    --hash=sha256:579554887ffd189226774b87570f4a76db75cf0efcbaffcacd5e98b8ee877f61
+    # via onnxruntime-training
+certifi==2026.6.17 \
+    --hash=sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432 \
+    --hash=sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db
+    # via requests
+charset-normalizer==3.4.9 \
+    --hash=sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62 \
+    --hash=sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c \
+    --hash=sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5 \
+    --hash=sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99 \
+    --hash=sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec \
+    --hash=sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698 \
+    --hash=sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3 \
+    --hash=sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2 \
+    --hash=sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a \
+    --hash=sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419 \
+    --hash=sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da \
+    --hash=sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe \
+    --hash=sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381 \
+    --hash=sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614 \
+    --hash=sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0 \
+    --hash=sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29 \
+    --hash=sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0 \
+    --hash=sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9 \
+    --hash=sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63 \
+    --hash=sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd \
+    --hash=sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde \
+    --hash=sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012 \
+    --hash=sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1 \
+    --hash=sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15 \
+    --hash=sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b \
+    --hash=sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993 \
+    --hash=sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5 \
+    --hash=sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8 \
+    --hash=sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35 \
+    --hash=sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642 \
+    --hash=sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2 \
+    --hash=sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d \
+    --hash=sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9 \
+    --hash=sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33 \
+    --hash=sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db \
+    --hash=sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee \
+    --hash=sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84 \
+    --hash=sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44 \
+    --hash=sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9 \
+    --hash=sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8 \
+    --hash=sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b \
+    --hash=sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39 \
+    --hash=sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0 \
+    --hash=sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616 \
+    --hash=sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d \
+    --hash=sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2 \
+    --hash=sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b \
+    --hash=sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9 \
+    --hash=sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b \
+    --hash=sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209 \
+    --hash=sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a \
+    --hash=sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b \
+    --hash=sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9 \
+    --hash=sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115
+    # via requests
+colorama==0.4.6 ; sys_platform == 'win32' \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via
+    #   pytest
+    #   tqdm
+exceptiongroup==1.3.1 ; python_full_version < '3.11' \
+    --hash=sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219 \
+    --hash=sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598
+    # via pytest
+filelock==3.29.7 \
+    --hash=sha256:5b481979797ae69e72f0b389d89a80bdd585c260c5b3f1fb9c0a5ba9bb3f195d \
+    --hash=sha256:987db6f789a3a2a59f55081801b2b3697cb97e2a736b5f1a9e99b559285fbc51
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+flatbuffers==24.3.25 ; python_full_version == '3.12.*' \
+    --hash=sha256:8dbdec58f935f3765e4f7f3cf635ac3a77f83568138d6a2311f524ec96364812 \
+    --hash=sha256:de2ec5b203f21441716617f38443e0a8ebf3d25bf0d9c0bb0ce68fa00ad546a4
+    # via onnxruntime-training
+fsspec==2026.6.0 \
+    --hash=sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1 \
+    --hash=sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a
+    # via
+    #   huggingface-hub
+    #   torch
+h5py==3.16.0 ; python_full_version == '3.12.*' \
+    --hash=sha256:099f2525c9dcf28de366970a5fb34879aab20491589fa89ce2863a84218bb524 \
+    --hash=sha256:1677ad48b703f44efc9ea0c3ab284527f81bc4f318386aaaebc5fede6bbae56f \
+    --hash=sha256:171038f23bccddfc23f344cadabdfc9917ff554db6a0d417180d2747fe4c75a7 \
+    --hash=sha256:17d1f1630f92ad74494a9a7392ab25982ce2b469fc62da6074c0ce48366a2999 \
+    --hash=sha256:18f2bbcd545e6991412253b98727374c356d67caa920e68dc79eab36bf5fedad \
+    --hash=sha256:2b2c02b0a160faed5fb33f1ba8a264a37ee240b22e049ecc827345d0d9043074 \
+    --hash=sha256:314b6054fe0b1051c2b0cb2df5cbdab15622fb05e80f202e3b6a5eee0d6fe365 \
+    --hash=sha256:370a845f432c2c9619db8eed334d1e610c6015796122b0e57aa46312c22617d9 \
+    --hash=sha256:39c2838fb1e8d97bcf1755e60ad1f3dd76a7b2a475928dc321672752678b96db \
+    --hash=sha256:42108e93326c50c2810025aade9eac9d6827524cdccc7d4b75a546e5ab308edb \
+    --hash=sha256:42b012933a83e1a558c673176676a10ce2fd3759976a0fedee1e672d1e04fc9d \
+    --hash=sha256:656f00e4d903199a1d58df06b711cf3ca632b874b4207b7dbec86185b5c8c7d4 \
+    --hash=sha256:698dd69291272642ffda44a0ecd6cd3bda5faf9621452d255f57ce91487b9794 \
+    --hash=sha256:719439d14b83f74eeb080e9650a6c7aa6d0d9ea0ca7f804347b05fac6fbf18af \
+    --hash=sha256:7c4dd4cf5f0a4e36083f73172f6cfc25a5710789269547f132a20975bfe2434c \
+    --hash=sha256:7e420b539fb6023a259a1b14d4c9f6df8cf50d7268f48e161169987a57b737ff \
+    --hash=sha256:85b9c49dd58dc44cf70af944784e2c2038b6f799665d0dcbbc812a26e0faa859 \
+    --hash=sha256:86385ea895508220b8a7e45efa428aeafaa586bd737c7af9ee04661d8d84a10d \
+    --hash=sha256:8975273c2c5921c25700193b408e28d6bdd0111c37468b2d4e25dcec4cd1d84d \
+    --hash=sha256:9300ad32dea9dfc5171f94d5f6948e159ed93e4701280b0f508773b3f582f402 \
+    --hash=sha256:96b422019a1c8975c2d5dadcf61d4ba6f01c31f92bbde6e4649607885fe502d6 \
+    --hash=sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738 \
+    --hash=sha256:a6fbc5367d4046801f9b7db9191b31895f22f1c6df1f9987d667854cac493538 \
+    --hash=sha256:bdef06507725b455fccba9c16529121a5e1fbf56aa375f7d9713d9e8ff42454d \
+    --hash=sha256:c3f0a0e136f2e95dd0b67146abb6668af4f1a69c81ef8651a2d316e8e01de447 \
+    --hash=sha256:c5313566f4643121a78503a473f0fb1e6dcc541d5115c44f05e037609c565c4d \
+    --hash=sha256:dfc21898ff025f1e8e67e194965a95a8d4754f452f83454538f98f8a3fcb207e \
+    --hash=sha256:e06f864bedb2c8e7c1358e6c73af48519e317457c444d6f3d332bb4e8fa6d7d9 \
+    --hash=sha256:ec86d4fffd87a0f4cb3d5796ceb5a50123a2a6d99b43e616e5504e66a953eca3 \
+    --hash=sha256:fb1720028d99040792bb2fb31facb8da44a6f29df7697e0b84f0d79aff2e9bd3 \
+    --hash=sha256:ff24039e2573297787c3063df64b60aab0591980ac898329a08b0320e0cf2527 \
+    --hash=sha256:ffbab2fedd6581f6aa31cf1639ca2cb86e02779de525667892ebf4cc9fd26434
+    # via onnxruntime-training
+hf-xet==1.5.1 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' \
+    --hash=sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6 \
+    --hash=sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6 \
+    --hash=sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf \
+    --hash=sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e \
+    --hash=sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947 \
+    --hash=sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d \
+    --hash=sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350 \
+    --hash=sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e \
+    --hash=sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e \
+    --hash=sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283 \
+    --hash=sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4 \
+    --hash=sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8 \
+    --hash=sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577 \
+    --hash=sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43 \
+    --hash=sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff \
+    --hash=sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342 \
+    --hash=sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5
+    # via huggingface-hub
+huggingface-hub==0.36.2 \
+    --hash=sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a \
+    --hash=sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270
+    # via
+    #   accelerate
+    #   mobiletransformers
+    #   optimum
+    #   peft
+    #   tokenizers
+    #   transformers
+idna==3.18 \
+    --hash=sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2 \
+    --hash=sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848
+    # via requests
+iniconfig==2.3.0 \
+    --hash=sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730 \
+    --hash=sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12
+    # via pytest
+jinja2==3.1.6 \
+    --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \
+    --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67
+    # via torch
+librt==0.13.0 ; platform_python_implementation != 'PyPy' \
+    --hash=sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b \
+    --hash=sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd \
+    --hash=sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a \
+    --hash=sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6 \
+    --hash=sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7 \
+    --hash=sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1 \
+    --hash=sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082 \
+    --hash=sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781 \
+    --hash=sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac \
+    --hash=sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2 \
+    --hash=sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0 \
+    --hash=sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c \
+    --hash=sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14 \
+    --hash=sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5 \
+    --hash=sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde \
+    --hash=sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f \
+    --hash=sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628 \
+    --hash=sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c \
+    --hash=sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db \
+    --hash=sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650 \
+    --hash=sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b \
+    --hash=sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40 \
+    --hash=sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348 \
+    --hash=sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588 \
+    --hash=sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd \
+    --hash=sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927 \
+    --hash=sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89 \
+    --hash=sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3 \
+    --hash=sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5 \
+    --hash=sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9 \
+    --hash=sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176 \
+    --hash=sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a \
+    --hash=sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7 \
+    --hash=sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8 \
+    --hash=sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3 \
+    --hash=sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7 \
+    --hash=sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c \
+    --hash=sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03 \
+    --hash=sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d \
+    --hash=sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1 \
+    --hash=sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9 \
+    --hash=sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b \
+    --hash=sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566 \
+    --hash=sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc \
+    --hash=sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82 \
+    --hash=sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547 \
+    --hash=sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1 \
+    --hash=sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa \
+    --hash=sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a \
+    --hash=sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929 \
+    --hash=sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79 \
+    --hash=sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e \
+    --hash=sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21
+    # via mypy
+markupsafe==3.0.3 \
+    --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \
+    --hash=sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a \
+    --hash=sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf \
+    --hash=sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19 \
+    --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \
+    --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \
+    --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \
+    --hash=sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1 \
+    --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \
+    --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \
+    --hash=sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695 \
+    --hash=sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad \
+    --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \
+    --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \
+    --hash=sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa \
+    --hash=sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559 \
+    --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \
+    --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \
+    --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \
+    --hash=sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c \
+    --hash=sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a \
+    --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \
+    --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \
+    --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \
+    --hash=sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50 \
+    --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \
+    --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \
+    --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \
+    --hash=sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115 \
+    --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \
+    --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \
+    --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \
+    --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \
+    --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \
+    --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \
+    --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \
+    --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \
+    --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \
+    --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \
+    --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \
+    --hash=sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f \
+    --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \
+    --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \
+    --hash=sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c \
+    --hash=sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8 \
+    --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \
+    --hash=sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6 \
+    --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \
+    --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \
+    --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \
+    --hash=sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01 \
+    --hash=sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419 \
+    --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795 \
+    --hash=sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1 \
+    --hash=sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591 \
+    --hash=sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a
+    # via jinja2
+ml-dtypes==0.5.4 \
+    --hash=sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483 \
+    --hash=sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6 \
+    --hash=sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175 \
+    --hash=sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270 \
+    --hash=sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1 \
+    --hash=sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2 \
+    --hash=sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298 \
+    --hash=sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d \
+    --hash=sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de \
+    --hash=sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d \
+    --hash=sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90 \
+    --hash=sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb \
+    --hash=sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453 \
+    --hash=sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48 \
+    --hash=sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff \
+    --hash=sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460 \
+    --hash=sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac \
+    --hash=sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900 \
+    --hash=sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a \
+    --hash=sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c \
+    --hash=sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040 \
+    --hash=sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7 \
+    --hash=sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6 \
+    --hash=sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b \
+    --hash=sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328
+    # via
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+mpmath==1.3.0 \
+    --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \
+    --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c
+    # via sympy
+mypy==2.3.0 \
+    --hash=sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491 \
+    --hash=sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5 \
+    --hash=sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd \
+    --hash=sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc \
+    --hash=sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3 \
+    --hash=sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5 \
+    --hash=sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329 \
+    --hash=sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3 \
+    --hash=sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805 \
+    --hash=sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e \
+    --hash=sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7 \
+    --hash=sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494 \
+    --hash=sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88 \
+    --hash=sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee \
+    --hash=sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2 \
+    --hash=sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757 \
+    --hash=sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a \
+    --hash=sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b \
+    --hash=sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461 \
+    --hash=sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97 \
+    --hash=sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117 \
+    --hash=sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36 \
+    --hash=sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac \
+    --hash=sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c \
+    --hash=sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568 \
+    --hash=sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595 \
+    --hash=sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f \
+    --hash=sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1 \
+    --hash=sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6 \
+    --hash=sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c
+mypy-extensions==1.1.0 \
+    --hash=sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505 \
+    --hash=sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558
+    # via mypy
+networkx==3.4.2 ; python_full_version < '3.11' \
+    --hash=sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1 \
+    --hash=sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f
+    # via torch
+networkx==3.6.1 ; python_full_version >= '3.11' \
+    --hash=sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509 \
+    --hash=sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762
+    # via torch
+numpy==1.26.4 ; python_full_version == '3.12.*' \
+    --hash=sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b \
+    --hash=sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818 \
+    --hash=sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20 \
+    --hash=sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0 \
+    --hash=sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010 \
+    --hash=sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a \
+    --hash=sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71 \
+    --hash=sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110 \
+    --hash=sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a \
+    --hash=sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a \
+    --hash=sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5 \
+    --hash=sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed \
+    --hash=sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e \
+    --hash=sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a \
+    --hash=sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b \
+    --hash=sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0 \
+    --hash=sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2 \
+    --hash=sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a \
+    --hash=sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218 \
+    --hash=sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5 \
+    --hash=sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07 \
+    --hash=sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2 \
+    --hash=sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4 \
+    --hash=sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef \
+    --hash=sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f
+    # via
+    #   accelerate
+    #   h5py
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxruntime-training
+    #   onnxscript
+    #   optimum
+    #   peft
+    #   transformers
+numpy==2.2.6 ; python_full_version < '3.11' \
+    --hash=sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff \
+    --hash=sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47 \
+    --hash=sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84 \
+    --hash=sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d \
+    --hash=sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6 \
+    --hash=sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f \
+    --hash=sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b \
+    --hash=sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49 \
+    --hash=sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163 \
+    --hash=sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571 \
+    --hash=sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42 \
+    --hash=sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff \
+    --hash=sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491 \
+    --hash=sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4 \
+    --hash=sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566 \
+    --hash=sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf \
+    --hash=sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40 \
+    --hash=sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd \
+    --hash=sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06 \
+    --hash=sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282 \
+    --hash=sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680 \
+    --hash=sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db \
+    --hash=sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3 \
+    --hash=sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90 \
+    --hash=sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1 \
+    --hash=sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289 \
+    --hash=sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab \
+    --hash=sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c \
+    --hash=sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d \
+    --hash=sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb \
+    --hash=sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d \
+    --hash=sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a \
+    --hash=sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf \
+    --hash=sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1 \
+    --hash=sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2 \
+    --hash=sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a \
+    --hash=sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543 \
+    --hash=sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00 \
+    --hash=sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c \
+    --hash=sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f \
+    --hash=sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd \
+    --hash=sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868 \
+    --hash=sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303 \
+    --hash=sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83 \
+    --hash=sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3 \
+    --hash=sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d \
+    --hash=sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87 \
+    --hash=sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa \
+    --hash=sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f \
+    --hash=sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae \
+    --hash=sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda \
+    --hash=sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915 \
+    --hash=sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249 \
+    --hash=sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de \
+    --hash=sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8
+    # via
+    #   accelerate
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+    #   optimum
+    #   peft
+    #   transformers
+numpy==2.4.6 ; python_full_version == '3.11.*' \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via
+    #   accelerate
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+    #   optimum
+    #   peft
+    #   transformers
+numpy==2.5.1 ; python_full_version >= '3.13' \
+    --hash=sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2 \
+    --hash=sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1 \
+    --hash=sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b \
+    --hash=sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd \
+    --hash=sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e \
+    --hash=sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277 \
+    --hash=sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6 \
+    --hash=sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7 \
+    --hash=sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1 \
+    --hash=sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9 \
+    --hash=sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca \
+    --hash=sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d \
+    --hash=sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75 \
+    --hash=sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74 \
+    --hash=sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0 \
+    --hash=sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a \
+    --hash=sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3 \
+    --hash=sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1 \
+    --hash=sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6 \
+    --hash=sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9 \
+    --hash=sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3 \
+    --hash=sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2 \
+    --hash=sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107
+    # via
+    #   accelerate
+    #   ml-dtypes
+    #   mobiletransformers
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+    #   optimum
+    #   peft
+    #   transformers
+nvidia-cublas-cu12==12.6.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb \
+    --hash=sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668 \
+    --hash=sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.6.80 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc \
+    --hash=sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4 \
+    --hash=sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132 \
+    --hash=sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73 \
+    --hash=sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53 \
+    --hash=sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13 \
+    --hash=sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a
+    # via torch
+nvidia-cuda-runtime-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd \
+    --hash=sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f \
+    --hash=sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8 \
+    --hash=sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7 \
+    --hash=sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e
+    # via torch
+nvidia-cudnn-cu12==9.5.1.17 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2 \
+    --hash=sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def \
+    --hash=sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8
+    # via torch
+nvidia-cufft-cu12==11.3.0.4 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464 \
+    --hash=sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca \
+    --hash=sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb \
+    --hash=sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5 \
+    --hash=sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6
+    # via torch
+nvidia-cufile-cu12==1.11.1.6 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db \
+    --hash=sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159
+    # via torch
+nvidia-curand-cu12==10.3.7.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905 \
+    --hash=sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8 \
+    --hash=sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e \
+    --hash=sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117 \
+    --hash=sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf
+    # via torch
+nvidia-cusolver-cu12==11.7.1.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0 \
+    --hash=sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7 \
+    --hash=sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6 \
+    --hash=sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e \
+    --hash=sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c
+    # via torch
+nvidia-cusparse-cu12==12.5.4.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f \
+    --hash=sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20 \
+    --hash=sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73 \
+    --hash=sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1 \
+    --hash=sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.6.3 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7 \
+    --hash=sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1 \
+    --hash=sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46
+    # via torch
+nvidia-nccl-cu12==2.26.2 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522 \
+    --hash=sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6
+    # via torch
+nvidia-nvjitlink-cu12==12.6.85 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41 \
+    --hash=sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c \
+    --hash=sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvtx-cu12==12.6.77 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0 \
+    --hash=sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1 \
+    --hash=sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059 \
+    --hash=sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2 \
+    --hash=sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b
+    # via torch
+onnx==1.18.0 ; python_full_version == '3.12.*' \
+    --hash=sha256:030d9f5f878c5f4c0ff70a4545b90d7812cd6bfe511de2f3e469d3669c8cff95 \
+    --hash=sha256:102c04edc76b16e9dfeda5a64c1fccd7d3d2913b1544750c01d38f1ac3c04e05 \
+    --hash=sha256:230b0fb615e5b798dc4a3718999ec1828360bc71274abd14f915135eab0255f1 \
+    --hash=sha256:2f4d37b0b5c96a873887652d1cbf3f3c70821b8c66302d84b0f0d89dd6e47653 \
+    --hash=sha256:3c137eecf6bc618c2f9398bcc381474b55c817237992b169dfe728e169549e8f \
+    --hash=sha256:3d8dbf9e996629131ba3aa1afd1d8239b660d1f830c6688dd7e03157cccd6b9c \
+    --hash=sha256:4a3b50d94620e2c7c1404d1d59bc53e665883ae3fecbd856cc86da0639fd0fc3 \
+    --hash=sha256:4c8c4bbda760c654e65eaffddb1a7de71ec02e60092d33f9000521f897c99be9 \
+    --hash=sha256:521bac578448667cbb37c50bf05b53c301243ede8233029555239930996a625b \
+    --hash=sha256:6acafb3823238bbe8f4340c7ac32fb218689442e074d797bee1c5c9a02fdae75 \
+    --hash=sha256:6c093ffc593e07f7e33862824eab9225f86aa189c048dd43ffde207d7041a55f \
+    --hash=sha256:6f91930c1a284135db0f891695a263fc876466bf2afbd2215834ac08f600cfca \
+    --hash=sha256:73160799472e1a86083f786fecdf864cf43d55325492a9b5a1cfa64d8a523ecc \
+    --hash=sha256:735e06d8d0cf250dc498f54038831401063c655a8d6e5975b2527a4e7d24be3e \
+    --hash=sha256:8521544987d713941ee1e591520044d35e702f73dc87e91e6d4b15a064ae813d \
+    --hash=sha256:911b37d724a5d97396f3c2ef9ea25361c55cbc9aa18d75b12a52b620b67145af \
+    --hash=sha256:9235b3493951e11e75465d56f4cd97e3e9247f096160dd3466bfabe4cbc938bc \
+    --hash=sha256:99afac90b4cdb1471432203c3c1f74e16549c526df27056d39f41a9a47cfb4af \
+    --hash=sha256:a5810194f0f6be2e58c8d6dedc6119510df7a14280dd07ed5f0f0a85bd74816a \
+    --hash=sha256:a69afd0baa372162948b52c13f3aa2730123381edf926d7ef3f68ca7cec6d0d0 \
+    --hash=sha256:aa1b7483fac6cdec26922174fc4433f8f5c2f239b1133c5625063bb3b35957d0 \
+    --hash=sha256:bfb1f271b1523b29f324bfd223f6a4cfbdc5a2f2f16e73563671932d33663365 \
+    --hash=sha256:e03071041efd82e0317b3c45433b2f28146385b80f26f82039bc68048ac1a7a0 \
+    --hash=sha256:e189652dad6e70a0465035c55cc565c27aa38803dd4f4e74e4b952ee1c2de94b \
+    --hash=sha256:e4da451bf1c5ae381f32d430004a89f0405bc57a8471b0bddb6325a5b334aa40 \
+    --hash=sha256:ee159b41a3ae58d9c7341cf432fc74b96aaf50bd7bb1160029f657b40dc69715
+    # via
+    #   mobiletransformers
+    #   onnx-ir
+    #   onnxruntime-training
+    #   onnxscript
+    #   optimum-onnx
+onnx==1.22.0 ; python_full_version != '3.12.*' \
+    --hash=sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5 \
+    --hash=sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c \
+    --hash=sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914 \
+    --hash=sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc \
+    --hash=sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103 \
+    --hash=sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b \
+    --hash=sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4 \
+    --hash=sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a \
+    --hash=sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c \
+    --hash=sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da \
+    --hash=sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573 \
+    --hash=sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58 \
+    --hash=sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec \
+    --hash=sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b \
+    --hash=sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6 \
+    --hash=sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16 \
+    --hash=sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016 \
+    --hash=sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0 \
+    --hash=sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f
+    # via
+    #   mobiletransformers
+    #   onnx-ir
+    #   onnxscript
+    #   optimum-onnx
+onnx-ir==0.2.1 \
+    --hash=sha256:8b8b10a93f43e65962104de6070c43c5dacb0e3cdfefc7c8059dd83c9db64f35 \
+    --hash=sha256:c7285da889312f91882de2092e298a9eeeefbfc1d1951c49d983992967eb09a7
+    # via onnxscript
+onnxscript==0.7.1 \
+    --hash=sha256:309fb86484b11fa4ded90dba580e0d63f1a0827588e521cecaf2eeddb46d6e86 \
+    --hash=sha256:544763b7fdef49940cdd9412ff5135cbae96d59ac6bc1921457f21280f40f4b7
+optimum==2.1.0 \
+    --hash=sha256:0a2a13f91500e41d34863ffdb08fcb886b3ce68a84a386e59653e3064a45dd4b \
+    --hash=sha256:bc3af32e1236a9b2c2ca1d27ed9d3ab1b6591e24c6bcd47f9671a8198a30ea88
+    # via optimum-onnx
+optimum-onnx==0.1.0 \
+    --hash=sha256:0301ec7a6ec5c77a57581e9970d380a6dc104bdb8f15b282e05af40d829c2eda \
+    --hash=sha256:182c54b25eddaded1618af7b58516da34749393a987ec7111f74677f249676f9
+packaging==25.0 \
+    --hash=sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484 \
+    --hash=sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f
+    # via
+    #   accelerate
+    #   huggingface-hub
+    #   onnxruntime-training
+    #   onnxscript
+    #   optimum
+    #   peft
+    #   pytest
+    #   transformers
+pathspec==1.1.1 \
+    --hash=sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+    # via mypy
+peft==0.13.2 \
+    --hash=sha256:0e0cbd40ebdf5fe4ea79f255880d02f96712d18899509369a2cc5768ad46d672 \
+    --hash=sha256:d4e0951ec78eac11c45a051801c569913436888c578d48e5ce86996b715bc6ef
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+protobuf==7.35.1 \
+    --hash=sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799 \
+    --hash=sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87 \
+    --hash=sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6 \
+    --hash=sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30 \
+    --hash=sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9 \
+    --hash=sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4 \
+    --hash=sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4 \
+    --hash=sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a
+    # via
+    #   onnx
+    #   onnxruntime-training
+psutil==7.2.2 \
+    --hash=sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372 \
+    --hash=sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9 \
+    --hash=sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63 \
+    --hash=sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979 \
+    --hash=sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b \
+    --hash=sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee \
+    --hash=sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312 \
+    --hash=sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b \
+    --hash=sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9 \
+    --hash=sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e \
+    --hash=sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc \
+    --hash=sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea \
+    --hash=sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988 \
+    --hash=sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486 \
+    --hash=sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8
+    # via
+    #   accelerate
+    #   peft
+pydantic==2.13.4 \
+    --hash=sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba \
+    --hash=sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6
+    # via mobiletransformers
+pydantic-core==2.46.4 \
+    --hash=sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0 \
+    --hash=sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262 \
+    --hash=sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda \
+    --hash=sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0 \
+    --hash=sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b \
+    --hash=sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594 \
+    --hash=sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2 \
+    --hash=sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c \
+    --hash=sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d \
+    --hash=sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398 \
+    --hash=sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d \
+    --hash=sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3 \
+    --hash=sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f \
+    --hash=sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7 \
+    --hash=sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4 \
+    --hash=sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d \
+    --hash=sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df \
+    --hash=sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2 \
+    --hash=sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd \
+    --hash=sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7 \
+    --hash=sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3 \
+    --hash=sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a \
+    --hash=sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987 \
+    --hash=sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e \
+    --hash=sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712 \
+    --hash=sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008 \
+    --hash=sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1 \
+    --hash=sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be \
+    --hash=sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea \
+    --hash=sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292 \
+    --hash=sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33 \
+    --hash=sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826 \
+    --hash=sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7 \
+    --hash=sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d \
+    --hash=sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf \
+    --hash=sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc \
+    --hash=sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3 \
+    --hash=sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b \
+    --hash=sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04 \
+    --hash=sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c \
+    --hash=sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b \
+    --hash=sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce \
+    --hash=sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4 \
+    --hash=sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a \
+    --hash=sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f \
+    --hash=sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894 \
+    --hash=sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9 \
+    --hash=sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76 \
+    --hash=sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb \
+    --hash=sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109 \
+    --hash=sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4 \
+    --hash=sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848 \
+    --hash=sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526 \
+    --hash=sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01 \
+    --hash=sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458 \
+    --hash=sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba \
+    --hash=sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39 \
+    --hash=sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b \
+    --hash=sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf \
+    --hash=sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4 \
+    --hash=sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd \
+    --hash=sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30 \
+    --hash=sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983 \
+    --hash=sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5 \
+    --hash=sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4 \
+    --hash=sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7 \
+    --hash=sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c \
+    --hash=sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3 \
+    --hash=sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89 \
+    --hash=sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50 \
+    --hash=sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76 \
+    --hash=sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b \
+    --hash=sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d \
+    --hash=sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4 \
+    --hash=sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c \
+    --hash=sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e
+    # via pydantic
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==9.1.1 \
+    --hash=sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313 \
+    --hash=sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c
+python-dotenv==1.2.2 \
+    --hash=sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a \
+    --hash=sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3
+    # via mobiletransformers
+pyyaml==6.0.3 \
+    --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \
+    --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \
+    --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \
+    --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \
+    --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \
+    --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \
+    --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \
+    --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \
+    --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via
+    #   accelerate
+    #   huggingface-hub
+    #   mobiletransformers
+    #   peft
+    #   transformers
+regex==2026.7.10 \
+    --hash=sha256:0639b2488b775a0109f55a5a2172deebdedb4b6c5ab0d48c90b43cbf5de58d17 \
+    --hash=sha256:081acf191b4d614d573a56cab69f948b6864daa5e3cc69f209ee92e26e454c2f \
+    --hash=sha256:1050fedf0a8a92e843971120c2f57c3a99bea86c0dfa1d63a9fac053fe54b135 \
+    --hash=sha256:13fba679fe035037e9d5286620f88bbfd105df4d5fcd975942edd282ab986775 \
+    --hash=sha256:14d27f6bd04beb01f6a25a1153d73e58c290fd45d92ba56af1bb44199fd1010d \
+    --hash=sha256:1f0d4ccf70b1d13711242de0ba78967db5c35d12ac408378c70e06295c3f6644 \
+    --hash=sha256:21150500b970b12202879dfd82e7fd809d8e853140fff84d08e57a90cf1e154e \
+    --hash=sha256:221f2771cb780186b94bbf125a151bbeb242fa1a971da6ad59d7b0370f19de9a \
+    --hash=sha256:234f8e0d65cf1df9becadae98648f74030ee85a8f12edcb5eb0f60a22a602197 \
+    --hash=sha256:28a0973eeffff4292f5a7ee498ab65d5e94ee8cc9cea364239251eb4a260a0f1 \
+    --hash=sha256:2b93eafd92c4128bab2f93500e8912cc9ecb3d3765f6685b902c6820d0909b6b \
+    --hash=sha256:2bc350e1c5fa250f30ab0c3e38e5cfdffcd82cb8af224df69955cab4e3003812 \
+    --hash=sha256:2c66a8a1969cfd506d1e203c0005fd0fc3fe6efc83c945606566b6f9611d4851 \
+    --hash=sha256:2f98ef73a13791a387d5c841416ad7f52040ae5caf10bcf46fa12bd2b3d63745 \
+    --hash=sha256:31fa17378b29519bfd0a1b8ba4e9c10cf0baf1cf4099b39b0689429e7dc2c795 \
+    --hash=sha256:3750c42d47712e362158a04d0fd80131f73a55e8c715b2885442a0ff6f9fc3fc \
+    --hash=sha256:396ea70e4ea1f19571940add3bad9fd3eb6a19dc610d0d01f692bc1ba0c10cb4 \
+    --hash=sha256:3d8ef9df02c8083c7b4b855e3cb87c8e0ebbcfea088d98c7a886aaefdf88d837 \
+    --hash=sha256:3e23458d8903e33e7d27196d7a311523dc4e2f4137a5f34e4dbd30c8d37ff33e \
+    --hash=sha256:3f03b92fb6ec739df042e45b06423fc717ecf0063e07ffe2897f7b2d5735e1e8 \
+    --hash=sha256:41a47c2b28d9421e2509a4583a22510dc31d83212fcf38e1508a7013140f71a8 \
+    --hash=sha256:4574feca202f8c470bf678aed8b5d89df04aaf8dc677f3b83d92825051301c0f \
+    --hash=sha256:4db009b4fc533d79af3e841d6c8538730423f82ea8508e353a3713725de7901c \
+    --hash=sha256:53bbbd6c610489700f7110db1d85f3623924c3f7c760f987eca033867360788a \
+    --hash=sha256:53f54993b462f3f91fea0f2076b46deb6619a5f45d70dbd1f543f789d8b900ef \
+    --hash=sha256:58a4571b2a093f6f6ee4fd281faa8ebf645abcf575f758173ea2605c7a1e1ecb \
+    --hash=sha256:5c363de7c0339d39341b6181839ed32509820b85ef506deafcf2e7e43baadab4 \
+    --hash=sha256:5e792367e5f9b4ffb8cad93f1beaa91837056b94da98aa5c65a0db0c1b474927 \
+    --hash=sha256:617e8f10472e34a8477931f978ff3a88d46ae2ba0e41927e580b933361f60948 \
+    --hash=sha256:64722a5031aeace7f6c8d5ea9a9b22d9368af0d6e8fa532585da8158549ea963 \
+    --hash=sha256:65ee5d1ac3cd541325f5ac92625b1c1505f4d171520dd931bda7952895c5321a \
+    --hash=sha256:66d2c35587cd601c95965d5c0415058ba5cfd6ffbab7624ce198bd967102b341 \
+    --hash=sha256:6cbedeb5112f59dbd169385459b9943310bdd241c6966c19c5f6e2295055c93a \
+    --hash=sha256:724ee9379568658ec06362cf24325c5315cc5a67f61dfe585bfeff58300a355b \
+    --hash=sha256:7252b48b0c60100095088fbeb281fca9a4fcf678a4e04b1c520c3f8613c952c4 \
+    --hash=sha256:732c19e5828eb287d01edb83b2eb87f283ba8e5fc3441c732709d3e8cbd14aaa \
+    --hash=sha256:74ae61d8573ecd51b5eeee7be2218e4c56e99c14fa8fcf97cf7519611d4be92e \
+    --hash=sha256:799a369bdab91dcf0eb424ebd7aa9650897025ce22f729248d8f2c72002c4daa \
+    --hash=sha256:80151ca5bfc6c4524186b3e08b499e97319b2001fc265ed2d4fc12c0d5692cdf \
+    --hash=sha256:82ab8330e7e2e416c2d42fcec67f02c242393b8681014750d4b70b3f158e1f08 \
+    --hash=sha256:8331484450b3894298bef8abecce532171ff6ac60b71f999eed10f2c01941a8a \
+    --hash=sha256:87794549a3f5c1c2bdfba2380c1bf87b931e375f4133d929da44f95e396bf5fe \
+    --hash=sha256:87b776cf2890e356e4ab104b9df846e169da3eb5b0f110975547091f4e51854e \
+    --hash=sha256:8e26a075fa9945b9e44a3d02cc83d776c3b76bb1ff4b133bbfa620d5650131da \
+    --hash=sha256:91b916d495db3e1b473c7c8e68733beec4dce8e487442db61764fff94f59740e \
+    --hash=sha256:948dfc62683a6947b9b486c4598d8f6e3ecc542478b6767b87d52be68aeb55c6 \
+    --hash=sha256:982d07727c809b42a3968785354f11c3728414e4e90af0754345b431b2c32561 \
+    --hash=sha256:9a094ed44a22f9da497453137c3118b531fd783866ab524b0b0fc146e7395e1d \
+    --hash=sha256:9d028d189d8f38d7ff292f22187c0df37f2317f554d2ed9a2908ada330af57c0 \
+    --hash=sha256:a2d6d30be35ddd70ce0f8ee259a4c25f24d6d689a45a5ac440f03e6bcc5a21d1 \
+    --hash=sha256:a68b637451d64ba30ed8ae125c973fa834cc2d37dfa7f154c2b479015d477ba8 \
+    --hash=sha256:aa34473fbcc108fea403074f3f45091461b18b2047d136f16ffaa4c65ad46a68 \
+    --hash=sha256:ab2fb1f7a2deb4ca3ddebbae6b93905d21480a3b4e11de28d79d9fb0d316fcf8 \
+    --hash=sha256:ab39d2c967aae3b48a412bff9cdbe7cd7559cd1e277599aceaeada7bc82b7200 \
+    --hash=sha256:b04583e8867136ae66353fa274f45121ab3ec3166dc45aaff3655a5db90d9f0e \
+    --hash=sha256:b1963ec5ba4d52788fb0eac6aca6eb8040e8e318c7e47ebbdfc09440c802919c \
+    --hash=sha256:b56416091bfd7a429f958f69aaf6823c517be9a49cb5bf1daa3767ce8bf8095e \
+    --hash=sha256:b96341cb29a3faa5db05aff29c77d141d827414f145330e5d8846892119351c1 \
+    --hash=sha256:bb52e10e453b5493afe1f7702a2973bc10f4dd8901c0f2ed869ffaa3f8319296 \
+    --hash=sha256:bb5aab464a0c5e03a97abad5bdf54517061ebbf72340d576e99ff661a42575cc \
+    --hash=sha256:be4223af640d0aa04c05db81d5d96ada3ead9c09187d892fd37f4f97829480be \
+    --hash=sha256:c2cbd385d82f63bb35edb60b09b08abad3619bd0a4a492ae59e55afaf98e1b9d \
+    --hash=sha256:c57b6ad3f7a1bdd101b2966f29dc161adf49727b1e8d3e1e89db2eda8a75c344 \
+    --hash=sha256:c622f4c638a725c39abcb2e680b1bd592663c83b672a4ed350a17f806d75618e \
+    --hash=sha256:cae27622c094558e519abf3242cf4272db961d12c5c9a9ffb7a1b44b2627d5c6 \
+    --hash=sha256:cfcec18f7da682c4e2d82112829ce906569cb8d69fa6c26f3a50dfbed5ceb682 \
+    --hash=sha256:d0834c84ae8750ae1c4cede59b0afd4d2f775be958e11b18a3eea24ed9d0d9f1 \
+    --hash=sha256:d3c75d57a00109255e60bc9c623b6ececaf7905eaab845c79f036670ed4750a2 \
+    --hash=sha256:da6ef4cb8d457aab0482b50120136ae94238aaa421863eaa7d599759742c72d6 \
+    --hash=sha256:e21e888a6b471b2bb1cdd4247e8d86632672232f29be583e7eafaa5f4634d34c \
+    --hash=sha256:e37aba1994d73b4944053ab65a15f313bd5c28c885dd7f0d494a11749d89db6e \
+    --hash=sha256:e6b6a11bf898cca3ce7bfaa17b646901107f3975677fbd5097f36e5eb5641983 \
+    --hash=sha256:eac1207936555aa691ce32df1432b478f2729d54e6d93a1f4db9215bcd8eb47d \
+    --hash=sha256:ebbf0d83ed5271991d666e54bb6c90ac2c55fb2ef3a88740c6af85dc85de2402 \
+    --hash=sha256:ecae626449d00db8c08f8f1fc00047a32d6d7eb5402b3976f5c3fda2b80a7a4f \
+    --hash=sha256:ed7c886a2fcbf14493ceaf9579394b33521730c161ebb8dad7db9c3e9fcab1a8 \
+    --hash=sha256:ee877b6d78f9dff1da94fef51ae8cf9cce0967e043fdcc864c40b85cf293c192 \
+    --hash=sha256:f0192e5f1cfc70e3cb35347135dd02e7497b3e7d83e378aa226d8b3e53a93f19 \
+    --hash=sha256:f3463a5f26be513a49e4d497debcf1b252a2db7b92c77d89621aa90b83d2dd38 \
+    --hash=sha256:f6222cafe00e072bb2b8f14142cd969637411fbc4dd3b1d73a90a3b817fa046f \
+    --hash=sha256:fadb07dbe36a541283ff454b1a268afd54b077d917043f2e1e5615372cb5f200 \
+    --hash=sha256:fe7ff456c22725c9d9017f7a2a7df2b51af6df77314176760b22e2d05278e181
+    # via transformers
+requests==2.34.2 \
+    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
+    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
+    # via
+    #   huggingface-hub
+    #   transformers
+ruff==0.15.21 \
+    --hash=sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075 \
+    --hash=sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be \
+    --hash=sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd \
+    --hash=sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd \
+    --hash=sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86 \
+    --hash=sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341 \
+    --hash=sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd \
+    --hash=sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67 \
+    --hash=sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41 \
+    --hash=sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d \
+    --hash=sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d \
+    --hash=sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8 \
+    --hash=sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233 \
+    --hash=sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8 \
+    --hash=sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500 \
+    --hash=sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3 \
+    --hash=sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646 \
+    --hash=sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f
+safetensors==0.8.0 \
+    --hash=sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358 \
+    --hash=sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f \
+    --hash=sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d \
+    --hash=sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d \
+    --hash=sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0 \
+    --hash=sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc \
+    --hash=sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235 \
+    --hash=sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98 \
+    --hash=sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4 \
+    --hash=sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846 \
+    --hash=sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca \
+    --hash=sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0 \
+    --hash=sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25 \
+    --hash=sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452 \
+    --hash=sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d \
+    --hash=sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78 \
+    --hash=sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774
+    # via
+    #   accelerate
+    #   peft
+    #   transformers
+setuptools==83.0.0 ; (python_full_version >= '3.12' and platform_machine != 'x86_64') or (python_full_version >= '3.12' and sys_platform != 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') \
+    --hash=sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef \
+    --hash=sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3
+    # via
+    #   onnxruntime-training
+    #   torch
+    #   triton
+sympy==1.14.0 \
+    --hash=sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517 \
+    --hash=sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5
+    # via
+    #   onnx-ir
+    #   onnxruntime-training
+    #   torch
+tokenizers==0.22.2 \
+    --hash=sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e \
+    --hash=sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001 \
+    --hash=sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7 \
+    --hash=sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd \
+    --hash=sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4 \
+    --hash=sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67 \
+    --hash=sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a \
+    --hash=sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5 \
+    --hash=sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917 \
+    --hash=sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c \
+    --hash=sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195 \
+    --hash=sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4 \
+    --hash=sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a \
+    --hash=sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc \
+    --hash=sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92 \
+    --hash=sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5 \
+    --hash=sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48 \
+    --hash=sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b \
+    --hash=sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c \
+    --hash=sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5
+    # via
+    #   mobiletransformers
+    #   transformers
+tomli==2.4.1 ; python_full_version < '3.11' \
+    --hash=sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe \
+    --hash=sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5 \
+    --hash=sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd \
+    --hash=sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54 \
+    --hash=sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c \
+    --hash=sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a \
+    --hash=sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd \
+    --hash=sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5 \
+    --hash=sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9 \
+    --hash=sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9 \
+    --hash=sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1 \
+    --hash=sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585 \
+    --hash=sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e \
+    --hash=sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f \
+    --hash=sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085 \
+    --hash=sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36 \
+    --hash=sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076 \
+    --hash=sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece \
+    --hash=sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a \
+    --hash=sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897 \
+    --hash=sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d \
+    --hash=sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917 \
+    --hash=sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a \
+    --hash=sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc \
+    --hash=sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f \
+    --hash=sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257 \
+    --hash=sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30 \
+    --hash=sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9 \
+    --hash=sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049
+    # via
+    #   mypy
+    #   pytest
+torch==2.7.1 \
+    --hash=sha256:03563603d931e70722dce0e11999d53aa80a375a3d78e6b39b9f6805ea0a8d28 \
+    --hash=sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1 \
+    --hash=sha256:0da4f4dba9f65d0d203794e619fe7ca3247a55ffdcbd17ae8fb83c8b2dc9b585 \
+    --hash=sha256:23660443e13995ee93e3d844786701ea4ca69f337027b05182f5ba053ce43b38 \
+    --hash=sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2 \
+    --hash=sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa \
+    --hash=sha256:30207f672328a42df4f2174b8f426f354b2baa0b7cca3a0adb3d6ab5daf00dc8 \
+    --hash=sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb \
+    --hash=sha256:79042feca1c634aaf6603fe6feea8c6b30dfa140a6bbc0b973e2260c7e79a22e \
+    --hash=sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52 \
+    --hash=sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162 \
+    --hash=sha256:988b0cbc4333618a1056d2ebad9eb10089637b659eb645434d0809d8d937b946 \
+    --hash=sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f \
+    --hash=sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730 \
+    --hash=sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc \
+    --hash=sha256:d632f5417b6980f61404a125b999ca6ebd0b8b4bbdbb5fbbba44374ab619a412 \
+    --hash=sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c \
+    --hash=sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b \
+    --hash=sha256:e08d7e6f21a617fe38eeb46dd2213ded43f27c072e9165dc27300c9ef9570934 \
+    --hash=sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d
+    # via
+    #   accelerate
+    #   optimum
+    #   peft
+tqdm==4.68.4 \
+    --hash=sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520 \
+    --hash=sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2
+    # via
+    #   huggingface-hub
+    #   peft
+    #   transformers
+transformers==4.57.6 \
+    --hash=sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550 \
+    --hash=sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3
+    # via
+    #   optimum
+    #   optimum-onnx
+    #   peft
+triton==3.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux' \
+    --hash=sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43 \
+    --hash=sha256:a3198adb9d78b77818a5388bff89fa72ff36f9da0bc689db2f0a651a67ce6a42 \
+    --hash=sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b \
+    --hash=sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e \
+    --hash=sha256:b89d846b5a4198317fec27a5d3a609ea96b6d557ff44b56c23176546023c4240
+    # via torch
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via
+    #   exceptiongroup
+    #   huggingface-hub
+    #   mypy
+    #   onnx
+    #   onnx-ir
+    #   onnxscript
+    #   pydantic
+    #   pydantic-core
+    #   torch
+    #   typing-inspection
+typing-inspection==0.4.2 \
+    --hash=sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7 \
+    --hash=sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464
+    # via pydantic
+urllib3==2.7.0 \
+    --hash=sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c \
+    --hash=sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897
+    # via requests
diff --git a/requirements/sbom-cyclonedx.json b/requirements/sbom-cyclonedx.json
new file mode 100644
index 0000000..0bfd035
--- /dev/null
+++ b/requirements/sbom-cyclonedx.json
@@ -0,0 +1,527 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "version": 1,
+  "serialNumber": "urn:uuid:a37a5f62-12df-483e-8cc4-43bc74ea43d0",
+  "metadata": {
+    "timestamp": "2026-08-17T11:29:23.325574262Z",
+    "tools": [
+      {
+        "vendor": "Astral Software Inc.",
+        "name": "uv",
+        "version": "0.11.28"
+      }
+    ],
+    "component": {
+      "type": "library",
+      "bom-ref": "mobiletransformers-1@0.2.0",
+      "name": "mobiletransformers",
+      "version": "0.2.0",
+      "properties": [
+        {
+          "name": "uv:package:is_project_root",
+          "value": "true"
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "bom-ref": "annotated-types-2@0.7.0",
+      "name": "annotated-types",
+      "version": "0.7.0",
+      "purl": "pkg:pypi/annotated-types@0.7.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "ast-serialize-3@0.6.0",
+      "name": "ast-serialize",
+      "version": "0.6.0",
+      "purl": "pkg:pypi/ast-serialize@0.6.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "certifi-4@2026.6.17",
+      "name": "certifi",
+      "version": "2026.6.17",
+      "purl": "pkg:pypi/certifi@2026.6.17"
+    },
+    {
+      "type": "library",
+      "bom-ref": "charset-normalizer-5@3.4.9",
+      "name": "charset-normalizer",
+      "version": "3.4.9",
+      "purl": "pkg:pypi/charset-normalizer@3.4.9"
+    },
+    {
+      "type": "library",
+      "bom-ref": "colorama-6@0.4.6",
+      "name": "colorama",
+      "version": "0.4.6",
+      "purl": "pkg:pypi/colorama@0.4.6",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "sys_platform == 'win32'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "exceptiongroup-7@1.3.1",
+      "name": "exceptiongroup",
+      "version": "1.3.1",
+      "purl": "pkg:pypi/exceptiongroup@1.3.1",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "python_full_version < '3.11'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "filelock-8@3.29.7",
+      "name": "filelock",
+      "version": "3.29.7",
+      "purl": "pkg:pypi/filelock@3.29.7"
+    },
+    {
+      "type": "library",
+      "bom-ref": "fsspec-9@2026.6.0",
+      "name": "fsspec",
+      "version": "2026.6.0",
+      "purl": "pkg:pypi/fsspec@2026.6.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "hf-xet-10@1.5.1",
+      "name": "hf-xet",
+      "version": "1.5.1",
+      "purl": "pkg:pypi/hf-xet@1.5.1",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "huggingface-hub-11@0.36.2",
+      "name": "huggingface-hub",
+      "version": "0.36.2",
+      "purl": "pkg:pypi/huggingface-hub@0.36.2"
+    },
+    {
+      "type": "library",
+      "bom-ref": "idna-12@3.18",
+      "name": "idna",
+      "version": "3.18",
+      "purl": "pkg:pypi/idna@3.18"
+    },
+    {
+      "type": "library",
+      "bom-ref": "iniconfig-13@2.3.0",
+      "name": "iniconfig",
+      "version": "2.3.0",
+      "purl": "pkg:pypi/iniconfig@2.3.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "librt-14@0.13.0",
+      "name": "librt",
+      "version": "0.13.0",
+      "purl": "pkg:pypi/librt@0.13.0",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "platform_python_implementation != 'PyPy'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "ml-dtypes-15@0.5.4",
+      "name": "ml-dtypes",
+      "version": "0.5.4",
+      "purl": "pkg:pypi/ml-dtypes@0.5.4"
+    },
+    {
+      "type": "library",
+      "bom-ref": "mypy-16@2.3.0",
+      "name": "mypy",
+      "version": "2.3.0",
+      "purl": "pkg:pypi/mypy@2.3.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "mypy-extensions-17@1.1.0",
+      "name": "mypy-extensions",
+      "version": "1.1.0",
+      "purl": "pkg:pypi/mypy-extensions@1.1.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "numpy-18@2.2.6",
+      "name": "numpy",
+      "version": "2.2.6",
+      "purl": "pkg:pypi/numpy@2.2.6",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "python_full_version < '3.11'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "numpy-19@2.4.6",
+      "name": "numpy",
+      "version": "2.4.6",
+      "purl": "pkg:pypi/numpy@2.4.6",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "python_full_version == '3.11.*'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "numpy-20@2.5.1",
+      "name": "numpy",
+      "version": "2.5.1",
+      "purl": "pkg:pypi/numpy@2.5.1",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "python_full_version >= '3.12'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "onnx-21@1.22.0",
+      "name": "onnx",
+      "version": "1.22.0",
+      "purl": "pkg:pypi/onnx@1.22.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "packaging-22@25.0",
+      "name": "packaging",
+      "version": "25.0",
+      "purl": "pkg:pypi/packaging@25.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pathspec-23@1.1.1",
+      "name": "pathspec",
+      "version": "1.1.1",
+      "purl": "pkg:pypi/pathspec@1.1.1"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pluggy-24@1.6.0",
+      "name": "pluggy",
+      "version": "1.6.0",
+      "purl": "pkg:pypi/pluggy@1.6.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "protobuf-25@7.35.1",
+      "name": "protobuf",
+      "version": "7.35.1",
+      "purl": "pkg:pypi/protobuf@7.35.1"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pydantic-26@2.13.4",
+      "name": "pydantic",
+      "version": "2.13.4",
+      "purl": "pkg:pypi/pydantic@2.13.4"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pydantic-core-27@2.46.4",
+      "name": "pydantic-core",
+      "version": "2.46.4",
+      "purl": "pkg:pypi/pydantic-core@2.46.4"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pygments-28@2.20.0",
+      "name": "pygments",
+      "version": "2.20.0",
+      "purl": "pkg:pypi/pygments@2.20.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pytest-29@9.1.1",
+      "name": "pytest",
+      "version": "9.1.1",
+      "purl": "pkg:pypi/pytest@9.1.1"
+    },
+    {
+      "type": "library",
+      "bom-ref": "python-dotenv-30@1.2.2",
+      "name": "python-dotenv",
+      "version": "1.2.2",
+      "purl": "pkg:pypi/python-dotenv@1.2.2"
+    },
+    {
+      "type": "library",
+      "bom-ref": "pyyaml-31@6.0.3",
+      "name": "pyyaml",
+      "version": "6.0.3",
+      "purl": "pkg:pypi/pyyaml@6.0.3"
+    },
+    {
+      "type": "library",
+      "bom-ref": "requests-32@2.34.2",
+      "name": "requests",
+      "version": "2.34.2",
+      "purl": "pkg:pypi/requests@2.34.2"
+    },
+    {
+      "type": "library",
+      "bom-ref": "ruff-33@0.15.21",
+      "name": "ruff",
+      "version": "0.15.21",
+      "purl": "pkg:pypi/ruff@0.15.21"
+    },
+    {
+      "type": "library",
+      "bom-ref": "tokenizers-34@0.22.2",
+      "name": "tokenizers",
+      "version": "0.22.2",
+      "purl": "pkg:pypi/tokenizers@0.22.2"
+    },
+    {
+      "type": "library",
+      "bom-ref": "tomli-35@2.4.1",
+      "name": "tomli",
+      "version": "2.4.1",
+      "purl": "pkg:pypi/tomli@2.4.1",
+      "properties": [
+        {
+          "name": "uv:package:marker",
+          "value": "python_full_version < '3.11'"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "tqdm-36@4.68.4",
+      "name": "tqdm",
+      "version": "4.68.4",
+      "purl": "pkg:pypi/tqdm@4.68.4"
+    },
+    {
+      "type": "library",
+      "bom-ref": "typing-extensions-37@4.16.0",
+      "name": "typing-extensions",
+      "version": "4.16.0",
+      "purl": "pkg:pypi/typing-extensions@4.16.0"
+    },
+    {
+      "type": "library",
+      "bom-ref": "typing-inspection-38@0.4.2",
+      "name": "typing-inspection",
+      "version": "0.4.2",
+      "purl": "pkg:pypi/typing-inspection@0.4.2"
+    },
+    {
+      "type": "library",
+      "bom-ref": "urllib3-39@2.7.0",
+      "name": "urllib3",
+      "version": "2.7.0",
+      "purl": "pkg:pypi/urllib3@2.7.0"
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "annotated-types-2@0.7.0"
+    },
+    {
+      "ref": "ast-serialize-3@0.6.0"
+    },
+    {
+      "ref": "certifi-4@2026.6.17"
+    },
+    {
+      "ref": "charset-normalizer-5@3.4.9"
+    },
+    {
+      "ref": "colorama-6@0.4.6"
+    },
+    {
+      "ref": "exceptiongroup-7@1.3.1",
+      "dependsOn": [
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "filelock-8@3.29.7"
+    },
+    {
+      "ref": "fsspec-9@2026.6.0"
+    },
+    {
+      "ref": "hf-xet-10@1.5.1"
+    },
+    {
+      "ref": "huggingface-hub-11@0.36.2",
+      "dependsOn": [
+        "filelock-8@3.29.7",
+        "fsspec-9@2026.6.0",
+        "hf-xet-10@1.5.1",
+        "packaging-22@25.0",
+        "pyyaml-31@6.0.3",
+        "requests-32@2.34.2",
+        "tqdm-36@4.68.4",
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "idna-12@3.18"
+    },
+    {
+      "ref": "iniconfig-13@2.3.0"
+    },
+    {
+      "ref": "librt-14@0.13.0"
+    },
+    {
+      "ref": "ml-dtypes-15@0.5.4",
+      "dependsOn": [
+        "numpy-18@2.2.6",
+        "numpy-19@2.4.6",
+        "numpy-20@2.5.1"
+      ]
+    },
+    {
+      "ref": "mypy-16@2.3.0",
+      "dependsOn": [
+        "ast-serialize-3@0.6.0",
+        "librt-14@0.13.0",
+        "mypy-extensions-17@1.1.0",
+        "pathspec-23@1.1.1",
+        "tomli-35@2.4.1",
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "mypy-extensions-17@1.1.0"
+    },
+    {
+      "ref": "numpy-18@2.2.6"
+    },
+    {
+      "ref": "numpy-19@2.4.6"
+    },
+    {
+      "ref": "numpy-20@2.5.1"
+    },
+    {
+      "ref": "onnx-21@1.22.0",
+      "dependsOn": [
+        "ml-dtypes-15@0.5.4",
+        "numpy-18@2.2.6",
+        "numpy-19@2.4.6",
+        "numpy-20@2.5.1",
+        "protobuf-25@7.35.1",
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "packaging-22@25.0"
+    },
+    {
+      "ref": "pathspec-23@1.1.1"
+    },
+    {
+      "ref": "pluggy-24@1.6.0"
+    },
+    {
+      "ref": "protobuf-25@7.35.1"
+    },
+    {
+      "ref": "pydantic-26@2.13.4",
+      "dependsOn": [
+        "annotated-types-2@0.7.0",
+        "pydantic-core-27@2.46.4",
+        "typing-extensions-37@4.16.0",
+        "typing-inspection-38@0.4.2"
+      ]
+    },
+    {
+      "ref": "pydantic-core-27@2.46.4",
+      "dependsOn": [
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "pygments-28@2.20.0"
+    },
+    {
+      "ref": "pytest-29@9.1.1",
+      "dependsOn": [
+        "colorama-6@0.4.6",
+        "exceptiongroup-7@1.3.1",
+        "iniconfig-13@2.3.0",
+        "packaging-22@25.0",
+        "pluggy-24@1.6.0",
+        "pygments-28@2.20.0",
+        "tomli-35@2.4.1"
+      ]
+    },
+    {
+      "ref": "python-dotenv-30@1.2.2"
+    },
+    {
+      "ref": "pyyaml-31@6.0.3"
+    },
+    {
+      "ref": "requests-32@2.34.2",
+      "dependsOn": [
+        "certifi-4@2026.6.17",
+        "charset-normalizer-5@3.4.9",
+        "idna-12@3.18",
+        "urllib3-39@2.7.0"
+      ]
+    },
+    {
+      "ref": "ruff-33@0.15.21"
+    },
+    {
+      "ref": "tokenizers-34@0.22.2",
+      "dependsOn": [
+        "huggingface-hub-11@0.36.2"
+      ]
+    },
+    {
+      "ref": "tomli-35@2.4.1"
+    },
+    {
+      "ref": "tqdm-36@4.68.4",
+      "dependsOn": [
+        "colorama-6@0.4.6"
+      ]
+    },
+    {
+      "ref": "typing-extensions-37@4.16.0"
+    },
+    {
+      "ref": "typing-inspection-38@0.4.2",
+      "dependsOn": [
+        "typing-extensions-37@4.16.0"
+      ]
+    },
+    {
+      "ref": "urllib3-39@2.7.0"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/research/README.md b/research/README.md
new file mode 100644
index 0000000..49c3488
--- /dev/null
+++ b/research/README.md
@@ -0,0 +1,31 @@
+# research/
+
+**Not part of the shipped framework.** Nothing here is installed by the wheel, imported by
+`src/mobiletransformers/`, or run by any gate. It is the experimental and measurement work the
+framework came out of, kept because the results in the thesis and in
+[`docs/mobile_evaluation.md`](../docs/mobile_evaluation.md) were produced by these scripts and would
+otherwise be unreproducible.
+
+Expect rougher edges than the rest of the repository: these are experiment scripts, not a library.
+Several assume paths, datasets or credentials that are not in this repo, and they are excluded from
+`ruff`/`mypy` for that reason. **If you are here to use MobileTransformers, you want
+[`docs/`](../docs/) instead.**
+
+| directory | what it is |
+| --- | --- |
+| `evaluation/` | On-device and host-side benchmarking: the harnesses behind the measured numbers, plus mobile profiling captures. Has its own [README](evaluation/README.md). |
+| `plots/` | The figure generators for those results — ablations, size comparisons, per-task radar charts. |
+| `genai/` | A desktop reference implementation of the GenAI generation loop. The Android engine is a port of it, so this is the version you can step through in a debugger. Has its own [README](genai/README.md). |
+| `onnx_experiments/` | Exploratory ONNX graph work from before the export pipeline existed: quantization at several widths, external-data handling, graph rewriting, dtype casting. Superseded by `src/mobiletransformers/export/`, kept as the record of what was tried. |
+| `pytorch_experiments/` | Host-side PEFT experiments that preceded MARS — low-rank matrix behaviour, dynamic training. `cca_core.py` is a third-party CCA/SVCCA implementation used for representation-similarity analysis. |
+| `tflite/` | An abandoned TensorFlow Lite export path, evaluated and not taken. Kept so the decision is legible: this project is ONNX Runtime end to end, and this is why it is not TFLite. |
+| `ablation_analysis.py`, `offline_train_eval.py`, `trainer_callbacks.py`, `utils.py` | Shared helpers for the above. |
+
+## Running any of it
+
+These are not covered by the project's dependency profiles and may need packages the framework does
+not depend on (`tensorflow`, plotting libraries, evaluation harnesses). Install what a given script
+imports, in a throwaway environment.
+
+Credentials, where a script needs them, are read from the environment — never written into the file.
+See [`.env.example`](../.env.example).
diff --git a/research/evaluation/README.md b/research/evaluation/README.md
new file mode 100644
index 0000000..0292774
--- /dev/null
+++ b/research/evaluation/README.md
@@ -0,0 +1,17 @@
+# Experiment scripts (moved out of `evaluation/` by Migration Map S8)
+
+These are **not** library code and **not** tests, despite `scripts/` having been called `test/`.
+
+Each file has zero classes and zero functions: it does its work in top-level statements, so importing
+one *runs an experiment*. They also hardcode paths like
+`experiment_results/TinyLlama_v1.1-lora_xs/...` that exist only on the machine that produced them.
+
+They stay in the repo because they document how published numbers were produced, and they stay **out**
+of `src/` because an installable wheel must not contain modules that execute a benchmark on import.
+This mirrors S5's treatment of `artifact/tflite_builder.py`.
+
+- `benchmark/` — deepeval harnesses (ARC, BoolQ, HellaSwag, LogiQA, WinoGrande).
+- `scripts/` — one-off generation/visualisation checks.
+
+Running them needs the `eval` extra (`uv sync --extra eval`) plus whatever the individual script
+hardcodes.
diff --git a/evaluation/benchmark/arc_eval.py b/research/evaluation/benchmark/arc_eval.py
similarity index 91%
rename from evaluation/benchmark/arc_eval.py
rename to research/evaluation/benchmark/arc_eval.py
index 15a5e1d..022daf8 100644
--- a/evaluation/benchmark/arc_eval.py
+++ b/research/evaluation/benchmark/arc_eval.py
@@ -5,7 +5,7 @@
 
 from deepeval.benchmarks import ARC
 from deepeval.benchmarks.modes import ARCMode
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 
 MODEL_PATH = "experiment_results/TinyLlama_v1.1-lora_xs/TinyLlama_v1.1-lora_xs-arc_c-r64-a2"
 
diff --git a/evaluation/benchmark/boolq_eval.py b/research/evaluation/benchmark/boolq_eval.py
similarity index 90%
rename from evaluation/benchmark/boolq_eval.py
rename to research/evaluation/benchmark/boolq_eval.py
index 6aa21ee..cfb5ed4 100644
--- a/evaluation/benchmark/boolq_eval.py
+++ b/research/evaluation/benchmark/boolq_eval.py
@@ -5,7 +5,7 @@
 os.environ["DEEPEVAL_TELEMETRY_OPT_OUT"] = "YES"
 
 from deepeval.benchmarks import BoolQ
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 
 MODEL_PATH = "experiment_results/TinyLlama_v1.1-lora-boolq-r2-a2"
 
diff --git a/evaluation/benchmark/hellaswag_eval.py b/research/evaluation/benchmark/hellaswag_eval.py
similarity index 91%
rename from evaluation/benchmark/hellaswag_eval.py
rename to research/evaluation/benchmark/hellaswag_eval.py
index 0a8e589..2286ca8 100644
--- a/evaluation/benchmark/hellaswag_eval.py
+++ b/research/evaluation/benchmark/hellaswag_eval.py
@@ -6,7 +6,7 @@
 
 from deepeval.benchmarks import HellaSwag
 from deepeval.benchmarks.tasks import HellaSwagTask
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 
 # results/joint-mars-8-4-12-a-2-shuffled
 MODEL_PATH = "results/mars-new-8-hellaswag"
diff --git a/evaluation/benchmark/logiqa_eval.py b/research/evaluation/benchmark/logiqa_eval.py
similarity index 90%
rename from evaluation/benchmark/logiqa_eval.py
rename to research/evaluation/benchmark/logiqa_eval.py
index 1eff0cc..e983388 100644
--- a/evaluation/benchmark/logiqa_eval.py
+++ b/research/evaluation/benchmark/logiqa_eval.py
@@ -5,7 +5,7 @@
 os.environ["DEEPEVAL_TELEMETRY_OPT_OUT"] = "YES"
 
 from deepeval.benchmarks import LogiQA
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 
 MODEL_PATH = "experiment_results/TinyLlama_v1.1-abl_C-logiqa-r8-a2"
 
diff --git a/evaluation/benchmark/winogrande_eval.py b/research/evaluation/benchmark/winogrande_eval.py
similarity index 90%
rename from evaluation/benchmark/winogrande_eval.py
rename to research/evaluation/benchmark/winogrande_eval.py
index 51ffa69..a502bae 100644
--- a/evaluation/benchmark/winogrande_eval.py
+++ b/research/evaluation/benchmark/winogrande_eval.py
@@ -5,7 +5,7 @@
 os.environ["DEEPEVAL_TELEMETRY_OPT_OUT"] = "YES"
 
 from deepeval.benchmarks import Winogrande
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 
 MODEL_PATH = "experiment_results/TinyLlama_v1.1-abl_A-winogrande-r2-a2"
 
diff --git a/evaluation/mobile/cpu_usage.sql b/research/evaluation/mobile_profiling/cpu_usage.sql
similarity index 85%
rename from evaluation/mobile/cpu_usage.sql
rename to research/evaluation/mobile_profiling/cpu_usage.sql
index f0cf6b3..63943bb 100644
--- a/evaluation/mobile/cpu_usage.sql
+++ b/research/evaluation/mobile_profiling/cpu_usage.sql
@@ -8,6 +8,6 @@ SELECT
 FROM sched_slice
 LEFT JOIN thread USING (utid)  
 LEFT JOIN process USING (upid)
-WHERE process.name = 'com.martinkorelic.ortmobile'
+WHERE process.name = 'com.martinkorelic.mobiletransformers.app'
 GROUP BY timestamp_sec, cpu
 ORDER BY timestamp_sec, cpu;
\ No newline at end of file
diff --git a/evaluation/mobile/mem_usage.sql b/research/evaluation/mobile_profiling/mem_usage.sql
similarity index 85%
rename from evaluation/mobile/mem_usage.sql
rename to research/evaluation/mobile_profiling/mem_usage.sql
index 33b81b3..33f9204 100644
--- a/evaluation/mobile/mem_usage.sql
+++ b/research/evaluation/mobile_profiling/mem_usage.sql
@@ -6,6 +6,6 @@ SELECT
 FROM counter as c
 LEFT JOIN process_counter_track as t ON c.track_id = t.id
 LEFT JOIN process as p USING (upid)
-WHERE p.name = 'com.martinkorelic.ortmobile'
+WHERE p.name = 'com.martinkorelic.mobiletransformers.app'
 AND t.name = 'mem.rss'
 ORDER BY timestamp_sec;
\ No newline at end of file
diff --git a/evaluation/mobile/temp_usage.sql b/research/evaluation/mobile_profiling/temp_usage.sql
similarity index 91%
rename from evaluation/mobile/temp_usage.sql
rename to research/evaluation/mobile_profiling/temp_usage.sql
index 83aba00..954ed4d 100644
--- a/evaluation/mobile/temp_usage.sql
+++ b/research/evaluation/mobile_profiling/temp_usage.sql
@@ -5,7 +5,7 @@ WITH process_activity AS (
  FROM sched_slice
  LEFT JOIN thread USING (utid)  
  LEFT JOIN process USING (upid)
- WHERE process.name = 'com.martinkorelic.ortmobile'
+ WHERE process.name = 'com.martinkorelic.mobiletransformers.app'
 )
 SELECT 
  CAST(c.ts/1e9 AS INT) as timestamp_sec,
diff --git a/evaluation/test/test_eval_onnx.py b/research/evaluation/scripts/test_eval_onnx.py
similarity index 90%
rename from evaluation/test/test_eval_onnx.py
rename to research/evaluation/scripts/test_eval_onnx.py
index fafdf38..e6d618d 100644
--- a/evaluation/test/test_eval_onnx.py
+++ b/research/evaluation/scripts/test_eval_onnx.py
@@ -1,6 +1,6 @@
 import os
 
-from evaluation.eval_adapter_onnx_model import CustomPeftONNXModel
+from mobiletransformers.evaluation.eval_adapter_onnx_model import CustomPeftONNXModel
 
 from deepeval.benchmarks import ARC
 from deepeval.benchmarks.modes import ARCMode
diff --git a/evaluation/test/test_gen.py b/research/evaluation/scripts/test_gen.py
similarity index 90%
rename from evaluation/test/test_gen.py
rename to research/evaluation/scripts/test_gen.py
index 2619a0d..0e67aef 100644
--- a/evaluation/test/test_gen.py
+++ b/research/evaluation/scripts/test_gen.py
@@ -3,7 +3,7 @@
 SLM_MODEL_DIR = "build/inference-arc-e"
 MERGED_WEIGHTS_DIR = "build/train-arc-e/merged"
 
-from inference.validator import ORTransformerGenerator
+from mobiletransformers.artifacts.validation import MobileTransformerGenerator
 from deepeval.benchmarks.arc.template import ARCTemplate
 
 test_arc = {
@@ -24,7 +24,7 @@
 q = ARCTemplate.format_question(test_arc, include_answer=False) + "\n\n "
 
 # Initialize models
-slm_generator = ORTransformerGenerator(
+slm_generator = MobileTransformerGenerator(
     model_id=SLM_MODEL_ID,
     model_name=SLM_MODEL_NAME, 
     model_dir=SLM_MODEL_DIR,
diff --git a/evaluation/test/test_gen_viz.py b/research/evaluation/scripts/test_gen_viz.py
similarity index 93%
rename from evaluation/test/test_gen_viz.py
rename to research/evaluation/scripts/test_gen_viz.py
index 98826e6..f3f6f98 100644
--- a/evaluation/test/test_gen_viz.py
+++ b/research/evaluation/scripts/test_gen_viz.py
@@ -1,4 +1,4 @@
-from evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
 from deepeval.benchmarks.arc.template import ARCTemplate
 
 ADAPTER_PATH = "experiment_results/TinyLlama_v1.1-abl_G-loraq8/TinyLlama_v1.1-abl_G-arc_c-r32-a2"
diff --git a/research/genai/README.md b/research/genai/README.md
new file mode 100644
index 0000000..755aceb
--- /dev/null
+++ b/research/genai/README.md
@@ -0,0 +1,12 @@
+# GenAI desktop reference (moved out of `inference/` by Migration Map S9)
+
+`generator_genai.py` is a **desktop prototype**, not library code: it has no importers anywhere in the
+repo, hardcodes a model path, and its two functions are exploratory smokes for the onnxruntime-genai
+Python loop.
+
+It is kept as the **desktop reference for the GenAI loop**: the Android engine in
+`ORTGeneratorGenAI.kt` is a port of it, so when the two disagree this is the version that can be
+stepped through in a debugger. It stays **out** of `src/` for the same reason the benchmark scripts
+do: a wheel should not ship modules that run an experiment on import.
+
+The shipping GenAI path is the Android engine (`ORTGeneratorGenAI` + `genai_runtime.cpp`), not this.
diff --git a/inference/generator_genai.py b/research/genai/generator_genai.py
similarity index 100%
rename from inference/generator_genai.py
rename to research/genai/generator_genai.py
diff --git a/research/offline_train_eval.py b/research/offline_train_eval.py
index 5239463..eb2286b 100644
--- a/research/offline_train_eval.py
+++ b/research/offline_train_eval.py
@@ -26,19 +26,25 @@
 from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
 from peft.tuners.vblora import VBLoRAConfig
 from peft.tuners.loha import LoHaConfig
-from evaluation.eval_adapter_models import CustomPeftModel
-from peft_models.ablation.config import AblationConfig
-from peft_models.ablation.model import AblationModel
-from peft_models.mars.config import MarsConfig
-from peft_models.mars.model import MarsModel
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.peft.ablation.config import AblationConfig
+from mobiletransformers.peft.ablation.model import AblationModel
+from mobiletransformers.peft.mars.config import MarsConfig
+from mobiletransformers.peft.mars.model import MarsModel
 from datasets import Dataset
 from research.trainer_callbacks import PEFTUsageCallback
-from tools.utils import preload_dataset
+from mobiletransformers.training.data import preload_dataset
 
 from peft.peft_model import PEFT_TYPE_TO_MODEL_MAPPING
 from peft import PeftType
-from config import TASK_EPOCHS, BATCH_SIZE, PER_DEVICE_BATCH_SIZE, GRADIENT_ACCUMULATION, EXPERIMENT_RANKS
-from peft_models.lora_xs.initialization_utils import find_and_initialize
+from mobiletransformers.config.constants import (
+    TASK_EPOCHS,
+    BATCH_SIZE,
+    PER_DEVICE_BATCH_SIZE,
+    GRADIENT_ACCUMULATION,
+    EXPERIMENT_RANKS,
+)
+from mobiletransformers.peft.lora_xs.initialization_utils import find_and_initialize
 
 def add_peft_type(name, value):
     """Dynamically add a new value to the PeftType enum."""
@@ -52,7 +58,7 @@ def add_peft_type(name, value):
 PEFT_TYPE_TO_MODEL_MAPPING[PeftType("MARS")] = MarsModel
 PEFT_TYPE_TO_MODEL_MAPPING[PeftType("ABLATION")] = AblationModel
 
-from trainer.utils import (
+from mobiletransformers.training.preprocessing import (
     process_sample_hellaswag_deepeval,
     process_sample_boolq_deepeval,
     process_sample_arc_deepeval,
@@ -72,40 +78,13 @@ class SLModel(Enum):
     QWEN = "Qwen/Qwen2.5-1.5B",
     GEMMA = "google/gemma-2-2b"
  
-class PEFTBenchmarkDataset(Enum):
-    """Enum for supported datasets with their configurations."""
-
-    ### Easy tasks
-    BOOLQ = "boolq"
-    ARC_E = "arc_e"
-    LOGIQA = "logiqa"
-    WINOGRANDE = "winogrande"
-
-    ### Complex tasks
-    HELLASWAG = "hellaswag"
-    ARC_C = "arc_c"
-
-    ### Mobile tasks
-    MINI_PERSONALQA = "mini_personalqa"
-    MINI_RECOMMENDATION = "mini_recommendation"
-
-DATASET_MAPPING = {
-
-    ### Easy tasks
-    PEFTBenchmarkDataset.BOOLQ.value : ("google/boolq", "boolq_train_deepeval"),
-    PEFTBenchmarkDataset.WINOGRANDE.value: ("allenai/winogrande", "winogrande_train_deepeval", "winogrande_l"),
-    PEFTBenchmarkDataset.ARC_E.value: ("allenai/ai2_arc", "arc_train_deepeval", "ARC-Easy"),
-    PEFTBenchmarkDataset.LOGIQA.value: ("data/logiqa_train", "logiqa_train_deepeval"),
-
-    ### Complex tasks
-    PEFTBenchmarkDataset.HELLASWAG.value : ("Rowan/hellaswag", "hellaswag_train_deepeval"),
-    PEFTBenchmarkDataset.ARC_C.value : ("allenai/ai2_arc", "arc_train_deepeval", "ARC-Challenge"),
-
-    ### Mobile tasks
-    PEFTBenchmarkDataset.MINI_PERSONALQA.value : ("data/MiniPersonalQA_train", "mini_personalqa"),
-    PEFTBenchmarkDataset.MINI_RECOMMENDATION.value : ("data/MiniRecommendation_train", "mini_recommendation"),
-
-}
+# Moved to mobiletransformers.training.benchmark_datasets (S6b): training/validators.py is a
+# PACKAGED module and cannot import research/ from an installed wheel. Re-exported here so this
+# script and its readers keep working unchanged.
+from mobiletransformers.training.benchmark_datasets import (  # noqa: E402,F401
+    DATASET_MAPPING,
+    PEFTBenchmarkDataset,
+)
 
 class PEFTMethod(Enum):
     """Enum for supported PEFT methods."""
diff --git a/research/onnx_experiments/rewriter_2.py b/research/onnx_experiments/rewriter_2.py
deleted file mode 100644
index 1fca0de..0000000
--- a/research/onnx_experiments/rewriter_2.py
+++ /dev/null
@@ -1,208 +0,0 @@
-import onnx
-import gc
-import os
-import onnx
-from onnx import numpy_helper
-import numpy as np
-
-def convert_dq_q4_initializers_to_inputs(input_model_path, output_model_path):
-    """
-    Load an ONNX model, convert all initializers with '.weight_DQ_Q4' in their names
-    to model inputs, and save the modified model.
-    
-    Args:
-        input_model_path (str): Path to the input ONNX model
-        output_model_path (str): Path where the modified model will be saved
-        
-    Returns:
-        int: Number of initializers converted to inputs
-    """
-    print(f"Loading ONNX model from: {input_model_path}")
-    
-    # Load the ONNX model
-    model = onnx.load(input_model_path)
-    graph = model.graph
-    
-    # Find initializers to convert
-    initializers_to_convert = []
-    converted_names = []
-    
-    for param in graph.initializer:
-        if ".weight_DQ_Q4" in param.name:
-            initializers_to_convert.append(param)
-            converted_names.append(param.name)
-            print(f"Marking initializer for conversion: {param.name}")
-    
-    print(f"Found {len(initializers_to_convert)} initializers to convert")
-    
-    # Convert initializers to inputs
-    for param in initializers_to_convert:
-        print(f"Converting initializer: {param.name}")
-        
-        try:
-            # Create a ValueInfoProto for the input
-            input_info = onnx.helper.make_tensor_value_info(
-                param.name,
-                param.data_type,
-                param.dims
-            )
-            
-            # Add to graph inputs
-            graph.input.append(input_info)
-            print(f"  Added input: {param.name} with shape {param.dims}")
-            
-        except Exception as e:
-            print(f"  ✗ Error creating input for {param.name}: {e}")
-            continue
-    
-    # Remove converted initializers
-    for param in initializers_to_convert:
-        try:
-            graph.initializer.remove(param)
-            print(f"  Removed initializer: {param.name}")
-        except Exception as e:
-            print(f"  ✗ Error removing initializer {param.name}: {e}")
-    
-    # Save the modified model
-    print(f"Saving modified model to: {output_model_path}")
-    try:
-        onnx.save(model, output_model_path, save_as_external_data=True)
-        print("✓ Model saved successfully")
-    except Exception as e:
-        print(f"✗ Error saving model: {e}")
-        return 0
-    
-    # Verify the model is still valid
-    try:
-        # Load and check the saved model
-        onnx.checker.check_model(output_model_path)
-        print("✓ Model validation passed after converting initializers to inputs")
-        
-    except Exception as e:
-        print(f"✗ Warning: Model validation failed: {e}")
-        print("This might indicate the model was corrupted during conversion")
-    
-    # Clean up
-    del model
-    
-    print(f"\n🎉 Conversion complete!")
-    print(f"   Successfully converted {len(initializers_to_convert)} initializers to inputs")
-    print("   Converted initializers:")
-    for name in converted_names:
-        print(f"     - {name}")
-    
-    return len(initializers_to_convert)
-
-
-
-def inspect_initializer_weights(model_path, weight_name):
-    """
-    Load an ONNX model and inspect a specific initializer weight.
-    
-    Args:
-        model_path (str): Path to the ONNX model
-        weight_name (str): Name of the initializer to inspect
-        
-    Returns:
-        numpy.ndarray: The weight as a numpy array
-    """
-    print(f"Loading ONNX model from: {model_path}")
-    
-    # Load the ONNX model
-    model = onnx.load(model_path)
-    graph = model.graph
-    
-    # Find the specific initializer
-    target_initializer = None
-    
-    print(f"Searching for initializer: {weight_name}")
-    
-    for init in graph.initializer:
-        if init.name == weight_name:
-            target_initializer = init
-            print(f"✓ Found initializer: {init.name}")
-            break
-    
-    if target_initializer is None:
-        print(f"✗ Initializer '{weight_name}' not found in model")
-        print("Available initializers with similar names:")
-        for init in graph.initializer:
-            if "weight_DQ_Q4" in init.name:
-                print(f"  - {init.name}")
-        return None
-    
-    # Convert to numpy array
-    print(f"Converting initializer to numpy array...")
-    try:
-        weight_array = numpy_helper.to_array(target_initializer)
-        
-        
-        # Inspect the numpy array
-        print(f"\n📊 Numpy Array Inspection:")
-        print(f"   Shape: {weight_array.shape}")
-        print(f"   Data type: {weight_array.dtype}")
-        print(f"   Size: {weight_array.size} elements")
-        print(f"   Memory size: {weight_array.nbytes} bytes")
-        
-        # Check value ranges
-        print(f"\n📈 Value Statistics:")
-        print(f"   Min value: {weight_array.min()}")
-        print(f"   Max value: {weight_array.max()}")
-        print(f"   Mean value: {weight_array.mean():.4f}")
-        print(f"   Unique values: {len(np.unique(weight_array))}")
-        
-        # Show first few values
-        print(f"\n🔍 First 10 values:")
-        print(f"   {weight_array.flatten()[:10]}")
-        
-        # If it's int4 packed, show how to unpack
-        if weight_array.dtype == np.uint8:
-            print(f"\n🔧 Int4 Unpacking Analysis:")
-            print(f"   If this is packed int4 (Int4x2), each byte contains 2 values")
-            print(f"   Logical shape would be: {weight_array.shape[:-1] + (weight_array.shape[-1] * 2,)}")
-            
-            # Show how to unpack first few bytes
-            first_bytes = weight_array.flatten()[:5]
-            print(f"   First 5 bytes: {first_bytes}")
-            print(f"   Unpacked int4 values:")
-            for i, byte_val in enumerate(first_bytes):
-                low_4bit = byte_val & 0xF  # Lower 4 bits
-                high_4bit = (byte_val >> 4) & 0xF  # Upper 4 bits
-                print(f"     Byte {i}: {byte_val} -> [{low_4bit}, {high_4bit}]")
-        
-        return weight_array
-        
-    except Exception as e:
-        print(f"✗ Error converting to numpy array: {e}")
-        return None
-
-# Example usage:
-# Replace 'your_model.onnx' with your actual model path
-model_path = "build/train_models/quant_model.onnx"  # Change this to your model path
-weight_name = "backbone.model.layers.0.self_attn.v_proj.base_layer.weight_DQ_Q4"
-
-# Inspect the weight
-weight_array = inspect_initializer_weights(model_path, weight_name)
-
-if weight_array is not None:
-    print(f"\n✅ Successfully loaded weight array!")
-    print(f"Use this array for your inputs with shape: {weight_array.shape}")
-    print(f"Data type: {weight_array.dtype}")
-else:
-    print(f"\n❌ Failed to load weight array")
-
-
-
-
-# Example usage
-#if __name__ == "__main__":
-#    # Example usage
-#    input_path = "build/train_models/quant_model.onnx"
-#    output_path = "model_cleaned.onnx"
-#    
-#    if os.path.exists(input_path):
-#        converted_count = convert_dq_q4_initializers_to_inputs(input_path, output_path)
-#        print(f"\nDone! Converted {converted_count} initializers to inputs.")
-#    else:
-#        print(f"Input model file not found: {input_path}")
-#        print("Please update the input_path variable with the correct path to your ONNX model.")
\ No newline at end of file
diff --git a/research/pytorch_experiments/dynamic_model_training.py b/research/pytorch_experiments/dynamic_model_training.py
index 96f7c6a..233e657 100644
--- a/research/pytorch_experiments/dynamic_model_training.py
+++ b/research/pytorch_experiments/dynamic_model_training.py
@@ -4,7 +4,7 @@
 
 import torch
 
-from peft_models.mars.config import MarsConfig
+from mobiletransformers.peft.mars.config import MarsConfig
 from research.pytorch_experiments.model_training import count_trainable_parameters, create_peft_model, get_training_args, list_trainable_layers, load_peft_model, set_manual_seed
 from peft import PeftModel, LoraConfig, get_peft_model
 from safetensors.torch import load_file, save_file
diff --git a/artifact/tflite_builder.py b/research/tflite/tflite_builder.py
similarity index 98%
rename from artifact/tflite_builder.py
rename to research/tflite/tflite_builder.py
index b3b5667..e1a2835 100644
--- a/artifact/tflite_builder.py
+++ b/research/tflite/tflite_builder.py
@@ -16,9 +16,11 @@
 
 from transformers import AutoModelForCausalLM, AutoTokenizer, AutoProcessor
 
-kaggle_username = "TODO"
-kaggle_key = "TODO"
-hf_token = "TODO"
+# Read from the environment, never written here. A credential-shaped placeholder in a tracked
+# file is an invitation to paste a real one into it and commit it by accident.
+kaggle_username = os.environ.get("KAGGLE_USERNAME", "")
+kaggle_key = os.environ.get("KAGGLE_KEY", "")
+hf_token = os.environ.get("HF_TOKEN", "")
 
 def convert_llm_tflite(archive_dir, tflite_path, rank=4, use_lora=True, model_type="gemma"):
 
diff --git a/research/utils.py b/research/utils.py
index f718512..23493cd 100644
--- a/research/utils.py
+++ b/research/utils.py
@@ -2,7 +2,7 @@
 import numpy as np
 from collections import defaultdict
 
-from peft_models.ablation.layer import Linear
+from mobiletransformers.peft.ablation.layer import Linear
 from safetensors.torch import load_file
 from safetensors import safe_open
 
@@ -28,17 +28,9 @@ def inspect_adapter_model(filepath="adapter_model.safetensors"):
     except Exception as e:
         print(f"Error loading {filepath}: {e}")
 
-def load_mars_adapters(model, adapter_path):
-    if not os.path.exists(adapter_path):
-        raise FileNotFoundError(f"Adapter file not found: {adapter_path}")
-    
-    # Load adapter weights
-    adapter_state_dict = load_file(adapter_path)
-
-    # Load adapters into model (allow missing keys to avoid errors)
-    model.base_model.model.load_state_dict(adapter_state_dict, strict=False)
-
-    return model
+# Moved to mobiletransformers.peft.adapters (S8): a PACKAGED evaluator is its only
+# caller, and a packaged module cannot import research/ from an installed wheel.
+from mobiletransformers.peft.adapters import load_mars_adapters  # noqa: F401,E402
 
 def get_ablation_linear_layers(model):
     ablation_linear_layers = []
diff --git a/schemas/GenerationConfig.schema.json b/schemas/GenerationConfig.schema.json
new file mode 100644
index 0000000..d4f85cd
--- /dev/null
+++ b/schemas/GenerationConfig.schema.json
@@ -0,0 +1,117 @@
+{
+  "$defs": {
+    "CoreConfigId": {
+      "enum": [
+        "opt1",
+        "opt2",
+        "opt3"
+      ],
+      "title": "CoreConfigId",
+      "type": "string"
+    },
+    "DeviceOptions": {
+      "properties": {
+        "coreConfigId": {
+          "$ref": "#/$defs/CoreConfigId",
+          "default": "opt1"
+        },
+        "enableProfiling": {
+          "default": false,
+          "title": "Enableprofiling",
+          "type": "boolean"
+        },
+        "executionProvider": {
+          "$ref": "#/$defs/ExecutionProvider",
+          "default": "cpu"
+        },
+        "memoryConfigId": {
+          "$ref": "#/$defs/MemoryConfigId",
+          "default": "high_perf"
+        }
+      },
+      "title": "DeviceOptions",
+      "type": "object"
+    },
+    "ExecutionProvider": {
+      "enum": [
+        "cpu",
+        "xnnpack",
+        "nnapi"
+      ],
+      "title": "ExecutionProvider",
+      "type": "string"
+    },
+    "MemoryConfigId": {
+      "enum": [
+        "low_mem",
+        "high_perf"
+      ],
+      "title": "MemoryConfigId",
+      "type": "string"
+    },
+    "SamplingConfig": {
+      "properties": {
+        "method": {
+          "$ref": "#/$defs/SamplingMethod",
+          "default": "greedy"
+        },
+        "seed": {
+          "default": 42,
+          "title": "Seed",
+          "type": "integer"
+        },
+        "temperature": {
+          "default": 1.0,
+          "title": "Temperature",
+          "type": "number"
+        },
+        "topK": {
+          "default": 10,
+          "title": "Topk",
+          "type": "integer"
+        },
+        "topP": {
+          "default": 0.9,
+          "title": "Topp",
+          "type": "number"
+        }
+      },
+      "title": "SamplingConfig",
+      "type": "object"
+    },
+    "SamplingMethod": {
+      "enum": [
+        "greedy",
+        "top_k",
+        "top_p"
+      ],
+      "title": "SamplingMethod",
+      "type": "string"
+    }
+  },
+  "properties": {
+    "deviceOptions": {
+      "$ref": "#/$defs/DeviceOptions"
+    },
+    "maxSequenceLength": {
+      "default": 128,
+      "title": "Maxsequencelength",
+      "type": "integer"
+    },
+    "minReaderVersion": {
+      "default": "1.0",
+      "title": "Minreaderversion",
+      "type": "string"
+    },
+    "sampling": {
+      "$ref": "#/$defs/SamplingConfig"
+    },
+    "schemaVersion": {
+      "default": "1.0",
+      "title": "Schemaversion",
+      "type": "string"
+    }
+  },
+  "title": "GenerationConfig",
+  "type": "object"
+}
diff --git a/schemas/RagConfig.schema.json b/schemas/RagConfig.schema.json
new file mode 100644
index 0000000..813060f
--- /dev/null
+++ b/schemas/RagConfig.schema.json
@@ -0,0 +1,40 @@
+{
+  "$defs": {
+    "SearchType": {
+      "enum": [
+        "semantic",
+        "text"
+      ],
+      "title": "SearchType",
+      "type": "string"
+    }
+  },
+  "properties": {
+    "embeddingDim": {
+      "default": 384,
+      "title": "Embeddingdim",
+      "type": "integer"
+    },
+    "minReaderVersion": {
+      "default": "1.0",
+      "title": "Minreaderversion",
+      "type": "string"
+    },
+    "schemaVersion": {
+      "default": "1.0",
+      "title": "Schemaversion",
+      "type": "string"
+    },
+    "searchType": {
+      "$ref": "#/$defs/SearchType",
+      "default": "semantic"
+    },
+    "topK": {
+      "default": 5,
+      "title": "Topk",
+      "type": "integer"
+    }
+  },
+  "title": "RagConfig",
+  "type": "object"
+}
diff --git a/schemas/TrainingConfig.schema.json b/schemas/TrainingConfig.schema.json
new file mode 100644
index 0000000..7eff14a
--- /dev/null
+++ b/schemas/TrainingConfig.schema.json
@@ -0,0 +1,168 @@
+{
+  "$defs": {
+    "CosineScheduler": {
+      "properties": {
+        "learningRate": {
+          "default": 0.0001,
+          "title": "Learningrate",
+          "type": "number"
+        },
+        "minLearningRate": {
+          "default": 0.0,
+          "title": "Minlearningrate",
+          "type": "number"
+        },
+        "schedulerType": {
+          "const": "cosine",
+          "default": "cosine",
+          "title": "Schedulertype",
+          "type": "string"
+        },
+        "warmupSteps": {
+          "default": 10,
+          "title": "Warmupsteps",
+          "type": "integer"
+        }
+      },
+      "title": "CosineScheduler",
+      "type": "object"
+    },
+    "LinearScheduler": {
+      "properties": {
+        "endFactor": {
+          "default": 0.333,
+          "title": "Endfactor",
+          "type": "number"
+        },
+        "learningRate": {
+          "default": 0.0001,
+          "title": "Learningrate",
+          "type": "number"
+        },
+        "schedulerType": {
+          "const": "linear",
+          "default": "linear",
+          "title": "Schedulertype",
+          "type": "string"
+        },
+        "startFactor": {
+          "default": 1.0,
+          "title": "Startfactor",
+          "type": "number"
+        }
+      },
+      "title": "LinearScheduler",
+      "type": "object"
+    },
+    "PEFTMethod": {
+      "enum": [
+        "lora",
+        "lora-xs",
+        "mars",
+        "all",
+        "nolora"
+      ],
+      "title": "PEFTMethod",
+      "type": "string"
+    },
+    "QuantizationOptions": {
+      "description": "Lifts the ad-hoc quantization ``extra_options`` dict (trainer/builder.py) into typed config.",
+      "properties": {
+        "activationSymmetric": {
+          "default": false,
+          "title": "Activationsymmetric",
+          "type": "boolean"
+        },
+        "enableSubgraph": {
+          "default": false,
+          "title": "Enablesubgraph",
+          "type": "boolean"
+        },
+        "forceQuantizeNoInputCheck": {
+          "default": true,
+          "title": "Forcequantizenoinputcheck",
+          "type": "boolean"
+        },
+        "matMulConstBOnly": {
+          "default": true,
+          "title": "Matmulconstbonly",
+          "type": "boolean"
+        },
+        "weightSymmetric": {
+          "default": false,
+          "title": "Weightsymmetric",
+          "type": "boolean"
+        },
+        "weightType": {
+          "$ref": "#/$defs/QuantizationType",
+          "default": "QInt8"
+        }
+      },
+      "title": "QuantizationOptions",
+      "type": "object"
+    },
+    "QuantizationType": {
+      "enum": [
+        "QInt8",
+        "QUInt8",
+        "int4"
+      ],
+      "title": "QuantizationType",
+      "type": "string"
+    }
+  },
+  "properties": {
+    "alpha": {
+      "default": 16,
+      "title": "Alpha",
+      "type": "integer"
+    },
+    "maxSteps": {
+      "default": 10,
+      "title": "Maxsteps",
+      "type": "integer"
+    },
+    "minReaderVersion": {
+      "default": "1.0",
+      "title": "Minreaderversion",
+      "type": "string"
+    },
+    "peftMethod": {
+      "$ref": "#/$defs/PEFTMethod",
+      "default": "lora"
+    },
+    "quantization": {
+      "$ref": "#/$defs/QuantizationOptions"
+    },
+    "rank": {
+      "default": 8,
+      "title": "Rank",
+      "type": "integer"
+    },
+    "scheduler": {
+      "discriminator": {
+        "mapping": {
+          "cosine": "#/$defs/CosineScheduler",
+          "linear": "#/$defs/LinearScheduler"
+        },
+        "propertyName": "schedulerType"
+      },
+      "oneOf": [
+        {
+          "$ref": "#/$defs/LinearScheduler"
+        },
+        {
+          "$ref": "#/$defs/CosineScheduler"
+        }
+      ],
+      "title": "Scheduler"
+    },
+    "schemaVersion": {
+      "default": "1.0",
+      "title": "Schemaversion",
+      "type": "string"
+    }
+  },
+  "title": "TrainingConfig",
+  "type": "object"
+}
diff --git a/schemas/enums.json b/schemas/enums.json
new file mode 100644
index 0000000..89fea76
--- /dev/null
+++ b/schemas/enums.json
@@ -0,0 +1,60 @@
+{
+  "CoreConfigId": [
+    "opt1",
+    "opt2",
+    "opt3"
+  ],
+  "ExecutionProvider": [
+    "cpu",
+    "xnnpack",
+    "nnapi"
+  ],
+  "HandoffMode": [
+    "external_initializer",
+    "model_input",
+    "adapter"
+  ],
+  "IndexingMode": [
+    "precompute",
+    "dynamic"
+  ],
+  "MemoryConfigId": [
+    "low_mem",
+    "high_perf"
+  ],
+  "MergerVariant": [
+    "lora",
+    "lora_q",
+    "mars_q"
+  ],
+  "PEFTMethod": [
+    "lora",
+    "lora-xs",
+    "mars",
+    "all",
+    "nolora"
+  ],
+  "QuantizationType": [
+    "QInt8",
+    "QUInt8",
+    "int4"
+  ],
+  "SamplingMethod": [
+    "greedy",
+    "top_k",
+    "top_p"
+  ],
+  "SchedulerType": [
+    "linear",
+    "cosine"
+  ],
+  "SearchType": [
+    "semantic",
+    "text"
+  ],
+  "TaskType": [
+    "text-generation",
+    "feature-extraction",
+    "text-classification"
+  ]
+}
diff --git a/scripts/android_build_aar.sh b/scripts/android_build_aar.sh
new file mode 100755
index 0000000..f867a61
--- /dev/null
+++ b/scripts/android_build_aar.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# Assemble the release AAR for the :MobileTransformers SDK module (#30).
+#
+#   scripts/android_build_aar.sh [-Pversion=<x>]
+#
+# Requires JDK 17 and the Android SDK/NDK. The native build also needs the git-ignored vendored
+# libraries under MobileTransformers/src/main/jniLibs/<abi>/ — they are provisioned out-of-band (same
+# story as the ORT-training wheel), so this checks for them up front and says so rather than failing
+# deep inside CMake.
+set -euo pipefail
+
+GRADLE_ROOT="android/MobileTransformers"
+MODULE_DIR="${GRADLE_ROOT}/MobileTransformers"
+JNI_LIBS="${MODULE_DIR}/src/main/jniLibs"
+
+# Libraries the CMake link line requires from jniLibs/<abi>/ (see cpp/CMakeLists.txt).
+REQUIRED_LIBS=(libonnxruntime.so libonnxruntime-genai.so libtokenizers_c.a libtokenizers_cpp.a)
+# v1 ships arm64-v8a only, matching build.gradle.kts's abiFilters — jniLibs/x86_64 lacks
+# libonnxruntime.so and the tokenizers archives, so libmobiletransformers.so cannot be built for it.
+# Set ABIS="arm64-v8a x86_64" once those are vendored; the completeness check below then enforces it.
+ABIS="${ABIS:-arm64-v8a}"
+
+if [ ! -d "${JNI_LIBS}" ]; then
+  echo "error: ${JNI_LIBS} is absent." >&2
+  echo "       The native build needs the vendored ONNX Runtime / tokenizers libraries per ABI." >&2
+  echo "       These are gitignored, so a fresh clone never has them." >&2
+  echo >&2
+  echo "       fix:  scripts/fetch_native_deps.sh" >&2
+  echo "       what: third_party/android/manifest.json  (every file, its sha256 and its provenance)" >&2
+  echo "       why:  docs/ARCHITECTURE.md -> Native dependencies" >&2
+  echo "       all prerequisites at once:  make doctor" >&2
+  exit 1
+fi
+
+incomplete=0
+for abi in ${ABIS}; do
+  for lib in "${REQUIRED_LIBS[@]}"; do
+    # .a/.so are interchangeable for some of these depending on how they were vendored.
+    stem="${lib%.*}"
+    if ! compgen -G "${JNI_LIBS}/${abi}/${stem}."* > /dev/null; then
+      echo "error: ${JNI_LIBS}/${abi}/ is missing ${stem}.(so|a)" >&2
+      incomplete=1
+    fi
+  done
+done
+if [ "${incomplete}" -ne 0 ]; then
+  echo >&2
+  echo "The vendored native libraries are incomplete for the requested ABIs (${ABIS})." >&2
+  echo "A release AAR must ship arm64-v8a AND x86_64. To build a partial artifact for local" >&2
+  echo "work only:  ABIS=arm64-v8a scripts/android_build_aar.sh -Pandroid.injected.build.abi=arm64-v8a" >&2
+  exit 1
+fi
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib/java_home.sh"
+
+echo "==> assembling the release AAR"
+(cd "${GRADLE_ROOT}" && ./gradlew :MobileTransformers:assembleRelease "$@")
+
+AAR="$(find "${MODULE_DIR}/build/outputs/aar" -name '*-release.aar' -print -quit 2>/dev/null || true)"
+if [ -z "${AAR}" ]; then
+  echo "error: assembleRelease reported success but produced no AAR." >&2
+  exit 1
+fi
+
+echo "==> ${AAR}"
+
+# An ABI directory in the AAR proves nothing on its own: the VENDORED libraries are packaged from
+# jniLibs/<abi>/ regardless of whether our own library was built for that ABI. An AAR carrying
+# jni/x86_64/ without libmobiletransformers.so fails at System.loadLibrary on the consumer's device.
+# So verify the PROJECT's library per ABI, not just the directories.
+present_abis="$(unzip -l "${AAR}" | awk '/\.so$/ {print $4}' | sed 's|/[^/]*$||;s|^jni/||' | sort -u)"
+own_abis="$(unzip -l "${AAR}" | awk '/libmobiletransformers\.so$/ {print $4}' | sed 's|/[^/]*$||;s|^jni/||' | sort -u)"
+echo "    ABI directories:            $(echo "${present_abis}" | paste -sd, -)"
+echo "    libmobiletransformers.so:   $(echo "${own_abis}" | paste -sd, -)"
+
+missing_own="$(comm -23 <(echo "${present_abis}") <(echo "${own_abis}"))"
+if [ -n "${missing_own}" ]; then
+  echo >&2
+  echo "error: the AAR ships ABI directories with NO libmobiletransformers.so: $(echo "${missing_own}" | paste -sd, -)" >&2
+  echo "       A consumer on that ABI would fail at System.loadLibrary(\"mobiletransformers\")." >&2
+  echo "       Build every shipped ABI, or restrict the packaged ABIs (abiFilters) to what was built." >&2
+  exit 1
+fi
diff --git a/scripts/build_ort_training_android.sh b/scripts/build_ort_training_android.sh
new file mode 100755
index 0000000..1094195
--- /dev/null
+++ b/scripts/build_ort_training_android.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Build the ONNX Runtime *training* Android AAR + native .so libraries, at the SAME ORT commit as the
+# Python training wheel (third_party/onnxruntime/manifest.json).
+#
+# PLACEHOLDER / REFERENCE: this is not run as part of any current workflow, and the manifest's
+# Android fields (ndk_version, abis, android.*) are still null. The shipped arm64-v8a binaries were
+# built out of band — see third_party/android/manifest.json for their hashes and provenance. This
+# script records the intended build shape so it stays reproducible.
+#
+# Usage:
+#   ORT_SRC=/path/to/onnxruntime ANDROID_NDK_HOME=/path/to/ndk scripts/build_ort_training_android.sh
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+MANIFEST="$REPO_ROOT/third_party/onnxruntime/manifest.json"
+
+ORT_SRC="${ORT_SRC:-$REPO_ROOT/../onnxruntime}"
+ORT_SHA="$(python3 -c "import json;print(json.load(open('$MANIFEST'))['ort_git_sha'])")"
+: "${ANDROID_NDK_HOME:?set ANDROID_NDK_HOME to your NDK path}"
+
+# ABIs / API level to be finalized and written back into manifest.json when this is really run.
+ABIS="${ABIS:-arm64-v8a}"
+ANDROID_API="${ANDROID_API:-24}"
+
+echo "== ONNX Runtime training Android build (reference) =="
+echo "   ORT source : $ORT_SRC"
+echo "   ORT commit : $ORT_SHA"
+echo "   NDK        : $ANDROID_NDK_HOME"
+echo "   ABIs       : $ABIS   API: $ANDROID_API"
+
+if [ ! -d "$ORT_SRC" ]; then
+  echo "ERROR: ORT source not found at $ORT_SRC (set ORT_SRC=...)." >&2
+  exit 1
+fi
+
+git -C "$ORT_SRC" checkout "$ORT_SHA"
+
+for abi in $ABIS; do
+  "$ORT_SRC/build.sh" \
+    --android \
+    --android_sdk_path "${ANDROID_HOME:-$HOME/Android/Sdk}" \
+    --android_ndk_path "$ANDROID_NDK_HOME" \
+    --android_abi "$abi" \
+    --android_api "$ANDROID_API" \
+    --enable_training_apis \
+    --build_java \
+    --config Release \
+    --parallel \
+    --skip_tests
+done
+
+echo "Build complete. Record NDK version, ABIs, AAR/.so SHA256 into third_party/onnxruntime/manifest.json (android.*)."
diff --git a/scripts/build_ort_training_wheel.sh b/scripts/build_ort_training_wheel.sh
new file mode 100755
index 0000000..b0c7f54
--- /dev/null
+++ b/scripts/build_ort_training_wheel.sh
@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Build the source ONNX Runtime *training* CPU wheel that this repo depends on.
+#
+# This is REFERENCE/PROVENANCE tooling. The wheel already exists (see
+# third_party/onnxruntime/manifest.json); only rebuild when the ORT SHA or torch ABI must change.
+# A full build needs tens of GB of scratch space and several minutes.
+#
+# Usage:
+#   ORT_SRC=/path/to/onnxruntime PYTHON=python3.12 scripts/build_ort_training_wheel.sh
+#
+# Reads the target commit + build flags from third_party/onnxruntime/manifest.json.
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+MANIFEST="$REPO_ROOT/third_party/onnxruntime/manifest.json"
+WHEELS_DIR="$REPO_ROOT/third_party/wheels"
+
+ORT_SRC="${ORT_SRC:-$REPO_ROOT/../onnxruntime}"
+PYTHON="${PYTHON:-python3.12}"
+
+ORT_SHA="$("$PYTHON" -c "import json;print(json.load(open('$MANIFEST'))['ort_git_sha'])")"
+TORCH_VER="$("$PYTHON" -c "import json;print(json.load(open('$MANIFEST'))['torch_version'])")"
+
+echo "== ONNX Runtime training wheel build =="
+echo "   ORT source : $ORT_SRC"
+echo "   ORT commit : $ORT_SHA"
+echo "   Python     : $($PYTHON --version)"
+echo "   torch pin  : $TORCH_VER  (must match the built ABI)"
+
+if [ ! -d "$ORT_SRC" ]; then
+  echo "ERROR: ORT source not found at $ORT_SRC (set ORT_SRC=...)." >&2
+  exit 1
+fi
+
+# Pin torch to the recorded ABI before building so training links against the right libtorch.
+"$PYTHON" -m pip install "torch==$TORCH_VER"
+
+git -C "$ORT_SRC" fetch --all --tags
+git -C "$ORT_SRC" checkout "$ORT_SHA"
+
+# CPU training build. See third_party/onnxruntime/BUILD.md for the full flag rationale.
+"$ORT_SRC/build.sh" \
+  --config Release \
+  --enable_training_apis \
+  --build_wheel \
+  --parallel \
+  --skip_tests
+
+mkdir -p "$WHEELS_DIR"
+BUILT_WHL="$(find "$ORT_SRC/build" -name 'onnxruntime_training-*.whl' | head -1)"
+if [ -z "$BUILT_WHL" ]; then
+  echo "ERROR: no onnxruntime_training wheel produced under $ORT_SRC/build." >&2
+  exit 1
+fi
+cp "$BUILT_WHL" "$WHEELS_DIR/"
+echo "Copied $(basename "$BUILT_WHL") -> $WHEELS_DIR/"
+echo "SHA256: $(sha256sum "$WHEELS_DIR/$(basename "$BUILT_WHL")" | cut -d' ' -f1)"
+echo "Now update third_party/onnxruntime/manifest.json (wheel.sha256, ort_git_sha, python_version, torch_version)."
diff --git a/scripts/device_package.sh b/scripts/device_package.sh
new file mode 100755
index 0000000..f9650f1
--- /dev/null
+++ b/scripts/device_package.sh
@@ -0,0 +1,151 @@
+#!/usr/bin/env bash
+# W6 (#1-29 device-test provisioning): export a real package, reshape it into the on-device cache layout,
+# and `adb push` it so the instrumented suites (which assumeTrue-skip without it) can run.
+#
+#   MODEL=<hf-id> [VARIANT=cpu-int4] [TRAIN=1] [RAG=1] [TASK=<optimum-task>] [EMBEDDING_MODEL=<hf-id>] \
+#     scripts/device_package.sh
+#
+# Steps: (1) inference+genai export under the `export` profile; (1b) optional training stage under
+# `ort-training-local` (TRAIN=1) for a train-capable package; (2) reshape build/pkg (#14 variants/ tree)
+# into <sanitizedRepoId>/{inference,train,embedding,tokenizer}; (3) adb push.
+#
+# Push destination: the instrumentation app's *external files dir*, NOT /data/local/tmp. `adb push`
+# can write both, but /data/local/tmp is SELinux-labelled `shell_data_file` — the app domain cannot
+# read it on a modern Android, and cannot write it at all, which the merge and checkpoint legs
+# (TrainMergeGenerateTest) require. DeviceModel.cacheRoot() already probes this path. Override with
+# DEVICE_DEST=... if you know what you are doing.
+set -euo pipefail
+
+MODEL="${MODEL:?set MODEL=<hf-id>, e.g. HuggingFaceTB/SmolLM2-135M-Instruct}"
+VARIANT="${VARIANT:-cpu-int4}"
+TRAIN="${TRAIN:-0}"
+# #33: the export auto-selects a task from TASK_PREFERENCE, which does not include
+# `text-classification` — a sentence-transformers encoder otherwise resolves to `feature-extraction`,
+# which is declared trainable=False. An encoder fine-tune must name its task explicitly.
+TASK="${TASK:-}"
+RAG="${RAG:-1}"
+EMBEDDING_MODEL="${EMBEDDING_MODEL:-}"
+# Overridable so a second model can be staged without overwriting the first package on the host — the
+# DEVICE cache holds one package at a time, but the host copy is what `federated serve` and any
+# re-push read, and re-exporting it costs a full export cycle.
+PKG="${PKG:-build/pkg}"
+DEVICE_CACHE="build/device_cache"
+TEST_PKG="${TEST_PKG:-com.martinkorelic.mobiletransformers.test}"
+DEVICE_DEST="${DEVICE_DEST:-/sdcard/Android/data/$TEST_PKG/files/mt_pkg}"
+# The #10 spike suite probes its own dir (mt_genai_spike/inference) and had no provisioning path, so
+# Gate 0.1 #2/#3/#5 could only ever skip after a device-package run.
+SPIKE_DEST="${SPIKE_DEST:-/sdcard/Android/data/$TEST_PKG/files/mt_genai_spike}"
+# Rough floor: the package itself plus the merged/checkpoint bytes the training legs write beside it.
+MIN_FREE_MB="${MIN_FREE_MB:-4096}"
+
+# --- preflight: fail here with a diagnosis, not three minutes into an export -----------------------
+command -v adb >/dev/null || { echo "adb not found on PATH (install platform-tools)" >&2; exit 1; }
+
+mapfile -t DEVICES < <(adb devices | awk 'NR>1 && $2=="device" {print $1}')
+if [[ "${#DEVICES[@]}" -eq 0 ]]; then
+  echo "no authorized device. Connect one, enable USB debugging, and accept the RSA prompt:" >&2
+  adb devices -l >&2
+  exit 1
+fi
+if [[ "${#DEVICES[@]}" -gt 1 && -z "${ANDROID_SERIAL:-}" ]]; then
+  echo "${#DEVICES[@]} devices attached; set ANDROID_SERIAL=<serial> to pick one:" >&2
+  adb devices -l >&2
+  exit 1
+fi
+
+ABI="$(adb shell getprop ro.product.cpu.abi | tr -d '\r')"
+if [[ "$ABI" != "arm64-v8a" ]]; then
+  echo "device ABI is '$ABI' but only arm64-v8a ships a complete jniLibs set" >&2
+  echo "(x86_64 is missing libonnxruntime.so / libtokenizers_{c,cpp}.a — see docs/ARCHITECTURE.md)" >&2
+  exit 1
+fi
+
+# `df -m` is not portable across Android toybox versions (Android 15 rejects it), and this probe must
+# never be the thing that fails the run — report in MB from 1K blocks, and treat "unknown" as "proceed".
+FREE_MB="$(adb shell df -k /sdcard 2>/dev/null | awk 'NR>1 {print int($4/1024); exit}' | tr -d '\r' || true)"
+if [[ -n "$FREE_MB" && "$FREE_MB" -lt "$MIN_FREE_MB" ]]; then
+  echo "device has ${FREE_MB}MB free on /sdcard; need >= ${MIN_FREE_MB}MB" >&2
+  exit 1
+fi
+echo ">> device $(adb shell getprop ro.product.model | tr -d '\r') ($ABI, API $(adb shell getprop ro.build.version.sdk | tr -d '\r'), ${FREE_MB:-?}MB free)"
+
+# --- 1. inference + genai export (export profile) --------------------------------------------------
+TASK_ARGS=()
+if [[ -n "$TASK" ]]; then
+  TASK_ARGS+=(--task "$TASK")
+fi
+
+# GenAI is a DECODER engine: its config declares a `model.decoder` block with `past_key_values.N`
+# inputs. Requesting it for a task with no KV cache asks the packager for a side-car that describes a
+# cache the graph does not have (the export now refuses to write it — see TaskSpec.emits_genai_config).
+GENAI_ARGS=(--genai)
+case "$TASK" in
+  text-classification|feature-extraction) GENAI_ARGS=() ;;
+esac
+
+RAG_ARGS=()
+if [[ "$RAG" == "1" ]]; then
+  RAG_ARGS+=(--include-rag)
+  [[ -n "$EMBEDDING_MODEL" ]] && RAG_ARGS+=(--embedding-model "$EMBEDDING_MODEL")
+fi
+
+echo ">> [1/4] inference+genai export ($MODEL) under the export profile"
+# --validate re-reads the written package against the #13 manifest contract, so a broken export fails
+# here rather than as an unexplained skip on device.
+uv run --extra export --python 3.12 mobiletransformers export \
+  --model "$MODEL" --output "$PKG" "${GENAI_ARGS[@]}" --validate "${TASK_ARGS[@]}" "${RAG_ARGS[@]}"
+
+if [[ "$TRAIN" == "1" ]]; then
+  echo ">> [1b] training stage under ort-training-local (train-capable package)"
+  # An explicit `uv sync` first, then `uv run --no-sync`. Step 1 above installs the export profile's
+  # stock `onnxruntime` into the shared .venv, and `uv run --group ort-training-local` does NOT displace
+  # it — the source-built training wheel provides a distribution of the same name, so the resolver
+  # considers the requirement already satisfied. The training import then finds a runtime with no
+  # training APIs and dies with `ImportError: cannot import name 'PropagateCastOpsStrategy'`. Running
+  # the training stage on its own works, which is why this only shows up on the TRAIN=1 path.
+  uv sync --python 3.12 --group ort-training-local --no-default-groups --reinstall-package onnxruntime-training
+  uv run --no-sync --python 3.12 \
+    mobiletransformers export --model "$MODEL" --output "$PKG" --stages training "${TASK_ARGS[@]}"
+fi
+
+# --- 2. reshape into the on-device cache layout ----------------------------------------------------
+# sanitized repo id = HF id with '/' -> '__' (mirrors PackageFormat.sanitizeRepoId).
+SANITIZED="${MODEL//\//__}"
+echo ">> [2/4] reshape $PKG/variants/$VARIANT -> $DEVICE_CACHE/$SANITIZED"
+if [[ ! -d "$PKG/variants/$VARIANT" ]]; then
+  echo "no variant '$VARIANT' in $PKG/variants (have: $(ls "$PKG/variants" 2>/dev/null | tr '\n' ' '))" >&2
+  echo "set VARIANT=<id> to match the exported quantization" >&2
+  exit 1
+fi
+rm -rf "$DEVICE_CACHE"
+DEST="$DEVICE_CACHE/$SANITIZED"
+mkdir -p "$DEST"
+for stage in inference train embedding; do
+  [[ -d "$PKG/variants/$VARIANT/$stage" ]] && cp -r "$PKG/variants/$VARIANT/$stage" "$DEST/$stage"
+done
+[[ -d "$PKG/shared/tokenizer" ]] && cp -r "$PKG/shared/tokenizer" "$DEST/tokenizer"
+
+echo ">> staged: $(cd "$DEST" && ls -d */ 2>/dev/null | tr -d '/' | tr '\n' ' ')"
+
+# --- 3. push ---------------------------------------------------------------------------------------
+echo ">> [3/4] adb push -> $DEVICE_DEST"
+adb shell "rm -rf '$DEVICE_DEST' && mkdir -p '$DEVICE_DEST'"
+adb push "$DEVICE_CACHE/." "$DEVICE_DEST" >/dev/null
+# `adb push` writes into the app's external dir as the `shell` user with mode 0770, so "other" — which
+# is what the app resolves to for shell-owned entries — gets nothing, and File.canRead()/listFiles()
+# return false/null on every pushed subdirectory. Widen so the app can use its own package.
+#
+# 777, not 775: in production the cache tree is created by ModelPackageInstaller and is app-owned, so
+# the app can write inside it — the RAG vector store creates `embedding/database/`, and the merge and
+# checkpoint legs write beside the weights. A read-only fixture would fail those for a reason that does
+# not exist on a real install. chmod may be refused when the target is already app-owned; harmless.
+adb shell "chmod -R 777 '$DEVICE_DEST' 2>/dev/null" || true
+adb shell "ls '$DEVICE_DEST'"
+
+echo ">> [3b] staging the GenAI spike dir -> $SPIKE_DEST"
+adb shell "rm -rf '$SPIKE_DEST' && mkdir -p '$SPIKE_DEST'"
+adb push "$DEST/inference" "$SPIKE_DEST/inference" >/dev/null
+adb shell "chmod -R 777 '$SPIKE_DEST' 2>/dev/null" || true
+
+echo ">> [4/4] done. Run the instrumented suites:"
+echo "   make device-test"
diff --git a/scripts/device_rss.sh b/scripts/device_rss.sh
new file mode 100755
index 0000000..b7ad21c
--- /dev/null
+++ b/scripts/device_rss.sh
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# Gate 0.1 #4 + Gate 0.2 (#10/#12): collect the four-point RSS table and evaluate both gates.
+#
+#   scripts/device_rss.sh            # needs a device + a pushed package (make device-package)
+#
+# The two knobs live outside the test process, so the 2x2 table is four instrumented runs:
+#   engine        -> MemoryRssTest.nativeFourPointTable / .genAiFourPointTable
+#   weight load   -> `adb shell setprop debug.mtf.mmap_weights {0,1}` (an instrumented test cannot set
+#                    an environment variable in the process it is measuring)
+# Each run writes one JSON row into the app's external files dir; this pulls them and applies the
+# project's ratified memory-gate thresholds.
+set -euo pipefail
+
+GRADLE_ROOT="android/MobileTransformers"
+TEST_PKG="${TEST_PKG:-com.martinkorelic.mobiletransformers.test}"
+RSS_REMOTE="/sdcard/Android/data/$TEST_PKG/files/mt_rss"
+OUT="${OUT:-build/rss}"
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib/java_home.sh"
+
+command -v adb >/dev/null || { echo "adb not found on PATH" >&2; exit 1; }
+test "$(adb devices | grep -c 'device$')" -ge 1 || { echo "no authorized device" >&2; exit 1; }
+
+adb shell "rm -rf '$RSS_REMOTE'" || true
+
+for mode in 0 1; do
+  echo ">> weight-load path: $([ "$mode" = 1 ] && echo mmap || echo copy)"
+  adb shell setprop debug.mtf.mmap_weights "$mode"
+  (cd "$GRADLE_ROOT" && ./gradlew :MobileTransformers:connectedDebugAndroidTest \
+      -Pandroid.testInstrumentationRunnerArguments.class=com.martinkorelic.mobiletransformers.MemoryRssTest) \
+    || echo ">> (run reported failures; rows already written are still collected)"
+done
+# Leave the device on the shipping default.
+adb shell setprop debug.mtf.mmap_weights 0
+
+rm -rf "$OUT"; mkdir -p "$OUT"
+adb pull "$RSS_REMOTE" "$OUT" >/dev/null 2>&1 || true
+find "$OUT" -name '*.json' -exec mv {} "$OUT"/ \; 2>/dev/null || true
+
+python3 - "$OUT" <<'PY'
+import json, pathlib, sys
+
+rows = {}
+for p in pathlib.Path(sys.argv[1]).rglob("*.json"):
+    r = json.loads(p.read_text())
+    rows[(r["engine"], bool(r["mmapWeights"]))] = r
+
+if not rows:
+    sys.exit("no RSS rows collected — did MemoryRssTest skip? (needs a pushed package)")
+
+print(f"\n{'engine':8} {'load':6} {'pre':>10} {'postLoad':>10} {'post1tok':>10} {'postRel':>10} {'peak':>10}")
+for (engine, mmap), r in sorted(rows.items()):
+    print(f"{engine:8} {'mmap' if mmap else 'copy':6} {r['preLoadKb']:>10} {r['postWeightLoadKb']:>10} "
+          f"{r['postFirstTokenKb']:>10} {r['postReleaseKb']:>10} {r['peakKb']:>10}   (kB)")
+
+failures = []
+
+# Gate 0.1 #4 — GenAI peak vs the Native baseline, on the shipping (copy) path.
+nat, gen = rows.get(("native", False)), rows.get(("genai", False))
+if nat and gen:
+    allowed = max(nat["peakKb"] * nat["acceptedRssDeltaRatio"], nat["acceptedRssDeltaFloorKb"])
+    delta = gen["peakKb"] - nat["peakKb"]
+    ok = delta <= allowed
+    print(f"\nGate 0.1 #4: GenAI peak - Native peak = {delta} kB, allowed {int(allowed)} kB -> "
+          f"{'PASS' if ok else 'FAIL'}")
+    if not ok:
+        failures.append("Gate 0.1 #4")
+else:
+    print("\nGate 0.1 #4: NOT EVALUATED (need both engines on the copy path)")
+
+# Gate 0.2 — mmap must cut peak RSS by the ratified margin, per engine.
+for engine in ("native", "genai"):
+    copy_row, mmap_row = rows.get((engine, False)), rows.get((engine, True))
+    if not (copy_row and mmap_row):
+        print(f"Gate 0.2 [{engine}]: NOT EVALUATED (need both weight-load paths)")
+        continue
+    required = copy_row["gate02RequiredReduction"]
+    reduction = 1 - (mmap_row["peakKb"] / copy_row["peakKb"])
+    ok = reduction >= required
+    print(f"Gate 0.2 [{engine}]: peak reduction {reduction:.1%}, required {required:.0%} -> "
+          f"{'PASS' if ok else 'FAIL'}")
+    if not ok:
+        failures.append(f"Gate 0.2 [{engine}]")
+
+# A failed gate is a real result to record, not a broken run — the mmap experiment is explicitly
+# allowed to come back negative. Report, do not exit non-zero.
+print("\n" + ("all evaluated gates PASS" if not failures else "gates not met: " + ", ".join(failures)))
+PY
+
+echo ">> rows in $OUT"
diff --git a/scripts/doctor.sh b/scripts/doctor.sh
new file mode 100755
index 0000000..634cee2
--- /dev/null
+++ b/scripts/doctor.sh
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+# One preflight report: every prerequisite, whether it is present, and the command that fixes it.
+#
+#   make doctor        (or: scripts/doctor.sh)
+#
+# Read-only. It downloads nothing, installs nothing and syncs no profile — safe to run at any time,
+# including while an export is in flight.
+#
+# WHY. The prerequisites are spread across uv, two Python versions, a JDK, the Android SDK, ~180 MB of
+# gitignored native binaries, a 662 MB source-built wheel and a `.env` token, and each one fails in a
+# different tool with a message that names neither the prerequisite nor how to get it. A fresh clone
+# could not build the Android SDK and the reason was undiscoverable. This is the single place that
+# answers "what is missing".
+#
+# It always exits 0. A missing prerequisite is normal — most workflows need only a few of these — so
+# this reports rather than gates. The `[--]` rows tell you what you cannot do yet.
+set -uo pipefail
+
+cd "$(dirname "$0")/.."
+
+GREEN=$'\033[32m'; RED=$'\033[31m'; YELLOW=$'\033[33m'; BOLD=$'\033[1m'; DIM=$'\033[2m'; OFF=$'\033[0m'
+MISSING=0
+
+section() { printf '\n%s%s%s\n' "$BOLD" "$1" "$OFF"; }
+ok()      { printf '  %s[ok]%s %-26s %s\n' "$GREEN" "$OFF" "$1" "${2:-}"; }
+bad()     { MISSING=$((MISSING+1)); printf '  %s[--]%s %-26s %s\n' "$RED" "$OFF" "$1" "${2:-}"; \
+            printf '       %sfix:%s %s\n' "$YELLOW" "$OFF" "$3"; }
+note()    { printf '       %s%s%s\n' "$DIM" "$1" "$OFF"; }
+
+section "Host toolchain"
+
+if command -v uv >/dev/null 2>&1; then
+  ok "uv" "$(uv --version 2>/dev/null)"
+else
+  bad "uv" "not on PATH" "curl -LsSf https://astral.sh/uv/install.sh | sh   (usually lands in ~/.local/bin)"
+fi
+
+for v in 3.10 3.12; do
+  if command -v "python$v" >/dev/null 2>&1; then
+    ok "python$v" "$(python$v -V 2>&1)"
+  elif uv python find "$v" >/dev/null 2>&1; then
+    ok "python$v" "available via uv"
+  else
+    case "$v" in
+      3.10) bad "python3.10" "not found" "uv python install 3.10   — the core/dev profile (make check) targets it" ;;
+      3.12) bad "python3.12" "not found" "uv python install 3.12   — required by the export and ORT-training profiles" ;;
+    esac
+  fi
+done
+
+if [ -d .venv ]; then
+  ok ".venv" "$(.venv/bin/python -V 2>&1 || echo 'present but unusable')"
+  # Which profile the shared venv is currently on. The single most common way to "break" the repo is
+  # running `make check` on a leftover export/training profile.
+  if .venv/bin/python -c "import onnxruntime.training" >/dev/null 2>&1; then
+    note "profile: ort-training-local — reset before make check: uv sync --frozen --group dev --python 3.10"
+  elif .venv/bin/python -c "import onnxruntime" >/dev/null 2>&1; then
+    note "profile: export (or genai) — reset before make check: uv sync --frozen --group dev --python 3.10"
+  else
+    note "profile: core/dev — ready for make check"
+  fi
+else
+  bad ".venv" "no environment yet" "make setup"
+fi
+
+section "Python: training profile (on-device fine-tuning exports)"
+
+WHEEL=third_party/wheels/onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl
+if [ -f "$WHEEL" ]; then
+  ok "ORT-training wheel" "$(du -h "$WHEEL" | cut -f1)"
+else
+  bad "ORT-training wheel" "$WHEEL" \
+      "TRAINING=1 scripts/fetch_native_deps.sh   (or source-build it: third_party/onnxruntime/BUILD.md)"
+  note "cp312 + linux_x86_64 only. macOS/Windows must rebuild it before any training export."
+  note "Without it: exports are inference-only; make test-train and make publish-catalog cannot run."
+fi
+
+section "Android: JDK + SDK"
+
+if (. scripts/lib/java_home.sh) >/dev/null 2>&1; then
+  # shellcheck disable=SC1091
+  . scripts/lib/java_home.sh >/dev/null 2>&1
+  ok "JAVA_HOME" "$JAVA_HOME ($("$JAVA_HOME/bin/java" -version 2>&1 | head -1))"
+else
+  bad "JAVA_HOME" "no JDK 17+ found" "export JAVA_HOME=/path/to/jdk17   (Android Studio ships one)"
+fi
+
+SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-$HOME/Android/Sdk}}"
+if [ -d "$SDK" ]; then
+  ok "Android SDK" "$SDK"
+else
+  bad "Android SDK" "not at $SDK" "install it via Android Studio, then: export ANDROID_HOME=/path/to/Sdk"
+fi
+
+LOCAL_PROPS=android/MobileTransformers/local.properties
+if [ -f "$LOCAL_PROPS" ]; then
+  ok "local.properties" "present"
+elif [ -d "$SDK" ]; then
+  ok "local.properties" "absent, but ANDROID_HOME resolves — Gradle will manage"
+else
+  bad "local.properties" "absent and no SDK found" "echo \"sdk.dir=/path/to/Sdk\" > $LOCAL_PROPS"
+fi
+
+if command -v adb >/dev/null 2>&1; then
+  DEVICES="$(adb devices 2>/dev/null | grep -c 'device$')"
+  if [ "$DEVICES" -ge 1 ]; then
+    ok "adb" "$DEVICES authorized device(s)"
+  else
+    ok "adb" "on PATH, no device attached"
+    note "Device targets (device-package / device-test / device-rss) need one; host gates do not."
+  fi
+else
+  bad "adb" "not on PATH" "export PATH=\"\$PATH:$SDK/platform-tools\""
+  note "Only the device targets need it."
+fi
+
+section "Android: vendored native dependencies"
+
+# Delegated to the fetch script's own verifier so there is ONE definition of "provisioned" — a second
+# copy of this list here is exactly how the two would drift.
+if NATIVE_REPORT="$(scripts/fetch_native_deps.sh 2>&1)" && \
+   printf '%s' "$NATIVE_REPORT" | grep -q "nothing to do"; then
+  ok "jniLibs / aarLibs / includes" "all present and verified against third_party/android/manifest.json"
+else
+  N_MISSING="$(printf '%s' "$NATIVE_REPORT" | grep -c '^MISSING\|^CORRUPT')"
+  bad "jniLibs / aarLibs / includes" "$N_MISSING artifact(s) missing or corrupt" \
+      "scripts/fetch_native_deps.sh   (see third_party/android/manifest.json)"
+  printf '%s\n' "$NATIVE_REPORT" | grep '^MISSING\|^CORRUPT' | head -12 | sed 's/^/       /'
+  note "These are gitignored and are the ONLY thing a git clone does not bring."
+  note "Without them the Android SDK cannot be built at all (make android-build / build-aar)."
+fi
+
+section "Hugging Face credentials"
+
+if [ -f .env ]; then
+  # shellcheck disable=SC1091
+  set -a; . ./.env; set +a
+  ok ".env" "present"
+else
+  bad ".env" "absent" "cp .env.example .env   then fill in the tokens you need"
+fi
+
+if [ -n "${HF_TOKEN:-}" ]; then
+  ok "HF_TOKEN" "set (personal)"
+else
+  bad "HF_TOKEN" "unset" "add HF_TOKEN=… to .env  (see .env.example)"
+  note "Needed for: exporting a gated base model, pulling a private package, the app's Install button."
+fi
+
+if [ -n "${HF_TOKEN_ORG:-}" ]; then
+  ok "HF_TOKEN_ORG" "set (organisation)"
+else
+  bad "HF_TOKEN_ORG" "unset" "add HF_TOKEN_ORG=… to .env  (see .env.example)"
+  note "Needed for: make publish-catalog. A personal token scoped to one repo cannot see the others."
+fi
+
+section "Summary"
+if [ "$MISSING" -eq 0 ]; then
+  printf '  %sEverything this repo knows how to check is present.%s\n\n' "$GREEN" "$OFF"
+else
+  printf '  %s%d prerequisite(s) missing%s — each is listed with its fix above.\n' "$YELLOW" "$MISSING" "$OFF"
+  printf '  Most workflows need only some of them; see docs/ARCHITECTURE.md ▸ Native dependencies.\n\n'
+fi
+exit 0
diff --git a/scripts/federated_peer_record.py b/scripts/federated_peer_record.py
new file mode 100644
index 0000000..7009567
--- /dev/null
+++ b/scripts/federated_peer_record.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Derive a synthetic PEER record from a real device record (#36 device round-trip).
+
+## Why this exists
+
+`FederatedGateway` refuses to publish an aggregate below `min_clients` (2 by default), and one phone is
+available. Submitting the device's own record twice would satisfy the count while producing an
+"aggregate" numerically identical to what the device already holds — an import that writes back exactly
+what was there cannot distinguish a working round from a no-op, which is the whole thing the device
+round-trip is meant to prove.
+
+So the second client is explicitly synthetic and explicitly *different*: every factor scaled by
+``--scale``. FedAvg then produces a value the device did **not** produce, and the device-side assertion
+"the checkpoint now holds the aggregate's bytes" has something to fail against.
+
+What this does NOT claim: it is not a second training run, and the round-trip therefore proves the
+transport/aggregation/import seam, not multi-device convergence (that is #35's simulation, which trains
+real clients).
+
+Usage::
+
+    python scripts/federated_peer_record.py --package build/pkg \
+        --input build/federated_round/client_update.bin \
+        --output build/federated_round/peer_update.bin --scale 3.0
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--package", required=True, help="Path to the exported package dir.")
+    parser.add_argument("--input", required=True, help="A real client record (from the device).")
+    parser.add_argument("--output", required=True, help="Where to write the synthetic peer record.")
+    parser.add_argument("--scale", type=float, default=3.0, help="Factor applied to every tensor.")
+    args = parser.parse_args(argv)
+
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+    from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+    from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+
+    pkg = Path(args.package)
+    manifest = MobileTransformersManifest.load(pkg / "mobiletransformers_manifest.json")
+    handoff = HandoffMap.load(pkg / manifest.data["weightHandoff"])
+
+    record = FederatedAdapterRecord.deserialize(Path(args.input).read_bytes())
+    # check_format is what would catch a device record built against a different package; running it
+    # here means a mismatch is reported next to the two files rather than as a gateway rejection.
+    record.check_format(handoff)
+
+    peer = FederatedAdapterRecord.from_handoff(
+        handoff,
+        [array * args.scale for array in record.arrays],
+        base_model_id=record.base_model_id,
+        peft_method=record.peft_method,
+        round=record.round,
+        package_revision=record.mobiletransformers_package_revision,
+    )
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_bytes(peer.serialize())
+
+    print(
+        f"peer record: {len(peer.tensors)} tensors x{args.scale} -> {out} "
+        f"({out.stat().st_size} B)"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/federated_round_device.sh b/scripts/federated_round_device.sh
new file mode 100755
index 0000000..c49b12a
--- /dev/null
+++ b/scripts/federated_round_device.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# #36 device round-trip: export adapter factors on REAL hardware -> aggregate on the host -> import the
+# aggregate back into the device checkpoint.
+#
+#   [PKG=build/pkg] [SCALE=3.0] scripts/federated_round_device.sh
+#
+# The middle of a federated round is a host process, so the seam cannot be crossed inside one
+# instrumentation run. This drives both halves and the host step between them:
+#
+#   phase 1 (device)  export the local factors from a live ORT checkpoint  -> client_update.bin
+#   adb pull          bring the record to the host
+#   peer record       derive a synthetic SECOND client (scaled) — see federated_peer_record.py for why
+#   federated serve   FedAvg the two into a global record                  -> global_record.bin
+#   adb push          hand the aggregate back to the device
+#   phase 2 (device)  import it, assert every checkpoint tensor now holds the aggregate's bytes,
+#                     then train+export one more round on top of it
+#
+# `BuildConfig.FEDERATION_ENABLED` is FALSE by default and that refusal is the feature (#36 privacy
+# gate), so the instrumentation runs are invoked with `-PmtFederationEnabled=true` — deliberately, per
+# invocation, never persisted into the tree.
+set -euo pipefail
+
+PKG="${PKG:-build/pkg}"
+OUT="${OUT:-build/federated_round}"
+SCALE="${SCALE:-3.0}"
+TEST_PKG="${TEST_PKG:-com.martinkorelic.mobiletransformers.test}"
+DEVICE_FED="${DEVICE_FED:-/sdcard/Android/data/$TEST_PKG/files/mt_pkg/federated}"
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib/java_home.sh"
+TEST_CLASS="com.martinkorelic.mobiletransformers.FederatedRoundDeviceTest"
+
+gradle_test() {
+  local method="$1"
+  (cd android/MobileTransformers && JAVA_HOME="$JAVA_HOME" ./gradlew \
+    :MobileTransformers:connectedDebugAndroidTest \
+    -PmtFederationEnabled=true \
+    "-Pandroid.testInstrumentationRunnerArguments.class=$TEST_CLASS#$method")
+}
+
+# --- preflight ------------------------------------------------------------------------------------
+command -v adb >/dev/null || { echo "adb not found on PATH (install platform-tools)" >&2; exit 1; }
+mapfile -t DEVICES < <(adb devices | awk 'NR>1 && $2=="device" {print $1}')
+if [[ "${#DEVICES[@]}" -eq 0 ]]; then
+  echo "no authorized device; connect one and accept the RSA prompt" >&2
+  exit 1
+fi
+if [[ ! -f "$PKG/mobiletransformers_manifest.json" ]]; then
+  echo "no package at $PKG (set PKG=<dir>). The gateway needs the SAME package the device holds —" >&2
+  echo "its weight_handoff_map.json is the authority on tensor names/shapes." >&2
+  exit 1
+fi
+
+mkdir -p "$OUT"
+# A stale record from an earlier run would let a SKIPPED phase look like a passing round.
+rm -f "$OUT/client_update.bin" "$OUT/peer_update.bin" "$OUT/global_record.bin"
+adb shell "rm -rf $DEVICE_FED" >/dev/null 2>&1 || true
+
+# --- 1. device: export -----------------------------------------------------------------------------
+echo ">> [1/5] phase 1 on device: export adapter factors from the live checkpoint"
+gradle_test phase1ExportsAnUpdateFromTheRealCheckpoint
+
+echo ">> [2/5] pull the client record"
+adb pull "$DEVICE_FED/client_update.bin" "$OUT/client_update.bin" >/dev/null || {
+  echo "phase 1 wrote no record. It skips (rather than fails) without a train-capable package —" >&2
+  echo "run: make device-package MODEL=<hf-id> TRAIN=1" >&2
+  exit 1
+}
+echo "   client record: $(stat -c%s "$OUT/client_update.bin") B"
+
+# --- 2. host: second client + aggregate ------------------------------------------------------------
+echo ">> [3/5] derive a synthetic peer record (x$SCALE) and aggregate both"
+uv run python scripts/federated_peer_record.py \
+  --package "$PKG" --input "$OUT/client_update.bin" --output "$OUT/peer_update.bin" --scale "$SCALE"
+
+# Example weights 1 and 3 -> the FedAvg mean is (1*v + 3*SCALE*v)/4, a value NEITHER client submitted.
+uv run mobiletransformers federated serve \
+  --package "$PKG" \
+  --updates "device:$OUT/client_update.bin:1" "peer:$OUT/peer_update.bin:3" \
+  --min-clients 2 --round 1 --output "$OUT/global_record.bin"
+
+# --- 3. device: import -----------------------------------------------------------------------------
+echo ">> [4/5] push the global record back"
+adb shell "mkdir -p $DEVICE_FED"
+adb push "$OUT/global_record.bin" "$DEVICE_FED/global_record.bin" >/dev/null
+adb shell "chmod -R 777 $DEVICE_FED" || true
+
+echo ">> [5/5] phase 2 on device: import the aggregate, then train+export on top of it"
+gradle_test phase2ImportsTheAggregateIntoTheRealCheckpoint
+
+echo
+echo "round complete. Payload sizes:"
+ls -l "$OUT"/*.bin | awk '{print "  " $NF ": " $5 " B"}'
+echo "Device-side measurements are in the instrumentation log:"
+echo "  adb logcat -d -s FederatedRoundDeviceTest"
diff --git a/scripts/fetch_native_deps.sh b/scripts/fetch_native_deps.sh
new file mode 100755
index 0000000..fda4280
--- /dev/null
+++ b/scripts/fetch_native_deps.sh
@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# Download and install the Android native dependencies a `git clone` does not bring.
+#
+#   scripts/fetch_native_deps.sh              # the natives bundle (what you need to build)
+#   TRAINING=1 scripts/fetch_native_deps.sh   # also the source-built ORT-training wheel (~632 MB)
+#   SYMBOLS=1 scripts/fetch_native_deps.sh    # also the unstripped debug symbols (~260 MB)
+#   URL=file:///path/to/dir scripts/fetch_native_deps.sh   # a local mirror, or an already-downloaded copy
+#   FORCE=1 scripts/fetch_native_deps.sh      # re-install even if every file already verifies
+#
+# `third_party/android/manifest.json` is the source of truth for what to fetch, where it goes and what
+# it must hash to. This script does not hardcode a single filename.
+#
+# WHY THIS EXISTS. ~180 MB of prebuilt binaries and vendored headers are gitignored, so a fresh clone
+# cannot build the Android SDK at all — and before this script the failure was undiscoverable: CMake
+# reported a missing link input naming no provenance, and `android_build_aar.sh` pointed at a docs
+# page that never mentioned jniLibs. See docs/ARCHITECTURE.md ▸ Native dependencies.
+#
+# TWO HASH CHECKS, DELIBERATELY. The archive sha256 proves the download; the per-file sha256s prove
+# the unpack. A half-populated jniLibs/ is the failure this guards: the link then fails naming a
+# symbol, not a missing file, and that is an afternoon.
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+REPO_ROOT="$PWD"
+MANIFEST="third_party/android/manifest.json"
+SYMBOLS="${SYMBOLS:-0}"
+TRAINING="${TRAINING:-0}"
+FORCE="${FORCE:-0}"
+
+log()  { printf '\n\033[1m>> %s\033[0m\n' "$*"; }
+warn() { printf '\033[33m   %s\033[0m\n' "$*"; }
+fail() { printf '\n\033[31m!! %s\033[0m\n' "$*" >&2; exit 1; }
+
+[[ -f "$MANIFEST" ]] || fail "$MANIFEST not found — are you in the repo root?"
+command -v python3 >/dev/null || fail "python3 is required (it reads the manifest and verifies hashes)"
+command -v curl    >/dev/null || fail "curl is required"
+command -v tar     >/dev/null || fail "tar is required"
+tar --zstd --help >/dev/null 2>&1 || fail "your tar cannot read .zst — install zstd (apt install zstd)"
+
+q() { python3 -c "import json,sys;print(json.load(open('$MANIFEST'))$1)"; }
+
+UNPACK_ROOT="$(q "['unpackRoot']")"
+BASE_URL="${URL:-$(q "['baseUrl'] or ''")}"
+
+# --- is anything actually missing? -----------------------------------------------------------------
+# Reported before downloading, so a no-op run costs nothing and says so.
+verify_installed() {
+  python3 - "$REPO_ROOT" "$MANIFEST" <<'PY'
+import hashlib, json, sys
+from pathlib import Path
+
+root, manifest_path = Path(sys.argv[1]), Path(sys.argv[2])
+manifest = json.loads(manifest_path.read_text())
+base = root / manifest["unpackRoot"]
+
+missing, corrupt = [], []
+for art in manifest["artifacts"]:
+    path = base / art["path"]
+    if not path.is_file():
+        missing.append(art["path"])
+        continue
+    digest = hashlib.sha256(path.read_bytes()).hexdigest()
+    if digest != art["sha256"]:
+        corrupt.append((art["path"], art["sha256"], digest))
+
+for d in manifest.get("directories", []):
+    if not (base / d["path"]).is_dir():
+        missing.append(d["path"] + "/")
+
+for name in missing:
+    print(f"MISSING {name}")
+for name, want, got in corrupt:
+    print(f"CORRUPT {name}\n        expected {want}\n        actual   {got}")
+sys.exit(1 if (missing or corrupt) else 0)
+PY
+}
+
+# Resolve the wheel's identity up front — needed both to decide whether to fetch it and to verify a
+# copy that is already there. Its filename and sha256 live in the ORT build's own provenance record.
+WHEEL_MANIFEST="third_party/onnxruntime/manifest.json"
+WHEEL_FILE="$(python3 -c "import json;print(json.load(open('$WHEEL_MANIFEST'))['wheel']['filename'])")"
+WHEEL_WANT="$(python3 -c "import json;print(json.load(open('$WHEEL_MANIFEST'))['wheel']['sha256'])")"
+WHEEL_DEST="third_party/wheels/$WHEEL_FILE"
+
+log "checking what is already installed under $UNPACK_ROOT"
+NEED_NATIVES=0
+verify_installed || NEED_NATIVES=1
+[[ "$FORCE" == "1" || "$SYMBOLS" == "1" ]] && NEED_NATIVES=1
+
+NEED_WHEEL=0
+if [[ "$TRAINING" == "1" ]]; then
+  if [[ -f "$WHEEL_DEST" ]] && [[ "$(sha256sum "$WHEEL_DEST" | cut -d' ' -f1)" == "$WHEEL_WANT" ]]; then
+    log "[wheel] already present and verifies"
+  else
+    NEED_WHEEL=1
+  fi
+fi
+
+if [[ "$NEED_NATIVES" == "0" && "$NEED_WHEEL" == "0" ]]; then
+  log "everything requested is present and verifies — nothing to do (FORCE=1 to reinstall)"
+  exit 0
+fi
+
+# A URL is only required once something actually has to be downloaded. Checked here, AFTER deciding,
+# so a fully-provisioned tree reports itself green instead of failing on a baseUrl it never needed —
+# which is the state of every developer machine that predates this script.
+if [[ -z "$BASE_URL" ]]; then
+  fail "something is missing (above), and there is no download URL.
+
+  third_party/android/manifest.json has \`baseUrl: null\` — the artifacts have been built but not yet
+  hosted anywhere, so there is nothing for this script to fetch.
+
+  If you have the files already:
+      URL=file:///path/to/their/directory scripts/fetch_native_deps.sh
+
+  If you are the maintainer: host build/dist/*.tar.zst (and the ORT-training wheel, for TRAINING=1)
+  and set \`baseUrl\` in the manifest to the directory they live under. A GitHub Release keeps the
+  URL stable across tags."
+fi
+
+# --- fetch ------------------------------------------------------------------------------------------
+STAGE="$(mktemp -d)"
+trap 'rm -rf "$STAGE"' EXIT
+
+bundle_count="$(q "['bundles'].__len__()")"
+[[ "$NEED_NATIVES" == "1" ]] && for i in $(seq 0 $((bundle_count - 1))); do
+  NAME="$(q "['bundles'][$i]['name']")"
+  FILE="$(q "['bundles'][$i]['filename']")"
+  WANT="$(q "['bundles'][$i]['sha256']")"
+  REQUIRED="$(q "['bundles'][$i]['required']")"
+
+  if [[ "$REQUIRED" != "True" && "$SYMBOLS" != "1" ]]; then
+    warn "skipping optional bundle '$NAME' (SYMBOLS=1 to fetch it)"
+    continue
+  fi
+
+  log "[$NAME] downloading $FILE"
+  curl -fL --progress-bar -o "$STAGE/$FILE" "${BASE_URL%/}/$FILE" \
+    || fail "download failed: ${BASE_URL%/}/$FILE"
+
+  log "[$NAME] verifying archive sha256"
+  GOT="$(sha256sum "$STAGE/$FILE" | cut -d' ' -f1)"
+  # Refuse rather than half-populate: unpacking an archive that failed its hash would leave the tree
+  # in a state this script's own verify step then blames on the unpack.
+  [[ "$GOT" == "$WANT" ]] || fail "sha256 mismatch for $FILE
+    expected $WANT
+    actual   $GOT
+  Nothing was unpacked. Re-download, or check that URL points at the right release."
+
+  log "[$NAME] unpacking into $UNPACK_ROOT"
+  mkdir -p "$UNPACK_ROOT"
+  tar --zstd -xf "$STAGE/$FILE" -C "$UNPACK_ROOT"
+done
+
+# --- the ORT-training wheel (optional; only the training side needs it) -----------------------------
+#
+# Not part of the natives bundle and not an Android artifact: it is a source-built CPython wheel
+# (cp312, linux_x86_64) that the EXPORT host needs to emit a training stage. Its filename and sha256
+# are recorded in third_party/onnxruntime/manifest.json, which is the provenance record for the ORT
+# build itself, so they are read from there rather than duplicated.
+if [[ "$NEED_WHEEL" == "1" ]]; then
+  log "[wheel] downloading $WHEEL_FILE (~632 MB)"
+  mkdir -p third_party/wheels
+  curl -fL --progress-bar -o "$STAGE/$WHEEL_FILE" "${BASE_URL%/}/$WHEEL_FILE" \
+    || fail "download failed: ${BASE_URL%/}/$WHEEL_FILE"
+  GOT="$(sha256sum "$STAGE/$WHEEL_FILE" | cut -d' ' -f1)"
+  [[ "$GOT" == "$WHEEL_WANT" ]] || fail "sha256 mismatch for $WHEEL_FILE
+    expected $WHEEL_WANT
+    actual   $GOT
+  Nothing was installed."
+  # Move only after the hash passes: a partially-written wheel makes every `uv run` fail with a
+  # metadata error that names the cache, not the download.
+  mv "$STAGE/$WHEEL_FILE" "$WHEEL_DEST"
+  log "[wheel] installed -> $WHEEL_DEST"
+fi
+
+# --- verify the unpack ------------------------------------------------------------------------------
+log "verifying every artifact against the manifest"
+if verify_installed; then
+  log "done — $UNPACK_ROOT is fully provisioned. Next: make android-build"
+else
+  fail "the unpack did not produce every artifact the manifest declares (listed above).
+  This means the bundle and the manifest disagree — report it rather than working around it."
+fi
diff --git a/scripts/lib/java_home.sh b/scripts/lib/java_home.sh
new file mode 100644
index 0000000..a7219b9
--- /dev/null
+++ b/scripts/lib/java_home.sh
@@ -0,0 +1,50 @@
+# shellcheck shell=sh
+# Resolve JAVA_HOME to a JDK 17+ that Gradle 8.7 / AGP 8.5.1 can use. Sourced, not executed:
+#
+#   . "$(dirname "$0")/lib/java_home.sh"
+#
+# Resolution order — an explicit JAVA_HOME always wins, then a JDK 17+ on PATH, then Android Studio's
+# bundled JBR at its Linux default.
+#
+# The PATH probe exists because `/opt/android-studio/jbr` is a *Linux Android Studio* path: it is
+# correct on exactly one kind of machine and simply absent on macOS, on a CI runner, or under any
+# standalone JDK. Four scripts and the Makefile each hardcoded it as their only fallback, so on any
+# other machine Gradle failed with a Java-version error that named neither JAVA_HOME nor the script
+# that set it. Mirrors the identical probe in the Makefile; keep the two in step.
+#
+# On failure this sets nothing and prints what to do. It deliberately does NOT exit — the caller
+# decides whether a missing JDK is fatal (`make doctor` reports it and carries on).
+
+mt_resolve_java_home() {
+  mt_jh_candidate=""
+
+  if [ -n "${JAVA_HOME:-}" ] && [ -x "${JAVA_HOME}/bin/java" ]; then
+    return 0
+  fi
+
+  if command -v java >/dev/null 2>&1; then
+    if java -version 2>&1 | head -1 | grep -qE '"(1[7-9]|2[0-9])'; then
+      mt_jh_candidate="$(dirname "$(dirname "$(readlink -f "$(command -v java)")")")"
+    fi
+  fi
+
+  if [ -z "$mt_jh_candidate" ] && [ -x /opt/android-studio/jbr/bin/java ]; then
+    mt_jh_candidate=/opt/android-studio/jbr
+  fi
+
+  if [ -n "$mt_jh_candidate" ]; then
+    JAVA_HOME="$mt_jh_candidate"
+    export JAVA_HOME
+    return 0
+  fi
+
+  echo "JAVA_HOME is not set and no JDK 17+ was found." >&2
+  echo "  Gradle 8.7 / AGP 8.5.1 need JDK 17 or newer. Either:" >&2
+  echo "    export JAVA_HOME=/path/to/jdk17        # any JDK 17+" >&2
+  echo "    export JAVA_HOME=\"\$(/usr/libexec/java_home -v 17)\"   # macOS" >&2
+  echo "  Android Studio ships one; on Linux it is usually /opt/android-studio/jbr." >&2
+  echo "  Run 'make doctor' for the full prerequisite report." >&2
+  return 1
+}
+
+mt_resolve_java_home
diff --git a/scripts/publish_build_artifacts.py b/scripts/publish_build_artifacts.py
new file mode 100755
index 0000000..27c31f2
--- /dev/null
+++ b/scripts/publish_build_artifacts.py
@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Upload the gitignored build artifacts to the Hub, so a fresh clone can provision itself.
+
+    scripts/publish_build_artifacts.py --dry-run     # verify hashes, print the plan, upload nothing
+    scripts/publish_build_artifacts.py               # verify, then upload what is missing
+    scripts/publish_build_artifacts.py --force       # re-upload even if the remote already matches
+
+WHY THIS EXISTS. ~956 MB of prebuilt binaries and one source-built wheel cannot live in git, so a
+`git clone` produces a tree that cannot build the Android SDK at all. `scripts/fetch_native_deps.sh`
+is the consumer side of that problem and has been complete for a while; it was waiting on somewhere
+to fetch *from*. This is that somewhere.
+
+WHY A DATASET REPO. It needs to be reachable by `curl -fL` with no credentials and no CLI, because
+it sits before the first build on a machine that has nothing. An anonymous
+`https://huggingface.co/datasets/<id>/resolve/main/<file>` request answers 302-to-CDN then 200,
+which is exactly what the fetch script already follows. A Storage Bucket would be the more natural
+"pile of build outputs" home, but its documented access paths are the `hf` CLI, the Python API and
+an S3-compatible endpoint — none of which a bootstrap script should have to depend on.
+
+THE HASHES ARE CHECKED BEFORE UPLOAD, NOT AFTER. `third_party/android/manifest.json` and
+`third_party/onnxruntime/manifest.json` are what `fetch_native_deps.sh` verifies downloads against,
+so a file whose local bytes do not match its recorded hash would be published as a permanently
+broken download — every consumer would fail the checksum and no amount of retrying would help. The
+manifests are the contract; this refuses to publish anything that already violates it.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT / "src"))
+
+from mobiletransformers.config.settings import get_settings  # noqa: E402
+
+#: The dataset repo the manifest's `baseUrl` points at. Created by hand, deliberately: making a
+#: public repo is an outward-facing act and not something a script should do as a side effect.
+DEFAULT_REPO = "mobiletransformers/build-artifacts"
+
+ANDROID_MANIFEST = REPO_ROOT / "third_party" / "android" / "manifest.json"
+ORT_MANIFEST = REPO_ROOT / "third_party" / "onnxruntime" / "manifest.json"
+
+
+@dataclass(frozen=True)
+class Artifact:
+    """One file to publish, with the hash its own manifest already claims for it."""
+
+    path: Path
+    sha256: str
+    size: int
+    required: bool
+    note: str
+
+    @property
+    def name(self) -> str:
+        return self.path.name
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    import json
+
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def collect_artifacts() -> list[Artifact]:
+    """Everything to publish, read from the two manifests rather than hardcoded here.
+
+    Hardcoding the filenames would put a third copy of them in the tree, and the version is in each
+    name — so a 0.3.0 bundle would upload under a 0.2.0 name the day someone forgot this file.
+    """
+    android = _load_json(ANDROID_MANIFEST)
+    ort = _load_json(ORT_MANIFEST)
+
+    artifacts = [
+        Artifact(
+            path=REPO_ROOT / "build" / "dist" / bundle["filename"],
+            sha256=bundle["sha256"],
+            size=bundle["size"],
+            required=bundle["required"],
+            note=bundle["note"],
+        )
+        for bundle in android["bundles"]
+    ]
+
+    wheel = ort["wheel"]
+    artifacts.append(
+        Artifact(
+            path=REPO_ROOT / "third_party" / "wheels" / wheel["filename"],
+            sha256=wheel["sha256"],
+            size=int(wheel.get("size") or 0),
+            required=False,
+            note="Source-built ONNX Runtime Training wheel (cp312, linux_x86_64). Only an export "
+            "that produces a TRAINING stage needs it; inference-only exports and the whole "
+            "Android side do not.",
+        )
+    )
+    return artifacts
+
+
+def sha256_of(path: Path) -> str:
+    """Streamed, because one of these is 632 MB and `read_bytes()` would hold it all."""
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def verify(artifacts: list[Artifact]) -> tuple[list[Artifact], list[str]]:
+    """Split into (publishable, problems). A missing OPTIONAL artifact is not a problem."""
+    ready: list[Artifact] = []
+    problems: list[str] = []
+
+    for art in artifacts:
+        if not art.path.is_file():
+            message = f"{art.name}: not found at {art.path.relative_to(REPO_ROOT)}"
+            if art.required:
+                problems.append(message)
+            else:
+                print(f"  skip    {art.name} — not present locally (optional)")
+            continue
+
+        actual = sha256_of(art.path)
+        if actual != art.sha256:
+            problems.append(
+                f"{art.name}: sha256 mismatch\n"
+                f"           manifest {art.sha256}\n"
+                f"           actual   {actual}"
+            )
+            continue
+
+        print(f"  ok      {art.name} ({art.path.stat().st_size / 1e6:.0f} MB)")
+        ready.append(art)
+
+    return ready, problems
+
+
+DATASET_CARD = """\
+---
+license: other
+tags:
+  - build-artifacts
+  - not-a-dataset
+---
+
+# MobileTransformers — build artifacts
+
+**This is not a dataset.** It is the set of build inputs that cannot live in git, published here so
+that a `git clone` of
+[MobileTransformers](https://github.com/martinkorelic/mobiletransformers) can provision itself.
+
+Nothing here is downloaded by the Android app or by any model package. These files are consumed by
+one script, at development time:
+
+```bash
+scripts/fetch_native_deps.sh              # the natives bundle — required to build the Android SDK
+TRAINING=1 scripts/fetch_native_deps.sh   # + the ORT-training wheel, for exporting a training stage
+SYMBOLS=1  scripts/fetch_native_deps.sh   # + unstripped binaries, for symbolicating a native crash
+```
+
+That script reads `third_party/android/manifest.json`, downloads what is missing, checks the archive
+sha256, unpacks it, and then checks every unpacked file's sha256 individually. Both halves matter: the
+archive hash proves the download, the per-file hashes prove the unpack, and a half-populated
+`jniLibs/` is the failure mode that produces a linker error naming a symbol rather than a file.
+
+## Contents
+
+| file | size | needed for |
+| --- | --- | --- |
+| `mobiletransformers-natives-0.2.0-arm64-v8a.tar.zst` | 63 MB | **Required** to build the Android SDK: ONNX Runtime (training build), the GenAI engine, the tokenizer static libs, and vendored headers. |
+| `onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl` | 632 MB | Only to export a **training** stage. Source-built, cp312/linux_x86_64 only — it is not on PyPI. |
+| `mobiletransformers-natives-0.2.0-arm64-v8a-debug-symbols.tar.zst` | 261 MB | Optional. The unstripped originals of the shipped `.so` files. Android's build strips them at packaging, so these cost nothing at runtime and are the only way to read a native stack trace. |
+
+Every sha256, size, provenance and role is recorded in
+[`third_party/android/manifest.json`](https://github.com/martinkorelic/mobiletransformers/blob/main/third_party/android/manifest.json)
+and
+[`third_party/onnxruntime/manifest.json`](https://github.com/martinkorelic/mobiletransformers/blob/main/third_party/onnxruntime/manifest.json).
+Verify by hand with `sha256sum` if you prefer; the fetch script does it for you either way.
+
+## Licensing
+
+These are builds of third-party projects — ONNX Runtime, onnxruntime-genai, tokenizers-cpp, protobuf
+— each under its own upstream licence. See
+[`THIRD_PARTY_NOTICES.md`](https://github.com/martinkorelic/mobiletransformers/blob/main/THIRD_PARTY_NOTICES.md).
+The `license: other` tag above reflects that this repo is a mixed bundle of upstream artifacts rather
+than a single licensed work.
+
+## arm64-v8a only
+
+There is no x86_64 build, so the SDK does not run on a standard Android emulator. `libonnxruntime.so`
+and the tokenizer archives were never built for it; restoring x86_64 means building ONNX Runtime
+Training and tokenizers-cpp for that ABI first.
+"""
+
+
+def main(argv: list[str] | None = None, *, uploader: Callable[..., Any] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--repo", default=DEFAULT_REPO, help=f"dataset repo id (default: {DEFAULT_REPO})")
+    parser.add_argument("--dry-run", action="store_true", help="verify and print the plan; upload nothing")
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="upload every artifact even if the remote already has a file of that name",
+    )
+    parser.add_argument("--skip-card", action="store_true", help="do not write the dataset card")
+    args = parser.parse_args(argv)
+
+    print(f"verifying local artifacts against the manifests ({ANDROID_MANIFEST.name}, {ORT_MANIFEST.name})")
+    ready, problems = verify(collect_artifacts())
+
+    if problems:
+        print("\nrefusing to publish:\n  " + "\n  ".join(problems), file=sys.stderr)
+        print(
+            "\nA file whose bytes do not match its manifest hash would be published as a "
+            "permanently broken download — every consumer fails the checksum and retrying cannot "
+            "help. Fix the file or the manifest before publishing.",
+            file=sys.stderr,
+        )
+        return 1
+    if not ready:
+        print("nothing to publish", file=sys.stderr)
+        return 1
+
+    total = sum(a.path.stat().st_size for a in ready)
+    print(f"\n{len(ready)} artifact(s), {total / 1e6:.0f} MB total -> {args.repo}")
+
+    if args.dry_run:
+        for art in ready:
+            print(f"  [dry-run] would upload {art.name}")
+        print("[dry-run] nothing was uploaded")
+        return 0
+
+    # Explicit token, and the ORG one. `huggingface_hub` falls back to $HF_TOKEN and then to the
+    # cached CLI login, so an org upload with no token argument can authenticate as the wrong
+    # identity and look exactly like success.
+    token = get_settings().require_org_token()
+
+    if uploader is None:
+        from huggingface_hub import create_repo, upload_file
+
+        # The repo is expected to exist (it is created by hand — see DEFAULT_REPO). exist_ok makes
+        # a re-run a no-op rather than an error, and covers a fresh org bootstrapping itself.
+        create_repo(args.repo, repo_type="dataset", exist_ok=True, token=token)
+        uploader = upload_file
+
+    if not args.skip_card:
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmp:
+            card = Path(tmp) / "README.md"
+            card.write_text(DATASET_CARD, encoding="utf-8")
+            uploader(
+                path_or_fileobj=str(card),
+                path_in_repo="README.md",
+                repo_id=args.repo,
+                repo_type="dataset",
+                token=token,
+                commit_message="Describe what these artifacts are and who consumes them",
+            )
+        print("  uploaded README.md (dataset card)")
+
+    for art in ready:
+        print(f"  uploading {art.name} ({art.path.stat().st_size / 1e6:.0f} MB)…", flush=True)
+        uploader(
+            path_or_fileobj=str(art.path),
+            path_in_repo=art.name,
+            repo_id=args.repo,
+            repo_type="dataset",
+            token=token,
+            commit_message=f"Add {art.name}",
+        )
+        print(f"  uploaded  {art.name}")
+
+    print(f"\npublished to https://huggingface.co/datasets/{args.repo}")
+    print("Set `baseUrl` in third_party/android/manifest.json to:")
+    print(f"  https://huggingface.co/datasets/{args.repo}/resolve/main")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/publish_catalog.sh b/scripts/publish_catalog.sh
new file mode 100755
index 0000000..f22580d
--- /dev/null
+++ b/scripts/publish_catalog.sh
@@ -0,0 +1,179 @@
+#!/usr/bin/env bash
+# Export, verify and publish the catalog of models the showcase app offers.
+#
+#   scripts/publish_catalog.sh                 # all entries: export + verify + push
+#   ONLY=smollm2 scripts/publish_catalog.sh    # one entry
+#   PUSH=0 scripts/publish_catalog.sh          # export + verify, publish nothing
+#   KEEP=1 scripts/publish_catalog.sh          # do not re-export an entry whose package already exists
+#
+# Every entry ships BOTH an inference and a training stage: fine-tuning on device is the point of the
+# project, and a shelf entry that cannot be trained demonstrates half of it.
+#
+# Two things here are not obvious and are the reason this is a script rather than a list of commands:
+#
+# 1. THE TWO-PROFILE DANCE. The inference export needs the `export` extra; the training stage needs the
+#    source-built `ort-training-local` wheel. They collide on the `onnxruntime` import and must never
+#    co-install. `uv run --group ort-training-local` alone does NOT displace the stock onnxruntime the
+#    export profile just installed — the training wheel provides a distribution of the same name, so
+#    the resolver considers the requirement satisfied, and the training import then dies with
+#    `ImportError: cannot import name 'PropagateCastOpsStrategy'`. An explicit `uv sync
+#    --reinstall-package` followed by `uv run --no-sync` is what actually works.
+#
+# 2. TASK AND ENGINE FLAGS ARE PER-MODEL, and getting them wrong fails late or, worse, silently:
+#    - `--task text-classification` is what makes an ENCODER trainable at all. `TaskSpec.default_stages`
+#      emits a train/ stage exactly when the task is `trainable`, and FEATURE_EXTRACTION is declared
+#      trainable=False — so exporting an encoder the "natural" way yields an inference-only package.
+#      Task auto-selection never picks text-classification.
+#    - `--genai` is DECODER-only. A classification/feature-extraction graph has no KV cache, and the
+#      export refuses to write a genai_config.json describing a cache the graph does not have.
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+PUSH="${PUSH:-1}"
+ONLY="${ONLY:-}"
+KEEP="${KEEP:-0}"
+ORG="${ORG:-mobiletransformers}"
+OUT_ROOT="${OUT_ROOT:-build/catalog}"
+
+# key | base model | repo name | task ("" = auto) | rag (1/0) | genai (1/0) | peft ("" = lora)
+#
+# Keep this table in sync with the app's assets/model_catalog.json — the app claims sizes and features
+# per entry, and a catalog that disagrees with what was pushed is worse than no catalog.
+#
+# The PEFT column is what the package is EXPORTED with, and it is a property of the package rather
+# than a runtime choice: the topology is baked into the training graph, so a device can only select
+# what the export built. Shipping one MARS package is the point — MARS (Multi-Adapter Rank Sharing) is
+# this project's own method, and a shelf of nothing but LoRA never demonstrates it.
+ENTRIES=(
+  "smollm2|HuggingFaceTB/SmolLM2-135M-Instruct|SmolLM2-135M-Instruct||1|1|"
+  "qwen25|Qwen/Qwen2.5-0.5B-Instruct|Qwen2.5-0.5B-Instruct||1|1|"
+  "minilm|sentence-transformers/all-MiniLM-L6-v2|all-MiniLM-L6-v2|text-classification|1|0|"
+  "distilbert|distilbert-base-uncased-finetuned-sst-2-english|distilbert-sst2-english|text-classification|0|0|"
+  # Gemma-3 270M with MARS. `--genai` is off: Gemma-3 exports through optimum rather than the GenAI
+  # builder, so the package declares native only and asking for genai fails closed at load.
+  "gemma3|google/gemma-3-270m-it|gemma-3-270m-it||0|0|mars"
+)
+
+log() { printf '\n\033[1m>> %s\033[0m\n' "$*"; }
+fail() { printf '\n\033[31m!! %s\033[0m\n' "$*" >&2; exit 1; }
+
+# The token is read the same way `mobiletransformers push` reads it, so an org push cannot silently
+# authenticate as a different identity than the one this script reports.
+#
+# HF_TOKEN_ORG is preferred over HF_TOKEN and the distinction is load-bearing, not cosmetic: HF_TOKEN
+# is fine-grained and scoped to `functiongemma-270m-it` alone, so every other repo in this table came
+# back as RepositoryNotFoundError — which the Hub returns identically for "does not exist" and "you
+# cannot see it", and which therefore reads as a typo rather than as a permissions problem.
+# HF_TOKEN_ORG carries `repo.write` on the whole `mobiletransformers` org. The fallback to HF_TOKEN
+# stays so a single-repo push still works for whoever only has that one.
+# Sourced UNCONDITIONALLY, not just when pushing. The export needs a token as much as the upload
+# does: a gated base model (google/gemma-3-270m-it) fails its very first config read without one, and
+# `huggingface_hub` falls back to $HF_TOKEN silently, so the difference between "sourced" and "not
+# sourced" is invisible until the fetch 401s. When this was inside the PUSH=1 branch, running with
+# PUSH=0 to test an export was exactly the case that had no credentials.
+[[ -f .env ]] && { set -a; . ./.env; set +a; }
+
+if [[ "$PUSH" == "1" ]]; then
+  PUSH_TOKEN="${HF_TOKEN_ORG:-${HF_TOKEN:-}}"
+  [[ -n "$PUSH_TOKEN" ]] || fail "PUSH=1 but no HF_TOKEN_ORG or HF_TOKEN (put one in .env, or run with PUSH=0)"
+  [[ -n "${HF_TOKEN_ORG:-}" ]] || log "no HF_TOKEN_ORG — falling back to HF_TOKEN, which may not reach every repo"
+fi
+
+for entry in "${ENTRIES[@]}"; do
+  IFS='|' read -r KEY MODEL REPO TASK RAG GENAI PEFT <<<"$entry"
+  [[ -n "$ONLY" && "$ONLY" != "$KEY" ]] && continue
+
+  PKG="$OUT_ROOT/$KEY"
+  log "[$KEY] $MODEL -> $ORG/$REPO"
+
+  if [[ "$KEEP" == "1" && -f "$PKG/mobiletransformers_manifest.json" ]]; then
+    log "[$KEY] KEEP=1 and a package already exists — skipping the export"
+  else
+    rm -rf "$PKG"
+
+    TASK_ARGS=(); [[ -n "$TASK" ]] && TASK_ARGS=(--task "$TASK")
+    PEFT_ARGS=(); [[ -n "$PEFT" ]] && PEFT_ARGS=(--peft "$PEFT")
+    RAG_ARGS=();  [[ "$RAG" == "1" ]] && RAG_ARGS=(--include-rag --embedding-model sentence-transformers/all-MiniLM-L6-v2)
+    GENAI_ARGS=(); [[ "$GENAI" == "1" ]] && GENAI_ARGS=(--genai)
+
+    log "[$KEY] 1/3 inference export (export profile)"
+    uv run --extra export --python 3.12 mobiletransformers export \
+      --model "$MODEL" --output "$PKG" --validate \
+      "${TASK_ARGS[@]}" "${RAG_ARGS[@]}" "${GENAI_ARGS[@]}" "${PEFT_ARGS[@]}"
+
+    log "[$KEY] 2/3 training stage (ort-training-local profile)"
+    # See note 1 in the header: the explicit sync is load-bearing, not belt-and-braces.
+    uv sync --python 3.12 --group ort-training-local --no-default-groups \
+      --reinstall-package onnxruntime-training
+    uv run --no-sync --python 3.12 mobiletransformers export \
+      --model "$MODEL" --output "$PKG" --stages training "${TASK_ARGS[@]}" "${PEFT_ARGS[@]}"
+  fi
+
+  log "[$KEY] 3/3 verify"
+  # Re-validate after the training stage: step 2 rewrites the manifest, and a package that validated
+  # before the train/ stage was added says nothing about the one that will actually be pushed.
+  uv run --group dev --python 3.10 mobiletransformers validate --package "$PKG"
+
+  uv run --group dev --python 3.10 python - "$PKG" "${PEFT:-lora}" <<'PY'
+import json, sys
+from pathlib import Path
+
+pkg = Path(sys.argv[1])
+manifest = json.loads((pkg / "mobiletransformers_manifest.json").read_text())
+features = {f for v in manifest.get("variants", []) for f in v.get("features", [])}
+
+# The user's requirement, asserted rather than assumed: every published entry must be trainable.
+if "train" not in features:
+    raise SystemExit(
+        f"{pkg}: no `train` group (features={sorted(features)}). An encoder needs an explicit "
+        "--task text-classification: FEATURE_EXTRACTION is declared trainable=False, so the export "
+        "emits no training stage and the package cannot be fine-tuned on device."
+    )
+if not (pkg / "variants").glob("*/train/training_config.json"):
+    raise SystemExit(f"{pkg}: the train group is declared but training_config.json is missing")
+
+# The PEFT method the table ASKED for must be the one the package DECLARES. Without this a silently
+# ignored `--peft` — a flag not threaded through one of the two export legs, say — would publish a
+# LoRA package under a MARS label, and nothing downstream could tell: the app reads `peftMethods`
+# from this manifest and would faithfully render the wrong badge.
+requested = sys.argv[2]
+declared = manifest.get("peftMethods") or []
+if requested not in declared:
+    raise SystemExit(
+        f"{pkg}: exported with --peft {requested!r} but the manifest declares peftMethods="
+        f"{declared}. The flag did not reach the export, or reached only one of its two stages."
+    )
+
+size_mb = sum(manifest.get("fileSizes", {}).values()) / 1e6
+inference_mb = sum(
+    s for name, s in manifest.get("fileSizes", {}).items() if "/inference/" in name or "/tokenizer" in name
+) / 1e6
+print(f"    base            {manifest.get('baseModelId')}")
+print(f"    task            {manifest.get('selectedTask')}")
+print(f"    peft            {manifest.get('peftMethods')}")
+print(f"    features        {sorted(features)}")
+print(f"    total           {size_mb:.0f} MB")
+print(f"    inference group {inference_mb:.0f} MB   <- approxSizeMb for the app catalog")
+PY
+
+  if [[ "$PUSH" == "1" ]]; then
+    log "[$KEY] push -> $ORG/$REPO"
+    # No --create: the repos are expected to exist. A mistyped id must fail rather than quietly make
+    # a stray repo under the organisation.
+    #
+    # The token goes through the ENVIRONMENT, not `--token`. A command-line argument is world-readable
+    # in /proc/<pid>/cmdline for the life of the process, so `ps` on a shared machine prints the
+    # credential in full — observed during the 2026-08-17 publish run. `push` resolves $HF_TOKEN
+    # through `config.settings`, the one sanctioned credential-read site, so this is the same code
+    # path with one fewer place for the secret to leak.
+    HF_TOKEN="$PUSH_TOKEN" uv run --group dev --python 3.10 mobiletransformers push \
+      --package "$PKG" --repo "$ORG/$REPO"
+  else
+    log "[$KEY] PUSH=0 — rendering the card only"
+    uv run --group dev --python 3.10 mobiletransformers push \
+      --package "$PKG" --repo "$ORG/$REPO" --dry-run
+  fi
+done
+
+log "done. Reset the profile before running the host suite: uv sync --frozen --group dev --python 3.10"
diff --git a/scripts/publish_local_maven.sh b/scripts/publish_local_maven.sh
new file mode 100755
index 0000000..8577b93
--- /dev/null
+++ b/scripts/publish_local_maven.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Publish the :MobileTransformers SDK to the local Maven repository (~/.m2) (#30).
+#
+#   scripts/publish_local_maven.sh [-Pversion=<x>]
+#
+# Publishes com.martinkorelic.mobiletransformers:mobiletransformers-android:<version> — AAR, sources
+# jar and POM — so `examples/consumer-app` (or any external project with mavenLocal()) can resolve it.
+set -euo pipefail
+
+GRADLE_ROOT="android/MobileTransformers"
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib/java_home.sh"
+
+# Same ABI caveat as android_build_aar.sh: pass -Pandroid.injected.build.abi=<abi> when the
+# vendored libraries are only complete for one ABI.
+echo "==> publishing to mavenLocal"
+(cd "${GRADLE_ROOT}" && ./gradlew :MobileTransformers:publishToMavenLocal "$@")
+
+COORD_DIR="${HOME}/.m2/repository/com/martinkorelic/mobiletransformers/mobiletransformers-android"
+if [ ! -d "${COORD_DIR}" ]; then
+  echo "error: publish reported success but ${COORD_DIR} does not exist." >&2
+  exit 1
+fi
+
+echo "==> published:"
+find "${COORD_DIR}" -type f \( -name '*.aar' -o -name '*.pom' -o -name '*-sources.jar' \) \
+  -printf '    %p\n' | sort
diff --git a/spikes/genai_external_swap/README.md b/spikes/genai_external_swap/README.md
new file mode 100644
index 0000000..ee3ebd0
--- /dev/null
+++ b/spikes/genai_external_swap/README.md
@@ -0,0 +1,135 @@
+# GenAI External-Data-Swap Spike (#10 · Gate 0.1)
+
+Validates finding **F2**: ONNX Runtime GenAI can consume on-device-merged weights **with no graph rewrite
+and no fork**, just by reading the same external-data folder — proving GenAI can be a *selectable engine*
+over the unified package (or, on failure, that we keep the manual loop for v1).
+
+The decisive mechanism is the stable **`OgaCreateModel(<dir>)`** + external-data file resolution. We
+deliberately avoid `OgaCreateModelWithInitializers` (fork-only) and the `model_input`/`SetModelInput`
+rewrite path.
+
+## Artifacts
+
+| File | What |
+| --- | --- |
+| `check_symbols.sh` | Gate 0.1 #6/#8 — asserts `OgaCreateModelWithInitializers` ABSENT + `OgaCreateModel` PRESENT in the linked Android `.so`. |
+| `desktop_spike.py` | Gate 0.1 #2/#3 — base-vs-swapped logits differ on a fresh `og.Model(dir)`. |
+| `measure_rss.py` | Gate 0.1 #7 — RSS sampler (mmap-vs-copy). |
+| `build_tiny_genai_model.sh` | Builds a tiny real GenAI model (SmolLM2-135M int4) in a standalone venv for the smokes. |
+| `android/.../cpp/genai_spike.cpp` | JNI: `OgaCreateModel` → one token → logits fingerprint + RSS. |
+| `android/.../GenAISpike.kt` + `androidTest/.../GenAISpikeTest.kt` | Device leg — external-data resolution + swap smoke. |
+
+## Results so far (host, this machine — Linux + arm64 device SM-G990B)
+
+- **Symbol check: PASS.** `OgaCreateModelWithInitializers` absent (fork-only confirmed); `OgaCreateModel`
+  present; 23 `OgaGenerator*` symbols. Run: `./check_symbols.sh`.
+- **Build + link: PASS.** `genai_spike.cpp` compiles against the real 0.14 AAR headers and
+  `libmobiletransformers.so` links against the real `libonnxruntime-genai.so` on arm64; the instrumented
+  `androidTest` APK assembles. The JNI symbol `Java_..._GenAISpike_runOneToken` is exported.
+  - Setup done: the real `onnxruntime-genai-android-0.14.0.aar` is installed at
+    `aarLibs/onnxruntime-genai.aar` (was a 1.3 MB stub) and the real `.so` copied into `jniLibs/{arm64-v8a,
+    x86_64}` (was a stale 3 MB build missing the 0.14 generator symbols). Vendored fork header
+    `cpp/onnxruntime-genai/ort_genai_c.h` replaced with the AAR's clean upstream header. A `packaging {
+    jniLibs { pickFirsts } }` dedupe resolves the AAR-vs-jniLibs `.so` collision. The dead
+    `ORTGenAITokenizer.kt` (old genai Java API) was reduced to a compiling stub (DECOMPOSE(#11)),
+    and **deleted outright 2026-08-14** together with its unused `LLMRepository` field.
+
+## How to run the swap smokes
+
+### 1. Build a tiny GenAI model (host, one-time)
+```bash
+./spikes/genai_external_swap/build_tiny_genai_model.sh
+# -> build/genai_spike_model/ with model.onnx + model.onnx.data + genai_config.json + tokenizer
+```
+
+### 2. Desktop swap smoke (Gate 0.1 #2/#3)
+```bash
+source .venv-genai-spike/bin/activate   # the venv the build script created
+python spikes/genai_external_swap/desktop_spike.py --dir build/genai_spike_model
+# PASS = base vs swapped logits differ on a fresh og.Model()
+```
+
+### 3. Device swap smoke (Gate 0.1 #2/#3/#5) — the key Android unknown
+Push the model into the **test app's** external files dir, then run the instrumented test on the device:
+```bash
+# the test app package is com.martinkorelic.mobiletransformers.test
+DEST=/sdcard/Android/data/com.martinkorelic.mobiletransformers.test/files/mt_genai_spike/inference
+adb shell mkdir -p "$DEST"
+adb push build/genai_spike_model/. "$DEST"
+
+cd android/MobileTransformers
+JAVA_HOME=/opt/android-studio/jbr ./gradlew :MobileTransformers:connectedDebugAndroidTest \
+  -Pandroid.testInstrumentationRunnerArguments.class=com.martinkorelic.mobiletransformers.GenAISpikeTest
+```
+The test **skips** (with the expected path) if no model is pushed, so it never hard-fails. When the model is
+present it asserts: `OgaCreateModel` resolves the relative external data (a token generates) **and** the
+logits fingerprint changes after one external weight is overwritten (swap observed).
+
+Watch `adb logcat -s GenAISpike` for the per-run `token / fp / rss pre|loaded|tok` line.
+
+## Gate 0.1 checklist status (verified on this machine + device SM-G990B, arm64)
+
+| # | Criterion | Status |
+| --- | --- | --- |
+| 6 | `OgaCreateModelWithInitializers` fork-only & not required | ✅ **PASS** (symbol check, device `.so`) |
+| 2 | External weight overwrite changes GenAI output on fresh `OgaCreateModel` | ✅ **PASS** — desktop `|ΔL|=39.6`; **device** token 28→6156, fp 1.518e8→9.82e7 |
+| 3 | Trainable externals not constant-folded (swap observable) | ✅ **PASS** — implied by #2 (desktop + device) |
+| 5 | GenAI Android resolves relative external data in the package dir | ✅ **PASS (device)** — `OgaCreateModel` loaded + generated |
+| 7 | Memory: mmap vs copy | ✅ measured — desktop 199 MB blob → RSS +144 MB; device load +102 MB (mmap/lazy, not 2×) |
+| 4 | GenAI peak RSS within threshold of Native (device) | ⏳ needs a File #9 package to run Native side too |
+| 1 | Same package correct under BOTH engines (device) | ⏳ needs a real File #9 package (per-tensor externals) |
+
+### The device blocker — and how it was RESOLVED (ORT engine separation)
+
+**Diagnosis.** The genai `0.14.0` AAR bundles **only `libonnxruntime-genai.so`, no `libonnxruntime.so`** —
+GenAI `dlopen`s whatever `libonnxruntime.so` the app ships. This app ships the **source-built ORT-*training***
+`libonnxruntime.so` (ORT **1.23**), but **genai 0.14 requires stock ORT ≥ 1.26** (`onnxruntime-genai`'s pip
+metadata: `onnxruntime>=1.26.0`; desktop worked with 1.27.0). So `OgaCreateModel` aborted (SIGABRT) on model
+load. The external-data mechanism itself was never the problem (proven on desktop). The real issue was
+**two different ORTs** — training 1.23 (with the training C++ API the Native engine needs) vs stock 1.27
+(genai-paired inference) — that must coexist in one process but share SONAME `libonnxruntime.so`.
+
+**Resolution — implemented and verified on device.** Give GenAI its own stock ORT under a distinct name so
+the two never collide (reproducible via `setup_ort_separation.sh`):
+
+| Consumer | Library | Notes |
+| --- | --- | --- |
+| Native / training engine (`libmobiletransformers.so`) | `jniLibs/<abi>/libonnxruntime.so` | the source-built ORT-training 1.23 (unchanged; linked as `-lonnxruntime`) |
+| GenAI engine | `jniLibs/<abi>/libort_gen.so` | stock ORT **1.27**; SONAME **raw-patched** `libonnxruntime.so`→`libort_gen.so` (no `patchelf` — it corrupts `verneed`; a length-preserving in-place byte edit keeps all offsets) |
+| GenAI dispatcher | `jniLibs/<abi>/libonnxruntime-genai.so` | `dlopen` target **raw-patched** `libonnxruntime.so`→`libort_gen.so` (and the `.so.1` fallback) |
+
+Why it's safe: each ORT **exports only ~3 symbols** (hidden visibility — `OrtGetApiBase` + two EP appenders),
+and genai resolves ORT via `dlsym` on **its own `dlopen` handle**, so there is **no symbol interposition**
+between the two ORTs. The distinct SONAME is essential — with the same soname the linker dedups and hands
+genai the already-loaded training lib back (this exact failure was observed). The genai AAR is **not** a
+Gradle dependency (its Java classes are unused on the C-API/JNI path), so only the patched `.so` ships.
+
+**Verified on device (SM-G990B, arm64):** `GenAISpikeTest` passes — `libmobiletransformers.so` loads with the
+**training** ORT 1.23 present, GenAI `OgaCreateModel` loads the model via the **stock** ORT 1.27
+(`libort_gen.so`), generates a token (relative external data resolved), and overwriting one external weight
+changes the output on a fresh model. **Both engines' ORTs coexist in one process.** This closes the F2 /
+Gate 0.1 GenAI-side question and hands #11 a working engine-coexistence design.
+
+### Running the device test
+1. Build a model (`build_tiny_genai_model.sh` → `build/genai_spike_model`) and set up separation
+   (`setup_ort_separation.sh`).
+2. `installDebugAndroidTest -Pandroid.injected.build.abi=arm64-v8a`.
+3. Stage the model where the app process reads it — the app's **internal** files dir is most reliable:
+   ```bash
+   adb shell mkdir -p /data/local/tmp/mt_genai_spike/inference
+   adb push build/genai_spike_model/. /data/local/tmp/mt_genai_spike/inference/
+   PKG=com.martinkorelic.mobiletransformers.test
+   adb shell run-as $PKG mkdir -p files/mt_genai_spike/inference
+   for f in genai_config.json model.onnx model.onnx.data tokenizer.json tokenizer_config.json chat_template.jinja; do
+     adb shell "run-as $PKG sh -c 'cp /data/local/tmp/mt_genai_spike/inference/$f files/mt_genai_spike/inference/$f'"; done
+   ```
+   (The test tries `filesDir`, `/data/local/tmp`, then the external files dir, and *skips* if none has a
+   `genai_config.json`. The internal `filesDir` copy survives `install -r`.)
+4. `adb shell am instrument -w -e class com.martinkorelic.mobiletransformers.GenAISpikeTest \
+   com.martinkorelic.mobiletransformers.test/androidx.test.runner.AndroidJUnitRunner` · watch
+   `adb logcat -s GenAISpike`. Cleanup: `adb shell rm -rf /data/local/tmp/mt_genai_spike`.
+
+**Note on #1/#4 (cross-engine):** the builder model is single-blob GenAI format — enough to prove the
+GenAI-side items. Full cross-engine equivalence (#1/#4) also needs a real File #9 package (per-tensor
+externals + `weight_handoff_map.json` consumable by BOTH `ORTGeneratorNative` and GenAI). `desktop_spike.py`
+and `GenAISpikeTest.kt` already handle both layouts.
diff --git a/spikes/genai_external_swap/build_tiny_genai_model.sh b/spikes/genai_external_swap/build_tiny_genai_model.sh
new file mode 100755
index 0000000..0491966
--- /dev/null
+++ b/spikes/genai_external_swap/build_tiny_genai_model.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Build a tiny GenAI-loadable model for the #10 spike (a real small decoder LM in ONNX Runtime GenAI
+# format: model.onnx + model.onnx.data + genai_config.json + tokenizer). Standalone venv so it does NOT
+# touch the uv-managed profiles. Output feeds desktop_spike.py and the device GenAISpikeTest.
+#
+#   ./build_tiny_genai_model.sh [out_dir] [hf_model_id] [precision]
+#
+# Defaults: out=build/genai_spike_model, model=HuggingFaceTB/SmolLM2-135M-Instruct, precision=int4, cpu.
+set -euo pipefail
+
+OUT="${1:-build/genai_spike_model}"
+MODEL="${2:-HuggingFaceTB/SmolLM2-135M-Instruct}"
+PREC="${3:-int4}"
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+VENV="${VENV:-$REPO_ROOT/.venv-genai-spike}"
+
+cd "$REPO_ROOT"
+if [[ ! -d "$VENV" ]]; then
+  python3.12 -m venv "$VENV"
+fi
+# shellcheck disable=SC1091
+source "$VENV/bin/activate"
+python -m pip install --quiet --upgrade pip
+# CPU torch + the genai model builder deps. onnxruntime-genai>=0.14 matches the device AAR.
+python -m pip install --quiet \
+  "onnxruntime-genai>=0.14" "onnxruntime>=1.20" "torch>=2.2" "transformers>=4.45" "onnx" \
+  "onnx_ir" "onnxscript" "huggingface-hub>=0.24"
+
+mkdir -p "$OUT"
+CACHE="$REPO_ROOT/build/genai_spike_cache"
+mkdir -p "$CACHE"
+echo ">> building $MODEL ($PREC, cpu) -> $OUT"
+python -m onnxruntime_genai.models.builder -m "$MODEL" -o "$OUT" -p "$PREC" -e cpu -c "$CACHE"
+
+echo ">> done. GenAI package contents:"
+ls -la "$OUT"
+echo ">> genai_config.json present: $([[ -f "$OUT/genai_config.json" ]] && echo yes || echo NO)"
diff --git a/spikes/genai_external_swap/check_symbols.sh b/spikes/genai_external_swap/check_symbols.sh
new file mode 100755
index 0000000..046aec9
--- /dev/null
+++ b/spikes/genai_external_swap/check_symbols.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Gate 0.1 symbol check (#10): confirm OgaCreateModelWithInitializers is fork-only (ABSENT) and the stable
+# OgaCreateModel is PRESENT in the *linked Android* onnxruntime-genai .so. Runs against the bundled AAR.
+#
+#   ./check_symbols.sh [path/to/onnxruntime-genai.aar]
+#
+# Defaults to the vendored aarLibs AAR. Exit 0 = PASS (fork-only confirmed), non-zero = FAIL.
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+AAR="${1:-$REPO_ROOT/android/MobileTransformers/MobileTransformers/src/main/aarLibs/onnxruntime-genai.aar}"
+ABI="${ABI:-arm64-v8a}"
+
+if [[ ! -f "$AAR" ]]; then
+  echo "FAIL: AAR not found at $AAR" >&2
+  exit 2
+fi
+
+# Find an nm that reads ELF: prefer the NDK's llvm-nm, then any llvm-nm, then system nm.
+NM="$(command -v llvm-nm || ls "$HOME"/Android/Sdk/ndk/*/toolchains/llvm/prebuilt/*/bin/llvm-nm 2>/dev/null | head -1 || command -v nm || true)"
+if [[ -z "$NM" ]]; then
+  echo "FAIL: no nm/llvm-nm available" >&2
+  exit 2
+fi
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+unzip -q "$AAR" "jni/$ABI/libonnxruntime-genai.so" -d "$WORK"
+SO="$WORK/jni/$ABI/libonnxruntime-genai.so"
+
+echo "AAR: $AAR"
+echo "ABI: $ABI   nm: $NM"
+echo "so:  $(du -h "$SO" | cut -f1)"
+
+with_init="$("$NM" -D --defined-only "$SO" 2>/dev/null | grep -c 'OgaCreateModelWithInitializers' || true)"
+create_model="$("$NM" -D --defined-only "$SO" 2>/dev/null | grep -c 'OgaCreateModel$' || true)"
+generators="$("$NM" -D --defined-only "$SO" 2>/dev/null | grep -c 'OgaGenerator' || true)"
+
+echo "OgaCreateModelWithInitializers : $with_init  (expect 0 -> fork-only)"
+echo "OgaCreateModel                 : $create_model  (expect >=1 -> stable API)"
+echo "OgaGenerator*                  : $generators  (expect >=1)"
+
+fail=0
+[[ "$with_init" -eq 0 ]] || { echo "FAIL: OgaCreateModelWithInitializers is present (not fork-only)" >&2; fail=1; }
+[[ "$create_model" -ge 1 ]] || { echo "FAIL: OgaCreateModel missing (stable API absent)" >&2; fail=1; }
+[[ "$generators" -ge 1 ]] || { echo "FAIL: no OgaGenerator symbols" >&2; fail=1; }
+
+if [[ "$fail" -eq 0 ]]; then
+  echo "PASS: OgaCreateModelWithInitializers is fork-only (absent); OgaCreateModel present."
+fi
+exit "$fail"
diff --git a/spikes/genai_external_swap/desktop_spike.py b/spikes/genai_external_swap/desktop_spike.py
new file mode 100644
index 0000000..4e62572
--- /dev/null
+++ b/spikes/genai_external_swap/desktop_spike.py
@@ -0,0 +1,127 @@
+"""Desktop GenAI external-data-swap spike (#10, Gate 0.1 steps 2-7).
+
+Proves finding F2 on the desktop before the device port: overwriting the external weight bytes changes
+GenAI's generated logits, and a **fresh** ``OgaCreateModel`` picks up the new bytes (no graph rewrite, no
+fork). Works on either layout:
+
+- a File #9 per-tensor package (``weight_handoff_map.json`` + per-tensor ``<name>.bin``): perturbs exactly
+  one trainable ``.bin`` (never ``frozen_base.onnx.data``), refreshing its ``.sha256``;
+- a builder-produced single-blob model (``model.onnx.data``): perturbs a byte range in the blob.
+
+Run under the genai profile (Python >=3.11):
+    uv run --python 3.12 --group genai-smoke python spikes/genai_external_swap/desktop_spike.py --dir <inference_dir>
+
+Exit 0 = swap observed (logits differ); non-zero = no effect (folded/copied) or load failure.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import sys
+from pathlib import Path
+
+import numpy as np
+
+from spikes.genai_external_swap.measure_rss import RssTrace
+
+
+def _first_logits(model_dir: str, prompt: str, trace: RssTrace | None = None) -> np.ndarray:
+    """One greedy token from a FRESH model (GenAI caches externals at construction — no reuse)."""
+    import onnxruntime_genai as og  # noqa: PLC0415
+
+    if trace:
+        trace.mark("pre-load")
+    model = og.Model(model_dir)
+    if trace:
+        trace.mark("post-Model")
+    tok = og.Tokenizer(model)
+    params = og.GeneratorParams(model)
+    ids = tok.encode(prompt)
+    params.set_search_options(do_sample=False, max_length=len(ids) + 1)
+    gen = og.Generator(model, params)
+    gen.append_tokens(ids)
+    gen.generate_next_token()
+    logits = np.array(gen.get_output("logits"))[0, -1, :]
+    if trace:
+        trace.mark("post-first-token")
+    return logits
+
+
+def _perturb_target(inf_dir: Path) -> Path:
+    """Choose the external file to perturb and return its path (backing it up first)."""
+    handoff = inf_dir / "weight_handoff_map.json"
+    if handoff.is_file():
+        hmap = json.loads(handoff.read_text())
+        loc = hmap["entries"][0]["externalDataLocation"]
+        rel = loc.get("weight") or next(iter(loc.values()))
+        return inf_dir / rel
+    # builder single-blob layout: perturb the largest *.data / *.bin that is not the frozen base blob.
+    candidates = [
+        p
+        for p in inf_dir.iterdir()
+        if p.suffix in (".data", ".bin") and p.name != "frozen_base.onnx.data"
+    ]
+    if not candidates:
+        raise SystemExit(f"no external weight file to perturb in {inf_dir}")
+    return max(candidates, key=lambda p: p.stat().st_size)
+
+
+def _apply_delta(path: Path) -> None:
+    """Simulate a merge delta: scale a wide contiguous float32 region by 1.5 so on-path weights change
+    measurably (a 64-byte low-mantissa XOR is too weak — it can land entirely in unused embedding rows).
+    Deterministic; NaN/Inf clamped. Refreshes a sibling .sha256 if present."""
+    buf = bytearray(path.read_bytes())
+    n = len(buf)
+    start = (n // 10) * 3  # 30% in — past most of the embedding table, into transformer weights
+    span = min(8 * 1024 * 1024, n - start)
+    span -= span % 4
+    if span > 0:
+        region = np.frombuffer(bytes(buf[start : start + span]), dtype="<f4").copy()
+        region = np.nan_to_num(region * np.float32(1.5), posinf=1e4, neginf=-1e4).astype("<f4")
+        buf[start : start + span] = region.tobytes()
+    path.write_bytes(bytes(buf))
+    sha = path.with_suffix(path.suffix + ".sha256")
+    if sha.exists():
+        sha.write_text(hashlib.sha256(bytes(buf)).hexdigest() + "\n")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="GenAI external-data-swap desktop spike (Gate 0.1)")
+    ap.add_argument("--dir", required=True, help="GenAI-loadable inference dir (model.onnx + genai_config.json)")
+    ap.add_argument("--prompt", default="Hello world")
+    ap.add_argument("--rtol", type=float, default=1e-3)
+    args = ap.parse_args()
+
+    inf_dir = Path(args.dir)
+    if not (inf_dir / "genai_config.json").is_file():
+        print(f"FAIL: no genai_config.json in {inf_dir} (not a GenAI package)")
+        return 2
+
+    trace = RssTrace()
+    l_base = _first_logits(str(inf_dir), args.prompt, trace)
+
+    target = _perturb_target(inf_dir)
+    backup = target.with_suffix(target.suffix + ".spikebak")
+    shutil.copy2(target, backup)
+    print(f"perturbing external weight: {target.name} ({target.stat().st_size} bytes)")
+    try:
+        _apply_delta(target)
+        l_swap = _first_logits(str(inf_dir), args.prompt)
+    finally:
+        shutil.move(str(backup), str(target))  # restore original bytes
+
+    differ = not np.allclose(l_base, l_swap, rtol=args.rtol, equal_nan=False)
+    print(trace.report())
+    print(f"|L_base - L_swap| max = {np.nanmax(np.abs(l_base - l_swap)):.6g}")
+    if differ:
+        print("PASS: external swap observed on fresh OgaCreateModel (logits differ).")
+        return 0
+    print("FAIL: logits identical after swap — trainable externals folded or copied (Gate 0.1 hard fail).")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/spikes/genai_external_swap/measure_rss.py b/spikes/genai_external_swap/measure_rss.py
new file mode 100644
index 0000000..25b6106
--- /dev/null
+++ b/spikes/genai_external_swap/measure_rss.py
@@ -0,0 +1,48 @@
+"""RSS sampler for the GenAI external-data-swap spike (#10, Gate 0.1 step 7).
+
+Snapshots resident set size (VmRSS) around load / first-token so mmap-vs-copy can be judged: with a
+file-path load ORT *can* mmap external initializers, so RSS-after-load close to the external file size
+indicates mmap; ~2x indicates a copy. Uses /proc/self/status on Linux (also works on Android), falling
+back to psutil if present.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def rss_kb() -> int:
+    """Current process resident set size in kB (-1 if unavailable)."""
+    status = Path("/proc/self/status")
+    if status.exists():
+        for line in status.read_text().splitlines():
+            if line.startswith("VmRSS:"):
+                return int(line.split()[1])
+    try:
+        import psutil  # noqa: PLC0415
+
+        return psutil.Process().memory_info().rss // 1024
+    except Exception:  # pragma: no cover - best-effort sampler
+        return -1
+
+
+class RssTrace:
+    """Named RSS checkpoints, printed as a small table with deltas."""
+
+    def __init__(self) -> None:
+        self.points: list[tuple[str, int]] = []
+
+    def mark(self, label: str) -> int:
+        v = rss_kb()
+        self.points.append((label, v))
+        return v
+
+    def report(self) -> str:
+        lines = ["RSS (kB):"]
+        base = self.points[0][1] if self.points else 0
+        for label, v in self.points:
+            lines.append(f"  {label:<16} {v:>10}  (+{v - base})")
+        return "\n".join(lines)
+
+
+__all__ = ["rss_kb", "RssTrace"]
diff --git a/spikes/genai_external_swap/setup_ort_separation.sh b/spikes/genai_external_swap/setup_ort_separation.sh
new file mode 100755
index 0000000..f7b1f57
--- /dev/null
+++ b/spikes/genai_external_swap/setup_ort_separation.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Set up ORT engine separation so the Native/training engine and the GenAI engine coexist in one app
+# (#10/#11). GenAI 0.14 needs stock ORT >=1.26; the Native/training engine needs the source-built
+# ORT-training 1.23 — different version AND build, both with SONAME `libonnxruntime.so`. This script gives
+# GenAI its own stock ORT under a distinct name so the two never collide:
+#
+#   • training ORT  -> stays  jniLibs/<abi>/libonnxruntime.so   (linked by libmobiletransformers.so)
+#   • stock ORT     -> shipped jniLibs/<abi>/libort_gen.so      (SONAME raw-patched to libort_gen.so)
+#   • genai .so     -> dlopen string raw-patched  libonnxruntime.so -> libort_gen.so
+#
+# Both export only ~3 symbols (hidden visibility) and genai resolves ORT via dlsym on its own handle, so
+# there is no interposition. Idempotent; re-run to refresh. Requires network (Maven) + Python3.
+set -euo pipefail
+
+ORT_VER="${ORT_VER:-1.27.0}"          # stock ORT paired with onnxruntime-genai 0.14 (needs >=1.26)
+ABI="${ABI:-arm64-v8a}"
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+JNI="$REPO_ROOT/android/MobileTransformers/MobileTransformers/src/main/jniLibs/$ABI"
+GENAI_SO="$JNI/libonnxruntime-genai.so"
+WORK="$(mktemp -d)"; trap 'rm -rf "$WORK"' EXIT
+
+[[ -f "$GENAI_SO" ]] || { echo "FAIL: $GENAI_SO missing (extract it from the genai AAR first)" >&2; exit 2; }
+
+echo ">> fetching stock onnxruntime-android $ORT_VER"
+curl -fsSL -o "$WORK/ort.aar" \
+  "https://repo1.maven.org/maven2/com/microsoft/onnxruntime/onnxruntime-android/$ORT_VER/onnxruntime-android-$ORT_VER.aar"
+unzip -qo "$WORK/ort.aar" "jni/$ABI/libonnxruntime.so" -d "$WORK"
+
+echo ">> raw-patching stock ORT SONAME -> libort_gen.so (no patchelf; preserves verneed/offsets)"
+python3 - "$WORK/jni/$ABI/libonnxruntime.so" "$JNI/libort_gen.so" <<'PY'
+import sys
+b = bytearray(open(sys.argv[1],'rb').read())
+old = b"libonnxruntime.so\x00"; new = b"libort_gen.so\x00" + b"\x00"*(len(old)-len(b"libort_gen.so\x00"))
+assert len(new)==len(old)
+open(sys.argv[2],'wb').write(b.replace(old,new))
+PY
+
+echo ">> raw-patching genai dlopen target: libonnxruntime.so -> libort_gen.so"
+python3 - "$GENAI_SO" <<'PY'
+import sys
+p = sys.argv[1]; b = bytearray(open(p,'rb').read())
+def patch(old,new):
+    ob=old.encode()+b'\x00'; nb=new.encode()+b'\x00'; nb+=b'\x00'*(len(ob)-len(nb)); assert len(nb)==len(ob)
+    n=b.count(ob); b[:]=b.replace(ob,nb); return n
+n1=patch("libonnxruntime.so.1","libort_gen.so.1"); n2=patch("libonnxruntime.so","libort_gen.so")
+open(p,'wb').write(b); print(f"   genai dlopen patched (.so.1 x{n1}, .so x{n2})")
+PY
+
+echo ">> done. jniLibs/$ABI now has:"
+ls -la "$JNI" | grep -iE "libort_gen|libonnxruntime(-genai)?\.so$"
+echo ">> NOTE: the genai AAR is NOT a Gradle dependency (its Java is unused); the patched .so ships from jniLibs."
diff --git a/spikes/mmap/base_blob_mmap_spike.py b/spikes/mmap/base_blob_mmap_spike.py
new file mode 100644
index 0000000..8476cd3
--- /dev/null
+++ b/spikes/mmap/base_blob_mmap_spike.py
@@ -0,0 +1,97 @@
+"""#12 desktop correctness invariant (Gate 0.2): loading the File #9 inference graph with the mmap /
+external-initializers config keys must produce **byte-identical** first-token logits to the default
+(copied-buffer) load. Any divergence is a hard fail — mmap must be transparent, only cheaper.
+
+This is the env-gated desktop leg (needs `onnxruntime`; run under the export or genai-smoke profile). The
+four-point RSS win itself is measured on-device (the manual Gate 0.2 table); here we only prove
+correctness + report desktop RSS deltas around each load.
+
+Run:  uv run --python 3.12 --group genai-smoke python -m spikes.mmap.base_blob_mmap_spike \
+          --dir build/pkg/variants/cpu-int4/inference
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+from spikes.mmap.measure_rss import RssTrace
+
+# ORT config keys under test (external-initializers folder + the ORT-format/bytes toggles).
+EXTERNAL_FOLDER_KEY = "session.model_external_initializers_file_folder_path"
+USE_BYTES_KEY = "session.use_ort_model_bytes_for_initializers"
+
+
+def _build_dummy_inputs(sess, genai_config: dict) -> dict:
+    """Minimal single-token decoder inputs (empty KV cache) from the genai_config geometry."""
+    decoder = genai_config.get("model", {}).get("decoder", {})
+    n_layers = int(decoder.get("num_hidden_layers", 0))
+    n_kv = int(decoder.get("num_key_value_heads", decoder.get("num_attention_heads", 0)))
+    head = int(decoder.get("head_size", 0))
+    feed: dict[str, np.ndarray] = {}
+    names = {i.name for i in sess.get_inputs()}
+    if "input_ids" in names:
+        feed["input_ids"] = np.array([[1]], dtype=np.int64)
+    if "attention_mask" in names:
+        feed["attention_mask"] = np.array([[1]], dtype=np.int64)
+    if "position_ids" in names:
+        feed["position_ids"] = np.array([[0]], dtype=np.int64)
+    for i in range(n_layers):
+        for kind in ("key", "value"):
+            name = f"past_key_values.{i}.{kind}"
+            if name in names:
+                feed[name] = np.zeros((1, n_kv, 0, head), dtype=np.float32)
+    return feed
+
+
+def _first_logits(inf_dir: Path, use_mmap_keys: bool, trace: RssTrace, tag: str) -> np.ndarray:
+    import onnxruntime as ort
+
+    opts = ort.SessionOptions()
+    if use_mmap_keys:
+        opts.add_session_config_entry(EXTERNAL_FOLDER_KEY, str(inf_dir))
+        opts.add_session_config_entry(USE_BYTES_KEY, "0")
+    trace.mark(f"{tag}:pre")
+    sess = ort.InferenceSession(str(inf_dir / "model.onnx"), sess_options=opts, providers=["CPUExecutionProvider"])
+    trace.mark(f"{tag}:loaded")
+    genai_config = json.loads((inf_dir / "genai_config.json").read_text()) if (inf_dir / "genai_config.json").is_file() else {}
+    feed = _build_dummy_inputs(sess, genai_config)
+    out = sess.run(None, feed)
+    trace.mark(f"{tag}:ran")
+    return np.asarray(out[0])
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="mmap external-initializer correctness invariant (#12)")
+    ap.add_argument("--dir", required=True, help="File #9 inference dir (model.onnx + weight_handoff_map.json)")
+    ap.add_argument("--rtol", type=float, default=0.0, help="allowed rtol (default 0 = byte-identical)")
+    args = ap.parse_args()
+
+    inf_dir = Path(args.dir)
+    if not (inf_dir / "model.onnx").is_file():
+        print(f"FAIL: no model.onnx in {inf_dir}")
+        return 2
+
+    trace = RssTrace()
+    logits_copy = _first_logits(inf_dir, use_mmap_keys=False, trace=trace, tag="copy")
+    logits_mmap = _first_logits(inf_dir, use_mmap_keys=True, trace=trace, tag="mmap")
+
+    print(trace.report())
+    identical = np.array_equal(logits_copy, logits_mmap) or np.allclose(
+        logits_copy, logits_mmap, rtol=args.rtol, atol=0.0
+    )
+    max_diff = float(np.nanmax(np.abs(logits_copy - logits_mmap))) if logits_copy.size else 0.0
+    print(f"|logits_copy - logits_mmap| max = {max_diff:.6g}")
+    if identical:
+        print("PASS: external-initializer config load is byte-identical to the copy baseline.")
+        return 0
+    print("FAIL: logits differ — mmap/external-initializer path is not transparent (Gate 0.2 hard fail).")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/spikes/mmap/measure_rss.py b/spikes/mmap/measure_rss.py
new file mode 100644
index 0000000..e3b1e81
--- /dev/null
+++ b/spikes/mmap/measure_rss.py
@@ -0,0 +1,11 @@
+"""#12: RSS sampler for the mmap experiments — a thin re-export of the genai spike's sampler.
+
+The plan is explicit: do NOT write a second sampler. Import `RssTrace`/`rss_kb` from
+`spikes/genai_external_swap/measure_rss.py`.
+"""
+
+from __future__ import annotations
+
+from spikes.genai_external_swap.measure_rss import RssTrace, rss_kb  # noqa: F401
+
+__all__ = ["RssTrace", "rss_kb"]
diff --git a/spikes/optimum_migration/check_symbols.py b/spikes/optimum_migration/check_symbols.py
new file mode 100644
index 0000000..224dcbb
--- /dev/null
+++ b/spikes/optimum_migration/check_symbols.py
@@ -0,0 +1,66 @@
+"""Optimum 2.1 migration spike — import-survival matrix (plan #7, step 6).
+
+Run in the **export** profile (``uv sync --extra export``; optimum + optimum-onnx + torch):
+
+    uv run --extra export python spikes/optimum_migration/check_symbols.py
+
+Prints a PASS/FAIL matrix for the symbols the legacy ``trainer/builder.py`` imported. The decisive
+question is whether ``OnnxConfigWithLoss`` and ``export`` survived optimum's ``optimum-onnx`` split —
+tested **independently** (do not infer their survival from ``main_export`` working).
+
+Recorded result (optimum 2.1.0 / optimum-onnx 0.1.0, 2026-07-13):
+    PASS  main_export                    (optimum.exporters.onnx)
+    PASS  TasksManager                   (optimum.exporters.tasks)
+    PASS  *OnnxConfig model_configs      (optimum.exporters.onnx.model_configs)
+    PASS  export                         (optimum.exporters.onnx  -> convert.export)   [survives]
+    FAIL  OnnxConfigWithLoss             (optimum.exporters.onnx)                       [REMOVED, no replacement]
+
+Decision: ``export()`` survives, so the training-graph path stays on Optimum's durable ``export()`` with
+a **vendored** ``OnnxConfigWithLoss`` (``mobiletransformers.export.onnx_config_with_loss``) — its deps
+(``OnnxConfig``, ``OnnxConfigWithPast``, ``DummyLabelsGenerator``, ``DEFAULT_DUMMY_SHAPES``) all survive.
+The plan's Fallback A (torch.onnx reconstruction) is therefore NOT needed and stays a reserved,
+fail-closed frontend row. Discovery gotcha: ``TasksManager``'s ONNX map is empty until
+``optimum.exporters.onnx.model_configs`` is imported (decorator registration) and requires
+``library_name="transformers"``.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+
+
+def _check(label: str, import_fn) -> bool:  # type: ignore[no-untyped-def]
+    try:
+        import_fn()
+        print(f"PASS  {label}")
+        return True
+    except Exception as exc:  # noqa: BLE001
+        print(f"FAIL  {label}  ->  {type(exc).__name__}: {exc}")
+        return False
+
+
+def main() -> int:
+    print("== optimum symbol-survival matrix ==")
+    for dist in ("optimum", "optimum-onnx", "transformers", "torch"):
+        try:
+            print(f"   {dist}: {importlib.metadata.version(dist)}")
+        except importlib.metadata.PackageNotFoundError:
+            print(f"   {dist}: NOT INSTALLED")
+
+    _check("main_export            (optimum.exporters.onnx)", lambda: __import__("optimum.exporters.onnx", fromlist=["main_export"]).main_export)
+    _check("TasksManager           (optimum.exporters.tasks)", lambda: __import__("optimum.exporters.tasks", fromlist=["TasksManager"]).TasksManager)
+    _check("*OnnxConfig model_configs", lambda: [getattr(__import__("optimum.exporters.onnx.model_configs", fromlist=[n]), n) for n in ("LlamaOnnxConfig", "GemmaOnnxConfig", "Phi3OnnxConfig", "BertOnnxConfig", "Qwen2OnnxConfig", "OPTOnnxConfig")])
+    export_ok = _check("export                 (optimum.exporters.onnx)  [at-risk]", lambda: __import__("optimum.exporters.onnx", fromlist=["export"]).export)
+    ocl_ok = _check("OnnxConfigWithLoss     (optimum.exporters.onnx)  [at-risk]", lambda: __import__("optimum.exporters.onnx", fromlist=["OnnxConfigWithLoss"]).OnnxConfigWithLoss)
+
+    print("\n== vendoring viability (deps for a self-owned OnnxConfigWithLoss) ==")
+    _check("OnnxConfig + OnnxConfigWithPast", lambda: (__import__("optimum.exporters.onnx", fromlist=["OnnxConfig"]).OnnxConfig, __import__("optimum.exporters.onnx.base", fromlist=["OnnxConfigWithPast"]).OnnxConfigWithPast))
+    _check("DummyLabelsGenerator + DEFAULT_DUMMY_SHAPES", lambda: (__import__("optimum.utils", fromlist=["DummyLabelsGenerator"]).DummyLabelsGenerator, __import__("optimum.utils", fromlist=["DEFAULT_DUMMY_SHAPES"]).DEFAULT_DUMMY_SHAPES))
+
+    print("\nDecision:", "vendor OnnxConfigWithLoss on surviving export()" if (export_ok and not ocl_ok) else "re-evaluate — see docstring")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/mobiletransformers/__init__.py b/src/mobiletransformers/__init__.py
new file mode 100644
index 0000000..d49d28a
--- /dev/null
+++ b/src/mobiletransformers/__init__.py
@@ -0,0 +1,62 @@
+"""MobileTransformers — export and Android runtime tooling for on-device transformers.
+
+``__all__`` is the SemVer-governed public Python surface (peer to the Kotlin facade and the CLI).
+It is intentionally small today and grows as later plans land their public entrypoints
+(``export_model``, ``package_model``, ``pull_package``, ``push_adapter``, the typed config models,
+the enums, and the registry ``register_*`` helpers). ``public_api.txt`` is a checked-in golden of
+this list so accidental surface changes fail the public-API test.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.config import resolve
+from mobiletransformers.config.settings import Settings, get_settings
+from mobiletransformers.exceptions import (
+    ConfigValidationError,
+    ExportError,
+    HandoffError,
+    HubError,
+    ManifestError,
+    MergeError,
+    MobileTransformersError,
+    UnsupportedModelError,
+)
+from mobiletransformers.utils.logging import configure_logging, get_logger
+
+
+def _read_version() -> str:
+    """Resolve the package version from installed metadata (#32).
+
+    ``pyproject.toml`` is the SINGLE write-site for the version; hardcoding it here made a second one
+    that could silently disagree. The fallback covers running straight from a source tree with no
+    installed distribution, and is only ever a development value.
+    """
+    from importlib.metadata import PackageNotFoundError, version  # noqa: PLC0415
+
+    try:
+        return version("mobiletransformers")
+    except PackageNotFoundError:  # pragma: no cover - source tree without an install
+        return "0.0.0+unknown"
+
+
+__version__ = _read_version()
+
+__all__ = [
+    "__version__",
+    # settings & precedence
+    "Settings",
+    "get_settings",
+    "resolve",
+    # logging
+    "get_logger",
+    "configure_logging",
+    # exception hierarchy
+    "MobileTransformersError",
+    "ConfigValidationError",
+    "ExportError",
+    "ManifestError",
+    "HandoffError",
+    "MergeError",
+    "UnsupportedModelError",
+    "HubError",
+]
diff --git a/src/mobiletransformers/_typing.py b/src/mobiletransformers/_typing.py
new file mode 100644
index 0000000..b2be789
--- /dev/null
+++ b/src/mobiletransformers/_typing.py
@@ -0,0 +1,21 @@
+"""Shared typing aliases used across the package.
+
+Kept small and dependency-free. The ``py.typed`` marker (sibling file) exports these types to
+downstream consumers per PEP 561.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+# A filesystem path accepted by the library (str or os.PathLike). PEP 604 union (runtime, py>=3.10).
+PathLike = str | os.PathLike[str]
+
+# An ONNX tensor/initializer name.
+TensorName = str
+
+# A decoded JSON object.
+JsonDict = dict[str, Any]
+
+__all__ = ["PathLike", "TensorName", "JsonDict"]
diff --git a/src/mobiletransformers/adapter/__init__.py b/src/mobiletransformers/adapter/__init__.py
new file mode 100644
index 0000000..981d954
--- /dev/null
+++ b/src/mobiletransformers/adapter/__init__.py
@@ -0,0 +1 @@
+"""Adapter push-back (#22): export a trained adapter from the cache and publish it to the Hub."""
diff --git a/src/mobiletransformers/adapter/convert.py b/src/mobiletransformers/adapter/convert.py
new file mode 100644
index 0000000..d2da67e
--- /dev/null
+++ b/src/mobiletransformers/adapter/convert.py
@@ -0,0 +1,170 @@
+"""The PEFT-vs-native gate (#22). Pure, deterministic metadata decision — no ML libraries.
+
+Mode 1 (PEFT-compatible) is emitted **only** when the handoff metadata proves a clean LoRA-shaped
+decomposition exists: ``peftMethod == "lora"`` AND the LoRA component tensors (A/B factors, per #6's
+``PEFTMethodSpec.component_schema``) are present in the checkpoint AND ``rank``/``alpha`` are known.
+Everything else — every MARS package, and any LoRA whose checkpoint no longer carries A/B factors —
+falls to Mode 2 (MobileTransformers-native). Materializing the actual ``adapter_model.safetensors`` bytes
+from the ORT checkpoint is ``torch``/``safetensors`` env-gated; the gate decision + ``adapter_config.json``
+here are pure and CI-covered.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from mobiletransformers.adapter.export import AdapterPackage
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.artifacts.package_paths import PackagePaths
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.config.registry.peft import get_peft_spec
+from mobiletransformers.exceptions import ExportError
+
+if TYPE_CHECKING:  # numpy is only needed under the train/ort-training profiles, not in the pure gate.
+    import numpy as np
+
+#: Reads trainable A/B factor arrays out of the ORT ``CheckpointState``: ``(checkpoint_dir, names) ->
+#: {checkpoint_name: ndarray}``. Injectable so the safetensors-writing path is unit-testable without a
+#: real on-device checkpoint (the default reader below is env-gated on ``onnxruntime-training``).
+FactorReader = Callable[[Path, "Iterable[str]"], "dict[str, np.ndarray]"]
+
+
+@dataclass
+class PeftLayout:
+    """A PEFT-compatible adapter layout (Mode 1). ``adapter_config`` is the ``adapter_config.json`` dict."""
+
+    adapter_config: dict[str, Any]
+    component_roles: tuple[str, ...]
+
+
+def to_peft_layout(pkg: AdapterPackage) -> PeftLayout | None:
+    """Return a :class:`PeftLayout` if the package cleanly maps to a PEFT LoRA adapter, else ``None``."""
+    if pkg.peft_method != PEFTMethod.LORA.value:
+        return None  # MARS (and anything non-LoRA) is never emitted as a drop-in PEFT adapter in v1.
+    required_roles = {c.role for c in get_peft_spec(PEFTMethod.LORA).component_schema}
+    if not required_roles.issubset(set(pkg.checkpoint_component_roles)):
+        return None  # checkpoint no longer carries the A/B factors (only merged tensors) -> native mode.
+    if pkg.rank is None or pkg.alpha is None:
+        return None
+    adapter_config = {
+        "peft_type": "LORA",
+        "r": pkg.rank,
+        "lora_alpha": pkg.alpha,
+        "target_modules": list(pkg.peft_target),
+        "base_model_name_or_path": pkg.base_model_id,
+        "task_type": "CAUSAL_LM",
+    }
+    return PeftLayout(adapter_config=adapter_config, component_roles=tuple(sorted(required_roles)))
+
+
+def _read_checkpoint_factors(checkpoint_dir: Path, names: Iterable[str]) -> dict[str, np.ndarray]:
+    """Default :data:`FactorReader`: pull trainable A/B factors from the ORT ``CheckpointState``.
+
+    Mirrors ``artifact/onnx_builder.py``'s ``onnx_transfer_trained_weights`` (``state.parameters`` yields
+    ``(name, parameter)`` with ``parameter.data`` a numpy array). Env-gated on ``onnxruntime-training``.
+    """
+    try:
+        from onnxruntime.training.api import CheckpointState  # noqa: PLC0415
+    except ImportError as exc:  # pragma: no cover - env-gated, needs the ORT-training runtime
+        raise ExportError(
+            "reading the ORT CheckpointState requires the onnxruntime-training runtime; run under the "
+            "ort-training profile, or pass a factor_reader to materialize_peft_weights"
+        ) from exc
+    if not checkpoint_dir.exists():  # pragma: no cover - env-gated path
+        raise ExportError(f"no ORT checkpoint at {checkpoint_dir}")
+    wanted = set(names)
+    try:  # pragma: no cover - env-gated
+        state = CheckpointState.load_checkpoint(str(checkpoint_dir))
+    except Exception as exc:  # noqa: BLE001 - ORT raises its own runtime errors here
+        # Normalize to ExportError so callers (cli/push_adapter) can distinguish "cannot produce
+        # weights" from a genuine bug, and fail closed rather than publish a weightless adapter.
+        raise ExportError(f"failed to load the ORT checkpoint at {checkpoint_dir}: {exc}") from exc
+    return {  # pragma: no cover - env-gated
+        param_name: parameter.data for param_name, parameter in state.parameters if param_name in wanted
+    }
+
+
+def _peft_safetensors_key(training_base_layer_name: str, search_pattern: str) -> str:
+    """Map a handoff ``trainingBaseLayerName`` + a PEFT component pattern to the PEFT safetensors key.
+
+    ``backbone.model.layers.0.self_attn.q_proj.base_layer`` + ``lora_A`` ->
+    ``base_model.model.model.layers.0.self_attn.q_proj.lora_A.weight`` (the layout ``peft`` loads with
+    ``PeftModel.from_pretrained``).
+    """
+    module_path = training_base_layer_name
+    if module_path.startswith("backbone."):
+        module_path = module_path[len("backbone.") :]
+    if module_path.endswith(".base_layer"):
+        module_path = module_path[: -len(".base_layer")]
+    return f"base_model.model.{module_path}.{search_pattern}.weight"
+
+
+def materialize_peft_weights(
+    pkg: AdapterPackage,
+    layout: PeftLayout,
+    dest_dir: str,
+    *,
+    factor_reader: FactorReader | None = None,
+) -> None:
+    """Write ``adapter_model.safetensors`` from the ORT checkpoint A/B factors — **env-gated**.
+
+    Writing safetensors needs ``torch``/``safetensors`` (the ``train`` extra) and reading the ORT
+    ``CheckpointState`` needs ``onnxruntime-training`` (the default ``factor_reader``). The gate decision +
+    ``adapter_config.json`` are produced without either (CI-covered). ``factor_reader`` is injectable so
+    the numpy->torch->safetensors path can be exercised without a real on-device checkpoint.
+
+    Fails closed (``ExportError``) naming any factor tensor the reader could not supply, before writing.
+    """
+    try:
+        import numpy as np  # noqa: PLC0415
+        import torch  # noqa: PLC0415
+        from safetensors.torch import save_file  # noqa: PLC0415
+    except ImportError as exc:  # pragma: no cover - env-gated, not run in the core CI env
+        raise ExportError(
+            "materializing adapter_model.safetensors requires the 'train' extra (torch + safetensors); "
+            "run under that profile"
+        ) from exc
+
+    # Component role -> PEFT sub-key pattern (adapter_A -> lora_A, adapter_B -> lora_B), from the registry.
+    role_to_pattern = {c.role: c.search_pattern for c in get_peft_spec(PEFTMethod.LORA).component_schema}
+    factor_roles = tuple(layout.component_roles)
+
+    # Reload the handoff map to recover each trainable layer's A/B factor checkpoint names (the merged
+    # AdapterPackage.tensors carry only the fused inference weight, not the separate factors).
+    cache_paths = PackagePaths.for_cache(pkg.cache_repo_dir.parent, pkg.cache_repo_dir.name)
+    handoff = HandoffMap.load(cache_paths.train / "weight_handoff_map.json")
+
+    # checkpoint param name -> its target PEFT safetensors key.
+    key_by_checkpoint_name: dict[str, str] = {}
+    for entry in handoff.entries:
+        if not all(role in entry.checkpoint_names for role in factor_roles):
+            continue  # this layer's checkpoint no longer carries the factors; skip (gate already vetted)
+        for role in factor_roles:
+            pattern = role_to_pattern.get(role)
+            if pattern is None:
+                raise ExportError(f"PEFT role {role!r} has no component pattern in the LoRA registry")
+            ckpt_name = entry.checkpoint_names[role]
+            key_by_checkpoint_name[ckpt_name] = _peft_safetensors_key(entry.training_base_layer_name, pattern)
+    if not key_by_checkpoint_name:
+        raise ExportError("no LoRA A/B factors found in the handoff map; package is not Mode-1 eligible")
+
+    reader = factor_reader or _read_checkpoint_factors
+    arrays = reader(cache_paths.train / "checkpoint", key_by_checkpoint_name.keys())
+
+    missing = sorted(set(key_by_checkpoint_name) - set(arrays))
+    if missing:
+        raise ExportError(f"checkpoint is missing required LoRA factor tensor(s): {', '.join(missing)}")
+
+    tensors = {
+        key_by_checkpoint_name[name]: torch.from_numpy(np.ascontiguousarray(arrays[name]))
+        for name in key_by_checkpoint_name
+    }
+    dest = Path(dest_dir)
+    dest.mkdir(parents=True, exist_ok=True)
+    save_file(tensors, str(dest / "adapter_model.safetensors"))
+
+
+__all__ = ["PeftLayout", "FactorReader", "to_peft_layout", "materialize_peft_weights"]
diff --git a/src/mobiletransformers/adapter/export.py b/src/mobiletransformers/adapter/export.py
new file mode 100644
index 0000000..c1a5652
--- /dev/null
+++ b/src/mobiletransformers/adapter/export.py
@@ -0,0 +1,103 @@
+"""Read a trained adapter out of the on-device cache layout into an :class:`AdapterPackage` (#22).
+
+Pure JSON/file I/O over a materialized ``<cacheDir>/<repo>/`` cache: reads ``train/training_config.json``
++ ``train/weight_handoff_map.json`` (via #8's ``HandoffMap``) and cross-references the flat per-tensor
+``.bin`` files in ``inference/``. No ML libraries — the package is metadata + file pointers the convert
+gate (``adapter/convert.py``) and the pushback CLI consume.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.artifacts.package_paths import PackagePaths
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.exceptions import ExportError
+
+
+@dataclass
+class AdapterTensor:
+    training_checkpoint_name: str
+    external_data_location: str  # per-tensor .bin filename, flat in inference/
+    dtype: str
+    shape: tuple[int, ...]
+    quantized: bool = False
+
+
+@dataclass
+class AdapterPackage:
+    base_model_id: str
+    peft_method: str  # "lora" | "mars" | ...
+    mars_optimization_level: int | None
+    rank: int | None
+    alpha: float | None
+    peft_target: list[str]
+    trainable_parameter_count: int | None
+    handoff_mode: str
+    tensors: list[AdapterTensor]
+    cache_repo_dir: Path
+    checkpoint_component_roles: tuple[str, ...] = ()  # adapter roles present in checkpoint_names
+    source: dict[str, Any] = field(default_factory=dict)
+
+
+def export_adapter_from_cache(cache_repo_dir: str | Path) -> AdapterPackage:
+    """Build an :class:`AdapterPackage` from a materialized cache repo dir (``train/`` + ``inference/``)."""
+    root = Path(cache_repo_dir)
+    # `cache_repo_dir` is already `<cacheDir>/<repoId>`, so resolve relative to its parent.
+    paths = PackagePaths.for_cache(root.parent, root.name)
+    train_cfg_path = paths.train / "training_config.json"
+    handoff_path = paths.train / "weight_handoff_map.json"
+    if not train_cfg_path.is_file():
+        raise ExportError(f"no train/training_config.json under {root}")
+    if not handoff_path.is_file():
+        raise ExportError(f"no train/weight_handoff_map.json under {root}")
+
+    cfg = json.loads(train_cfg_path.read_text(encoding="utf-8"))
+    handoff = HandoffMap.load(handoff_path)
+
+    inference_dir = paths.inference
+    tensors: list[AdapterTensor] = []
+    component_roles: set[str] = set()
+    for entry in handoff.entries:
+        # Adapter component roles present in the checkpoint (LoRA A/B etc.), used by the convert gate.
+        component_roles.update(r for r in entry.checkpoint_names if r != "weight")
+        for role, location in entry.external_data_location.items():
+            tensors.append(
+                AdapterTensor(
+                    training_checkpoint_name=entry.checkpoint_names.get(role, entry.training_base_layer_name),
+                    external_data_location=location,
+                    dtype=entry.dtype,
+                    shape=tuple(entry.shape),
+                    quantized=role in ("weight_quantized", "scale", "zero_point"),
+                )
+            )
+            # note: existence of the .bin in inference/ is not required for metadata export;
+            # the pushback CLI checks presence when it actually copies files.
+            _ = inference_dir  # kept for clarity of where merged tensors live
+
+    peft_method = str(cfg.get("peftMethod") or cfg.get("peft_method") or "").lower()
+    return AdapterPackage(
+        base_model_id=cfg.get("modelId") or cfg.get("model_id") or "unknown",
+        peft_method=peft_method,
+        mars_optimization_level=(
+            cfg.get("optimization_level") if peft_method == PEFTMethod.MARS.value else None
+        ),
+        rank=cfg.get("rank"),
+        alpha=cfg.get("alpha"),
+        peft_target=list(cfg.get("peft_target", [])),
+        trainable_parameter_count=cfg.get("trainable_parameter_count"),
+        handoff_mode=handoff.handoff_mode.value
+        if hasattr(handoff.handoff_mode, "value")
+        else str(handoff.handoff_mode),
+        tensors=tensors,
+        cache_repo_dir=root,
+        checkpoint_component_roles=tuple(sorted(component_roles)),
+        source={"device": cfg.get("device", "unknown")},
+    )
+
+
+__all__ = ["AdapterTensor", "AdapterPackage", "export_adapter_from_cache"]
diff --git a/src/mobiletransformers/adapter/model_card.py b/src/mobiletransformers/adapter/model_card.py
new file mode 100644
index 0000000..9c22a44
--- /dev/null
+++ b/src/mobiletransformers/adapter/model_card.py
@@ -0,0 +1,76 @@
+"""Adapter model-card renderer (#22) — wraps #15's ``render_model_card`` with the mandatory adapter
+disclosures: a bold privacy warning, the exact upstream base-model license, PEFT/MARS details, and
+re-apply instructions. ``assert_required_sections`` fails closed before any upload."""
+
+from __future__ import annotations
+
+from mobiletransformers.adapter.export import AdapterPackage
+from mobiletransformers.config.constants import PEFTMethod
+
+PRIVACY_WARNING = (
+    "**⚠️ Privacy warning:** this adapter was fine-tuned on-device and its weights may encode private "
+    "user data. Uploading it is a deliberate act of publication — do not push adapters trained on data "
+    "you would not publish."
+)
+
+
+def render_adapter_card(pkg: AdapterPackage, *, mode: str, base_model_license: str = "see upstream") -> str:
+    """Render the adapter README. ``mode`` is ``"peft"`` (Mode 1) or ``"native"`` (Mode 2)."""
+    lines: list[str] = []
+    lines.append(f"# {pkg.base_model_id} — MobileTransformers adapter")
+    lines.append("")
+    lines.append(PRIVACY_WARNING)
+    lines.append("")
+    lines.append("## Adapter")
+    lines.append(f"- Base model: `{pkg.base_model_id}`")
+    lines.append(
+        f"- PEFT method: **{pkg.peft_method}**"
+        + (
+            f" (MARS optimization level {pkg.mars_optimization_level})"
+            if pkg.peft_method == PEFTMethod.MARS.value
+            else ""
+        )
+    )
+    lines.append(f"- Rank: {pkg.rank}    Alpha: {pkg.alpha}")
+    lines.append(f"- Target modules: {', '.join(pkg.peft_target) or 'n/a'}")
+    lines.append(f"- Trainable parameters: {pkg.trainable_parameter_count}")
+    lines.append(f"- Handoff mode: `{pkg.handoff_mode}`")
+    lines.append("")
+    lines.append("## Licenses")
+    lines.append("- Framework: Apache-2.0")
+    lines.append(f"- Base model weights: {base_model_license}")
+    lines.append("")
+    lines.append("## Re-apply")
+    if mode == "peft":
+        lines.append(
+            "This is a standard PEFT LoRA adapter — load it with "
+            "`PeftModel.from_pretrained(base_model, <this_repo>)`."
+        )
+    else:
+        lines.append(
+            "This is a **MobileTransformers-native** adapter (not a drop-in PEFT adapter): it ships the "
+            "merged per-tensor external initializers + `weight_handoff_map.json`. Re-apply it through "
+            "MobileTransformers (install the package, load via the native runtime)."
+        )
+    lines.append("")
+    return "\n".join(lines)
+
+
+def assert_required_sections(card: str, pkg: AdapterPackage) -> None:
+    """Fail closed unless the mandatory disclosures are present in ``card``."""
+    missing: list[str] = []
+    if "Privacy warning" not in card:
+        missing.append("privacy warning")
+    if "## Licenses" not in card:
+        missing.append("licenses section")
+    if pkg.peft_method and pkg.peft_method not in card:
+        missing.append("peft method")
+    if "Rank:" not in card:
+        missing.append("rank/alpha")
+    if missing:
+        from mobiletransformers.exceptions import ExportError
+
+        raise ExportError(f"adapter model card missing mandatory sections: {', '.join(missing)}")
+
+
+__all__ = ["PRIVACY_WARNING", "render_adapter_card", "assert_required_sections"]
diff --git a/artifact/__init__.py b/src/mobiletransformers/agent/__init__.py
similarity index 100%
rename from artifact/__init__.py
rename to src/mobiletransformers/agent/__init__.py
diff --git a/src/mobiletransformers/agent/mobile_actions.py b/src/mobiletransformers/agent/mobile_actions.py
new file mode 100644
index 0000000..9da942b
--- /dev/null
+++ b/src/mobiletransformers/agent/mobile_actions.py
@@ -0,0 +1,194 @@
+"""Synthetic **per-user** mobile-action datasets for the #37 tool-call demo.
+
+## Why synthetic, and why per-user
+
+The differentiation gate is explicit that running a vendor's off-device tutorial
+is not a contribution. What this project can show that a hosted assistant cannot is a model fine-tuned
+**on one person's own action vocabulary, on their device, from data that never leaves it**. That needs a
+per-user dataset, and a per-user dataset cannot be downloaded — it has to be generated from the action
+set that user's app actually declares.
+
+So the generator takes the **allowlist** as input. The training targets it emits are exactly the calls
+``FunctionCallValidator`` would accept: same action names, same parameter keys, values that satisfy the
+same ``validationRules``. A model trained on this is being taught the app's real boundary rather than a
+generic function-calling format that then has to be validated into shape.
+
+## What it deliberately does not do
+
+No natural-language *diversity* modelling: the prompt templates are simple and few. The dataset exists
+to demonstrate the loop (per-user actions → on-device fine-tune → validated call → dry-run intent), not
+to be a benchmark, and pretending otherwise by generating thousands of near-duplicates would overstate
+what it shows.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from mobiletransformers.exceptions import ConfigValidationError
+
+#: Prompt templates per action, with `{...}` slots naming the action's own parameters.
+#:
+#: Keyed by action name so an app's allowlist drives what is generated. An action with no template
+#: falls back to a generic phrasing rather than being skipped — a silently missing action would mean a
+#: user's dataset lacked the very action they declared.
+DEFAULT_TEMPLATES: dict[str, tuple[str, ...]] = {
+    "set_alarm": (
+        "wake me at {time}",
+        "set an alarm for {time} called {label}",
+        "alarm {time} for {label}",
+    ),
+    "set_timer": (
+        "timer for {seconds} seconds",
+        "count down {seconds} seconds",
+    ),
+    "send_message": (
+        "text {recipient} saying {body}",
+        "message {recipient}: {body}",
+    ),
+}
+
+#: Value pools per rule, so generated values satisfy the SAME rules the validator enforces.
+_VALUES_BY_RULE: dict[str, tuple[str, ...]] = {
+    "HH:mm": ("06:15", "07:30", "08:00", "12:45", "18:20", "22:05"),
+}
+
+_GENERIC_VALUES: tuple[str, ...] = ("gym", "work", "school", "run", "call mum", "groceries")
+
+
+@dataclass
+class ActionSpec:
+    """Mirror of the Kotlin ``ActionSpec``. The app's declaration, not the model's."""
+
+    action_name: str
+    parameters: dict[str, str] = field(default_factory=dict)
+    allowed_intent: str = ""
+    validation_rules: dict[str, str] = field(default_factory=dict)
+    privacy_class: str = "unspecified"
+    #: Parameters that MUST be present. ``None`` means "all of them", which is what a hand-written
+    #: allowlist means and what the validator enforced before optional parameters existed.
+    #:
+    #: Real tool schemas distinguish the two: in `google/mobile-actions`, `send_email` declares
+    #: `subject`/`body`/`to` but requires only `to`/`subject`, and `create_contact` requires 2 of 4.
+    #: Treating every declared parameter as required would reject calls the dataset itself considers
+    #: correct — the model would be trained on targets its own validator refuses.
+    required_parameters: set[str] | None = None
+
+    @property
+    def required(self) -> set[str]:
+        """The effective required set (all declared parameters unless narrowed)."""
+        return set(self.parameters) if self.required_parameters is None else set(self.required_parameters)
+
+
+def _value_for(param: str, rule: str | None, rng: random.Random) -> str:
+    if rule is not None and rule in _VALUES_BY_RULE:
+        return rng.choice(_VALUES_BY_RULE[rule])
+    if rule is not None and rule.startswith("/") and rule.endswith("/") and "0-9" in rule:
+        return str(rng.randint(5, 900))
+    if param in ("seconds", "minutes"):
+        return str(rng.randint(5, 900))
+    return rng.choice(_GENERIC_VALUES)
+
+
+def generate_examples(
+    allowlist: list[ActionSpec],
+    *,
+    per_action: int = 8,
+    seed: int = 0,
+    templates: dict[str, tuple[str, ...]] | None = None,
+) -> list[dict[str, str]]:
+    """One user's dataset: ``{"prompt": ..., "completion": <tool-call JSON>}`` rows.
+
+    The completion is the exact JSON shape ``FunctionCallValidator.validate`` parses, so what the model
+    is trained to emit and what the app will accept are the same object by construction rather than by
+    a later mapping step.
+
+    Deterministic for a given ``seed`` — a per-user dataset that changed between runs would make "the
+    model learned this user's actions" unfalsifiable.
+    """
+    if not allowlist:
+        raise ConfigValidationError("cannot generate a dataset from an empty allowlist")
+    if per_action < 1:
+        raise ConfigValidationError(f"per_action must be >= 1, got {per_action}")
+
+    table = {**DEFAULT_TEMPLATES, **(templates or {})}
+    rng = random.Random(seed)
+    rows: list[dict[str, str]] = []
+
+    for spec in allowlist:
+        forms = table.get(spec.action_name) or (
+            f"{spec.action_name.replace('_', ' ')} " + " ".join(f"{{{p}}}" for p in spec.parameters),
+        )
+        for _ in range(per_action):
+            params = {
+                param: _value_for(param, spec.validation_rules.get(param), rng) for param in spec.parameters
+            }
+            form = rng.choice(forms)
+            try:
+                prompt = form.format(**params)
+            except KeyError as exc:
+                # A template naming a parameter the action does not declare would produce a prompt the
+                # completion cannot satisfy. Fail closed naming both, rather than emitting the pair.
+                raise ConfigValidationError(
+                    f"template for {spec.action_name!r} references {exc} which the action does not "
+                    f"declare (declared: {sorted(spec.parameters)})"
+                ) from exc
+            rows.append(
+                {
+                    "prompt": prompt,
+                    "completion": json.dumps(
+                        {"actionName": spec.action_name, "parameters": params},
+                        sort_keys=True,
+                    ),
+                }
+            )
+
+    rng.shuffle(rows)
+    return rows
+
+
+def write_jsonl(rows: list[dict[str, str]], path: str | Path) -> Path:
+    """Write ``rows`` as JSONL, the format ``ORTDataCurator`` reads on device."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+    return path
+
+
+def load_allowlist(path: str | Path) -> list[ActionSpec]:
+    """Read an app's action-schema JSON — the same records the Kotlin validator is built from."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(data, list):
+        raise ConfigValidationError("action schema must be a JSON array of action records")
+    specs = []
+    for row in data:
+        if "actionName" not in row:
+            raise ConfigValidationError(f"action record has no 'actionName': {row}")
+        specs.append(
+            ActionSpec(
+                action_name=row["actionName"],
+                parameters=row.get("parameters", {}),
+                allowed_intent=row.get("allowedIntent", ""),
+                validation_rules=row.get("validationRules", {}),
+                privacy_class=row.get("privacyClass", "unspecified"),
+                # Absent means "all declared parameters are required" — the same default the Kotlin
+                # ActionSpec applies, so a schema written before optional parameters existed keeps
+                # its original, stricter meaning on both sides.
+                required_parameters=(set(row["requiredParameters"]) if "requiredParameters" in row else None),
+            )
+        )
+    return specs
+
+
+__all__ = [
+    "ActionSpec",
+    "DEFAULT_TEMPLATES",
+    "generate_examples",
+    "load_allowlist",
+    "write_jsonl",
+]
diff --git a/src/mobiletransformers/agent/mobile_actions_import.py b/src/mobiletransformers/agent/mobile_actions_import.py
new file mode 100644
index 0000000..100200c
--- /dev/null
+++ b/src/mobiletransformers/agent/mobile_actions_import.py
@@ -0,0 +1,276 @@
+"""Import a real function-calling dataset into the #37 tool-call training shape.
+
+Companion to ``mobile_actions.py``: that module *generates* a per-user set from an app's allowlist,
+this one *imports* an existing corpus. Both emit the same two things, so the demo can be driven by
+either or by both in sequence:
+
+* **training rows** — ``{"prompt", "completion"}`` JSONL, where the completion is exactly the JSON
+  ``FunctionCallValidator.validate`` parses. What the model is trained to emit and what the app will
+  accept are the same object by construction, not by a later mapping step;
+* **an action schema** — the ``ActionSpec`` allowlist, derived from the corpus's own tool
+  declarations, so the validator's boundary and the training targets cannot drift apart.
+
+## The source format
+
+Written against ``google/mobile-actions`` (CC-BY-4.0), whose records are::
+
+    {"metadata": "train"|"eval",
+     "tools":    [{"function": {"name", "description", "parameters": {...JSON-Schema-ish...}}}],
+     "messages": [{"role": "developer", "content": ...},
+                  {"role": "user",      "content": ...},
+                  {"role": "assistant", "tool_calls": [{"function": {"name", "arguments": {...}}}]}]}
+
+Any corpus in that shape imports — bring your own file and it is the same code path. Three details
+were taken from the **data**, not from its README, because they disagree:
+
+1. the README says ``arguments`` is "a stringified JSON object"; in all 9,654 records it is a real
+   object. Both are accepted here, because a corpus that follows the README is equally valid;
+2. ``parameters`` uses Gemini-style upper-case type names (``OBJECT``/``STRING``), not JSON Schema's
+   lower-case ones. Both are lower-cased on the way in;
+3. ``required`` is a genuine subset of ``properties`` (``send_email`` requires 2 of 3), which is why
+   :class:`ActionSpec` grew ``required_parameters``.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Iterable, Iterator
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.agent.mobile_actions import ActionSpec
+from mobiletransformers.exceptions import ConfigValidationError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: The file inside a Hub dataset repo to read when ``source`` is a repo id.
+DEFAULT_DATASET_FILE = "dataset.jsonl"
+
+#: Function name -> the Android intent action an accepted call may produce.
+#:
+#: **The corpus does not carry this, and must not.** `google/mobile-actions` describes function calls;
+#: which intent a call is permitted to fire is the *app's* decision, and #37's safety contract is that
+#: the intent string never comes from anything the model touched. So the mapping lives here, in the
+#: repo, reviewable in one place — and an action absent from it gets an empty ``allowedIntent``,
+#: meaning it can be trained on and validated but **never bound**. Failing that way round keeps an
+#: unmapped action from silently acquiring an intent.
+ANDROID_INTENT_BY_ACTION: dict[str, str] = {
+    "create_calendar_event": "android.intent.action.INSERT",
+    "create_contact": "android.intent.action.INSERT",
+    "send_email": "android.intent.action.SENDTO",
+    "show_map": "android.intent.action.VIEW",
+    "open_wifi_settings": "android.settings.WIFI_SETTINGS",
+    # The flashlight has no public intent action — it is a CameraManager torch call. Deliberately
+    # left unmapped rather than invented, so the demo cannot claim a binding that does not exist.
+}
+
+#: Parameter name -> a `validationRules` entry, for values whose shape the corpus states in prose.
+#: Only rules the Kotlin validator understands (`HH:mm`, or `/regex/`) may appear here.
+VALIDATION_RULES_BY_PARAM: dict[str, str] = {
+    # "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS" — asserted, not assumed.
+    "datetime": r"/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/",
+}
+
+
+def _download(repo_id: str, filename: str) -> str:
+    from huggingface_hub import hf_hub_download  # core dep, imported lazily to keep import light
+
+    return hf_hub_download(repo_id=repo_id, filename=filename, repo_type="dataset")  # type: ignore[no-any-return]
+
+
+def resolve_source(
+    source: str | Path,
+    *,
+    filename: str = DEFAULT_DATASET_FILE,
+    downloader: Callable[[str, str], str] | None = None,
+) -> Path:
+    """A local JSONL path for ``source``, downloading it from the Hub if it is a repo id.
+
+    ``downloader`` is injectable (defaults to ``huggingface_hub.hf_hub_download``) for the same reason
+    ``hub/pull.py`` does it: the tests must run offline.
+    """
+    local = Path(source)
+    if local.exists():
+        return local
+    text = str(source)
+    if "/" not in text or text.endswith(".jsonl"):
+        raise ConfigValidationError(
+            f"no such file: {source!r} (a Hub dataset id looks like 'google/mobile-actions')"
+        )
+    logger.info("fetching %s:%s from the Hub", text, filename)
+    return Path((downloader or _download)(text, filename))
+
+
+def read_records(path: str | Path) -> Iterator[dict[str, Any]]:
+    """Stream the JSONL, skipping blank lines. Malformed lines fail closed naming the line number."""
+    with Path(path).open(encoding="utf-8") as handle:
+        for lineno, line in enumerate(handle, start=1):
+            if not line.strip():
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ConfigValidationError(f"{path}:{lineno} is not valid JSON: {exc}") from exc
+
+
+def _arguments(raw: Any) -> dict[str, str]:
+    """Tool-call arguments as a flat string map, accepting both the object and stringified forms."""
+    if isinstance(raw, str):
+        try:
+            raw = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ConfigValidationError(f"tool-call arguments are not valid JSON: {raw!r}") from exc
+    if raw is None:
+        return {}
+    if not isinstance(raw, dict):
+        raise ConfigValidationError(f"tool-call arguments must be an object, got {type(raw).__name__}")
+    # Every value crosses into `parameters: Map<String, String>` on the Kotlin side, so non-strings are
+    # rendered here rather than at the JNI boundary where the failure would be far from its cause.
+    return {k: v if isinstance(v, str) else json.dumps(v, sort_keys=True) for k, v in raw.items()}
+
+
+def extract_allowlist(records: Iterable[dict[str, Any]]) -> list[ActionSpec]:
+    """The union of every tool the corpus declares, as the validator's allowlist.
+
+    Deriving the allowlist from the corpus is what keeps the two halves honest: the model is trained on
+    calls to these actions, and the validator accepts exactly these actions. A hand-written allowlist
+    beside a downloaded corpus is a drift waiting to happen.
+
+    Fails closed if two records declare the same action with different parameters — that is the corpus
+    disagreeing with itself, and picking one silently would make the validator's verdict depend on
+    record order.
+    """
+    specs: dict[str, ActionSpec] = {}
+    for record in records:
+        for tool in record.get("tools") or []:
+            function = tool.get("function") or {}
+            name = function.get("name")
+            if not name:
+                raise ConfigValidationError(f"tool declaration has no function name: {tool}")
+            schema = function.get("parameters") or {}
+            properties = schema.get("properties") or {}
+            spec = ActionSpec(
+                action_name=name,
+                parameters={p: str(v.get("type", "STRING")).lower() for p, v in properties.items()},
+                allowed_intent=ANDROID_INTENT_BY_ACTION.get(name, ""),
+                validation_rules={
+                    p: VALIDATION_RULES_BY_PARAM[p] for p in properties if p in VALIDATION_RULES_BY_PARAM
+                },
+                privacy_class="imported-corpus",
+                required_parameters=set(schema.get("required") or ()),
+            )
+            existing = specs.get(name)
+            if existing is not None and existing != spec:
+                raise ConfigValidationError(
+                    f"action {name!r} is declared two different ways in the corpus: "
+                    f"{existing.parameters} / required={sorted(existing.required)} vs "
+                    f"{spec.parameters} / required={sorted(spec.required)}"
+                )
+            specs[name] = spec
+    if not specs:
+        raise ConfigValidationError("corpus declares no tools — nothing to build an allowlist from")
+    return [specs[name] for name in sorted(specs)]
+
+
+def _prompt(messages: list[dict[str, Any]], style: str) -> str:
+    user = next((m.get("content", "") for m in messages if m.get("role") == "user"), "")
+    if not user:
+        return ""
+    if style == "user":
+        return str(user)
+    if style != "context":
+        raise ConfigValidationError(f"unknown prompt style {style!r} (expected 'context' or 'user')")
+    # The developer turn carries the current date and day of week, and a third of the corpus asks for
+    # a calendar event in relative terms ("this Friday"). Drop it and those targets become unlearnable
+    # — the model would be supervised toward a datetime nothing in its input determines.
+    developer = next((m.get("content", "") for m in messages if m.get("role") == "developer"), "")
+    return f"{developer}\n{user}".strip() if developer else str(user)
+
+
+def to_training_rows(
+    records: Iterable[dict[str, Any]],
+    *,
+    split: str | None = "train",
+    prompt_style: str = "context",
+    multi_call: str = "skip",
+) -> list[dict[str, str]]:
+    """Convert corpus records into ``{"prompt", "completion"}`` rows.
+
+    ``split`` filters on the record's ``metadata`` field (``"train"`` / ``"eval"``); ``None`` keeps all.
+
+    ``multi_call`` decides what to do with the ~33% of `google/mobile-actions` records whose assistant
+    turn emits two or three calls, which the single-call ``ValidatedCall`` contract cannot express:
+
+    * ``"skip"`` (default) drops them. **This is deliberate.** Splitting one prompt into several rows
+      would train the model to answer a two-action request with one action and call that correct —
+      supervision that is actively wrong, and invisible in the loss. Dropping loses examples; splitting
+      loses the truth.
+    * ``"first"`` keeps the first call, for when volume matters more than fidelity. Say so if you use
+      it: the resulting model is being taught to under-answer.
+    """
+    if multi_call not in ("skip", "first"):
+        raise ConfigValidationError(f"unknown multi_call policy {multi_call!r} (expected 'skip'/'first')")
+
+    rows: list[dict[str, str]] = []
+    dropped = 0
+    for record in records:
+        if split is not None and record.get("metadata") != split:
+            continue
+        messages = record.get("messages") or []
+        calls = next((m.get("tool_calls") for m in messages if m.get("role") == "assistant"), None) or []
+        if not calls:
+            continue
+        if len(calls) > 1 and multi_call == "skip":
+            dropped += 1
+            continue
+        prompt = _prompt(messages, prompt_style)
+        if not prompt:
+            continue
+        function = calls[0].get("function") or {}
+        name = function.get("name")
+        if not name:
+            raise ConfigValidationError(f"tool call has no function name: {calls[0]}")
+        rows.append(
+            {
+                "prompt": prompt,
+                "completion": json.dumps(
+                    {"actionName": name, "parameters": _arguments(function.get("arguments"))},
+                    sort_keys=True,
+                ),
+            }
+        )
+    if dropped:
+        logger.info("skipped %d multi-call record(s); kept %d single-call row(s)", dropped, len(rows))
+    return rows
+
+
+def write_action_schema(specs: list[ActionSpec], path: str | Path) -> Path:
+    """Write the allowlist as the action-schema JSON both languages read."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = [
+        {
+            "actionName": spec.action_name,
+            "parameters": spec.parameters,
+            "allowedIntent": spec.allowed_intent,
+            "requiredParameters": sorted(spec.required),
+            "validationRules": spec.validation_rules,
+            "privacyClass": spec.privacy_class,
+        }
+        for spec in specs
+    ]
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path
+
+
+__all__ = [
+    "ANDROID_INTENT_BY_ACTION",
+    "DEFAULT_DATASET_FILE",
+    "VALIDATION_RULES_BY_PARAM",
+    "extract_allowlist",
+    "read_records",
+    "resolve_source",
+    "to_training_rows",
+    "write_action_schema",
+]
diff --git a/inference/__init__.py b/src/mobiletransformers/artifacts/__init__.py
similarity index 100%
rename from inference/__init__.py
rename to src/mobiletransformers/artifacts/__init__.py
diff --git a/artifact/onnx_builder.py b/src/mobiletransformers/artifacts/builder.py
similarity index 54%
rename from artifact/onnx_builder.py
rename to src/mobiletransformers/artifacts/builder.py
index d35dfb8..257d146 100644
--- a/artifact/onnx_builder.py
+++ b/src/mobiletransformers/artifacts/builder.py
@@ -1,43 +1,108 @@
+# DECOMPOSE(#5): split graph assembly vs. quantization vs. gen_artifacts orchestration into
+# src/mobiletransformers/{export,artifacts} as touched (#7/#9). ~38 KB.
 """
 Script that creates the training and inference model artifacts which can be deployed to the device.
 The models are utilized by the on-device application.
 """
 
 import argparse
+import contextlib
+import gc
+import json
+import os
 import textwrap
-from typing import Dict, List
-import subprocess
-import os, json, gc, time, yaml
+import time
 
 from dotenv import load_dotenv
+
+from mobiletransformers.utils.yaml import load_config_from_file
+
 load_dotenv()
 
 import numpy as np
-from transformers import AutoTokenizer, AutoConfig
-
 import onnx
-from onnx import helper, TensorProto, numpy_helper
-from onnxruntime.training import onnxblock, artifacts
-from onnxruntime.training.api import CheckpointState, Module, Optimizer
-from onnx.external_data_helper import convert_model_to_external_data, write_external_data_tensors, set_external_data
-
 import onnxruntime as rt
+from onnx import TensorProto, helper, numpy_helper
+from onnx.external_data_helper import (
+    convert_model_to_external_data,
+    set_external_data,
+    write_external_data_tensors,
+)
 from onnxruntime import InferenceSession, SessionOptions
-from inference.generator import generate_tokens_onnx
-from tools.utils import move_files_excluding, delete_directory, load_and_save_dataset, move_onnx_model
-from tools.parser_config import ARTIFACT_CONFIG, TRAIN_CONFIG, INFERENCE_CONFIG, TASK_NAME_TO_DATASET
-from tools.tokenizer_export import export_tokenizer_config
-
-from artifact.merger import create_mars_merger_model, create_lora_merger_model, create_mars_merger_model_2, create_lora_merger_model_2
-
-def gen_artifacts(train_dir,
-                  artifact_dir="artifacts",
-                  model_name="quant_model.onnx",
-                  train_cfg_file="training_config.json",
-                  training_config={}):
+from onnxruntime.training import artifacts, onnxblock
+from onnxruntime.training.api import CheckpointState, Module, Optimizer
+from transformers import AutoConfig, AutoTokenizer
+
+from mobiletransformers.artifacts.graph_prep import ensure_layernorm_grad_outputs
+from mobiletransformers.artifacts.trainable_gate import (
+    assert_every_requested_tensor_is_trainable,
+    is_quant_companion,
+)
+from mobiletransformers.config.constants import (
+    ARTIFACT_CONFIG,
+    INFERENCE_CONFIG,
+    TASK_NAME_TO_DATASET,
+    TRAIN_CONFIG,
+    PEFTMethod,
+)
+from mobiletransformers.config.registry.merger import emit_merger_models
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.export.tokenizer_export import export_tokenizer_config
+from mobiletransformers.inference.generator import generate_tokens_onnx
+from mobiletransformers.training.data import load_and_save_dataset
+from mobiletransformers.utils.logging import get_logger
+from mobiletransformers.utils.paths import delete_directory, move_files_excluding, move_onnx_model
+
+logger = get_logger(__name__)
+
+
+#: Suffixes the quantizer appends beside a weight it packs. Same role vocabulary the handoff map uses
+@contextlib.contextmanager
+def _onnx_external_data_overwrite():
+    """Let ``onnx.save`` overwrite an existing external-data file, for the duration of the block.
+
+    ORT-training's ``onnxblock.Block`` writes ``temp.onnx`` + ``temp.onnx.data`` into the **current
+    working directory** (`blocks.py:36`) and only removes them in ``__del__``. Every Block shares that
+    one filename, so with a model large enough to take the external-data path
+    (``accessor.has_path``), the second Block of a ``generate_artifacts`` run saves onto the first
+    Block's still-present ``temp.onnx.data`` — and onnx >= 1.16 raises
+    ``FileExistsError: External data file exists in temp.onnx.data`` instead of overwriting, killing
+    artifact generation.
+
+    ORT 1.23 and onnx 1.18 are the pairing recorded in ``third_party/onnxruntime/manifest.json``, so
+    this is not version drift we can pin away; Gate 0.3's smoke never hit it because its model is small
+    enough that ``has_path`` is false and the whole branch is skipped. Restoring the pre-1.16 overwrite
+    semantics for exactly this call is the narrowest fix available to us.
+    """
+    original_save = onnx.save_model
+
+    def _save(proto, f, *args, **kwargs):
+        location = kwargs.get("location")
+        if location and kwargs.get("save_as_external_data") and isinstance(f, (str, os.PathLike)):
+            stale = os.path.join(os.path.dirname(os.path.abspath(str(f))), str(location))
+            if os.path.exists(stale):
+                os.remove(stale)
+        return original_save(proto, f, *args, **kwargs)
+
+    onnx.save_model = _save
+    onnx.save = _save
+    try:
+        yield
+    finally:
+        onnx.save_model = original_save
+        onnx.save = original_save
+
+
+def gen_artifacts(
+    train_dir,
+    artifact_dir="artifacts",
+    model_name="quant_model.onnx",
+    train_cfg_file="training_config.json",
+    training_config={},
+):
     """
     Generates the training artifacts from the provided model and directory.
-    Needs the training configuration provided along with the model in the same directory. 
+    Needs the training configuration provided along with the model in the same directory.
     """
     onnx_model_path = os.path.join(train_dir, model_name)
     train_cfg_path = os.path.join(train_dir, train_cfg_file)
@@ -46,71 +111,102 @@ def gen_artifacts(train_dir,
     onnx_model = onnx.load(onnx_model_path)
 
     params = {}
-    with open(train_cfg_path, "r", encoding="utf-8") as f:
+    with open(train_cfg_path, encoding="utf-8") as f:
         params = json.load(f)
 
     requires_grad = []
     frozen_params = []
 
+    # Adapter tensor IDENTITY, not just its name. The handoff map is declared as the single source of
+    # tensor identity, but it only ever described the MERGED inference initializers: it *names*
+    # `adapter_A`/`adapter_B` in `checkpointNames` and says nothing about their dtype or shape. A
+    # consumer that wants to exchange the factors themselves (#35 rank-r federation, and #36's Kotlin
+    # codec after it) would otherwise have to infer shapes from the rank — exactly the kind of
+    # re-derivation that produced the layer-identity defects. Captured here because this is the one
+    # place the training graph is already open and its initializers already being walked.
+    trainable_tensor_specs: dict[str, dict] = {}
+
     for param in onnx_model.graph.initializer:
-        if any(rqp in param.name for rqp in params["requires_grad"]):
-            requires_grad.append(param.name)
-        else:
-            frozen_params.append(param.name)
-    
+        trainable = any(rqp in param.name for rqp in params["requires_grad"]) and not is_quant_companion(
+            param.name
+        )
+        (requires_grad if trainable else frozen_params).append(param.name)
+        if trainable:
+            trainable_tensor_specs[param.name] = {
+                "dtype": onnx.helper.tensor_dtype_to_np_dtype(param.data_type).name,
+                "shape": list(param.dims),
+            }
+
+    assert_every_requested_tensor_is_trainable(params["requires_grad"], requires_grad, frozen_params)
+
     del onnx_model
     gc.collect()
 
+    # Gradient graphs need LayerNormalization's optional saved-stat outputs; see graph_prep.
+    onnx_model_path = ensure_layernorm_grad_outputs(onnx_model_path)
+
     # Generate the training artifacts
-    artifacts.generate_artifacts(onnx_model_path,
-                                requires_grad = requires_grad,
-                                frozen_params = frozen_params,
-                                # We don't need to provide a loss function, as the loss is already
-                                # computed from the PyTorch Transformer model
-                                # In the case of inference model, we don't need it
-                                #loss = CausalLMCE(),
-                                optimizer = artifacts.OptimType.AdamW,
-                                artifact_directory = artifact_dir
-                                )
-    
+    with _onnx_external_data_overwrite():
+        artifacts.generate_artifacts(
+            onnx_model_path,
+            requires_grad=requires_grad,
+            frozen_params=frozen_params,
+            # We don't need to provide a loss function, as the loss is already
+            # computed from the PyTorch Transformer model
+            # In the case of inference model, we don't need it
+            # loss = CausalLMCE(),
+            optimizer=artifacts.OptimType.AdamW,
+            artifact_directory=artifact_dir,
+        )
+
     extended_training_config = {
-            "requires_grad": requires_grad,
-            "peft_mapping": params["peft_mapping"],
-            "rank": params["rank"],
-            "alpha": params["alpha"],
-            "peft_target": params["peft_target"],
-            "trainable_parameter_count": params["trainable_parameter_count"],
-            **training_config
-        }
+        "requires_grad": requires_grad,
+        # {initializer name -> {"dtype", "shape"}} for every realized trainable tensor. Consumed by
+        # `TrainableTensorCodec.from_peft_mapping` so the handoff map can DESCRIBE the adapter
+        # factors, not merely name them.
+        "trainable_tensor_specs": trainable_tensor_specs,
+        "peft_mapping": params["peft_mapping"],
+        "rank": params["rank"],
+        "alpha": params["alpha"],
+        "peft_target": params["peft_target"],
+        "trainable_parameter_count": params["trainable_parameter_count"],
+        # Carried through for the export-time parameter-budget gate (artifacts/parameter_budget.py).
+        # Absent from packages exported before that gate existed, hence .get rather than [].
+        "source_parameter_count": params.get("source_parameter_count"),
+        **training_config,
+    }
 
     # Export training configs
-    with open(f'{artifact_dir}/{train_cfg_file}', "w", encoding="utf-8") as f:
+    with open(f"{artifact_dir}/{train_cfg_file}", "w", encoding="utf-8") as f:
         json.dump(extended_training_config, f, ensure_ascii=False)
 
     return extended_training_config
 
-def onnx_checktrain(model_dir,
-                    model_id,
-                    export_inference=False,
-                    test_inference=False,
-                    test_evaluate=False,
-                    transfer_weights=False,
-                    inference_model_path="inference_model.onnx",
-                    max_sequence_length=100):
+
+def onnx_checktrain(
+    model_dir,
+    model_id,
+    export_inference=False,
+    test_inference=False,
+    test_evaluate=False,
+    transfer_weights=False,
+    inference_model_path="inference_model.onnx",
+    max_sequence_length=100,
+):
     """
-    Checks the model if the outputs are training correctly as well as evaluation.
-    Exports model for inference if needed or transfers the weights to an already existing inference model.
-
-   - `test_inference` - runs the model through an example prompt
-   - `test_evaluate` - tests the model evaluation
-   - `transfer_weights` - instead of exporting for inference, we only copy the subset of updated weights to an already created inference model after training
-   - `inference_model_path` - model path of an already existing inference model or one to create
-   - `max_sequence_length` - length of text generation sequence
+     Checks the model if the outputs are training correctly as well as evaluation.
+     Exports model for inference if needed or transfers the weights to an already existing inference model.
+
+    - `test_inference` - runs the model through an example prompt
+    - `test_evaluate` - tests the model evaluation
+    - `transfer_weights` - instead of exporting for inference, we only copy the subset of updated weights to an already created inference model after training
+    - `inference_model_path` - model path of an already existing inference model or one to create
+    - `max_sequence_length` - length of text generation sequence
     """
-    
+
     state = CheckpointState.load_checkpoint(f"{model_dir}/checkpoint")
 
-    sess_options = SessionOptions()    
+    sess_options = SessionOptions()
     sess_options.enable_profiling = False
     sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_EXTENDED
     sess_options.execution_mode = rt.ExecutionMode.ORT_PARALLEL
@@ -119,28 +215,41 @@ def onnx_checktrain(model_dir,
     sess_options.add_session_config_entry("session.intra_op.allow_spinning", "0")
     sess_options.add_session_config_entry("session.inter_op.allow_spinning", "0")
 
-    model = Module(f"{model_dir}/training_model.onnx", state, f"{model_dir}/eval_model.onnx", session_options=sess_options)
+    model = Module(
+        f"{model_dir}/training_model.onnx",
+        state,
+        f"{model_dir}/eval_model.onnx",
+        session_options=sess_options,
+    )
     optimizer = Optimizer(f"{model_dir}/optimizer_model.onnx", model)
 
-    tokenizer = AutoTokenizer.from_pretrained(model_id, token=os.environ['HF_TOKEN'])
+    tokenizer = AutoTokenizer.from_pretrained(model_id, token=get_settings().require_hf_token())
 
     # Create dummy input
     tokenizer.pad_token_id = 0
-    inputs = tokenizer(["This is a test, hello from world.", "This is a test, hello to world."], return_tensors="pt", padding=True)
+    inputs = tokenizer(
+        ["This is a test, hello from world.", "This is a test, hello to world."],
+        return_tensors="pt",
+        padding=True,
+    )
 
     input_ids = inputs["input_ids"].numpy()
     position_ids = np.arange(input_ids.shape[1], dtype=np.int64)[None, :]
-    labels = inputs["input_ids"].clone().numpy()
 
+    # Labels are passed UNSHIFTED.
+    #
+    # This used to pre-shift (`labels[:, :-1] = input_ids[:, 1:]`), which double-shifted: the exported
+    # training graph already performs the HF causal shift internally (`Slice(logits, 0:-1)` against
+    # `Slice(labels, 1:)`), so every loss this helper printed was inflated by a second shift and was
+    # not comparable to the on-device number. The Android path (`ORTDataCurator`) always passed
+    # unshifted labels, so only this host-side check was wrong.
     labels = np.copy(input_ids)
-    labels[:, :-1] = input_ids[:, 1:]
-    labels[:, -1] = -100  # Optionally, set the last token to -100 to ignore it in the loss
 
     inputs = {
         "input_ids": inputs["input_ids"].numpy(),
         "attention_mask": inputs["attention_mask"].numpy(),
         "position_ids": position_ids,
-        "labels": labels
+        "labels": labels,
     }
 
     start_train_time = time.time()
@@ -171,7 +280,10 @@ def onnx_checktrain(model_dir,
         gc.collect()
     elif export_inference:
         # Model inference: we want to get only logits and hidden states for decoding
-        model.export_model_for_inferencing(f"{model_dir}/{inference_model_path}", [ out_name for out_name in model.output_names() if out_name not in exclude_nodes])
+        model.export_model_for_inferencing(
+            f"{model_dir}/{inference_model_path}",
+            [out_name for out_name in model.output_names() if out_name not in exclude_nodes],
+        )
 
         del model
         del state
@@ -179,143 +291,142 @@ def onnx_checktrain(model_dir,
         gc.collect()
         # Load and test inference if needed
         if test_inference:
-            onnx_infer(model_id, f"{model_dir}/{inference_model_path}", with_past=False, max_length=max_sequence_length)
+            onnx_infer(
+                model_id,
+                f"{model_dir}/{inference_model_path}",
+                with_past=False,
+                max_length=max_sequence_length,
+            )
+
 
 def force_dequantize_external_and_save(model, output_path, external_data_filename=None):
     """
     Force DequantizeLinear x_scale and x_zero_point tensors to be external and save the model.
-    
+
     Args:
         model: Loaded ONNX model (onnx.ModelProto)
         output_path: Path where to save the modified model
         external_data_filename: Name of external data file (optional, defaults to model_name.onnx.data)
-    
+
     Returns:
         model : The new inference model with external initializers
     """
     if external_data_filename is None:
         model_name = os.path.splitext(os.path.basename(output_path))[0]
-        external_data_filename = f'{model_name}.onnx.data'
-    
+        external_data_filename = f"{model_name}.onnx.data"
+
     forced_count = 0
-    
+
     # Force DequantizeLinear tensors to external manually BEFORE converting everything else
     for initializer in model.graph.initializer:
         # Check if initializer name ends with x_scale or x_zero_point
         # TODO: Hard coded
-        is_dequant_tensor = (initializer.name.startswith("model.layers")) and (initializer.name.endswith("MatMul.weight") or initializer.name.endswith("MatMul.weight_zero_point") or initializer.name.endswith("MatMul.weight_scale"))
-        
+        is_dequant_tensor = (initializer.name.startswith("model.layers")) and (
+            initializer.name.endswith("MatMul.weight")
+            or initializer.name.endswith("MatMul.weight_zero_point")
+            or initializer.name.endswith("MatMul.weight_scale")
+        )
+
         if is_dequant_tensor and initializer.data_location != onnx.TensorProto.EXTERNAL:
             print(f"Forcing DequantizeLinear tensor to external: {initializer.name}")
-            
+
             # Convert tensor data to raw_data format first
             # This ensures the tensor has raw_data field that set_external_data expects
             if not initializer.HasField("raw_data"):
                 # Convert using numpy helper to preserve exact data type and format
                 tensor_array = onnx.numpy_helper.to_array(initializer)
-                
+
                 # Clear all existing data fields first
                 initializer.ClearField("float_data")
-                initializer.ClearField("int32_data") 
+                initializer.ClearField("int32_data")
                 initializer.ClearField("int64_data")
                 initializer.ClearField("string_data")
                 initializer.ClearField("uint64_data")
                 initializer.ClearField("double_data")
                 initializer.ClearField("raw_data")
-                
+
                 # Set raw_data with the binary representation
                 initializer.raw_data = tensor_array.tobytes()
-            
+
             # Now use the proper ONNX function to set external data
-            onnx.external_data_helper.set_external_data(
-                tensor=initializer,
-                location=external_data_filename
-            )
+            onnx.external_data_helper.set_external_data(tensor=initializer, location=external_data_filename)
             forced_count += 1
-            
+
             # Now use the proper ONNX function to set external data
-            set_external_data(
-                tensor=initializer,
-                location=external_data_filename
-            )
-            
+            set_external_data(tensor=initializer, location=external_data_filename)
+
             forced_count += 1
-    
+
     # Convert all OTHER tensors to external data (this won't affect already external ones)
     convert_model_to_external_data(
-        model, 
-        location=external_data_filename, 
-        size_threshold=0,
-        all_tensors_to_one_file=True
+        model, location=external_data_filename, size_threshold=0, all_tensors_to_one_file=True
     )
-    
+
     # Write external data to file
     output_dir = os.path.dirname(output_path)
     if not output_dir:
         output_dir = "."
-    
+
     return write_external_data_tensors(model, output_dir)
 
+
 def get_all_metadata_from_onnx(model_path):
     """
     Extract all metadata properties from ONNX model.
-    
+
     Args:
         model_path (Path or str): Path to the .onnx model file
-    
+
     Returns:
         dict: Dictionary containing all metadata properties from both model and graph levels.
               Graph-level metadata will override model-level metadata if keys conflict.
     """
     import onnx
-    
+
     model = onnx.load(str(model_path))
     metadata = {}
-    
+
     # Read model-level metadata first
     for prop in model.metadata_props:
         metadata[prop.key] = prop.value
-    
+
     # Read graph-level metadata (will override model-level if keys conflict)
     for prop in model.graph.metadata_props:
         metadata[prop.key] = prop.value
-    
+
     return metadata
 
+
 def onnx_export_dummy_model(model_output="tokenizer.onnx"):
     """
     Creates a fake dummy model for the tokenization process with GenAI.
     """
 
     # Define the input and output tensor types
-    input_ids = helper.make_tensor_value_info('input_ids', TensorProto.FLOAT, [None, None])
-    logits = helper.make_tensor_value_info('logits', TensorProto.FLOAT, [None, None])
+    input_ids = helper.make_tensor_value_info("input_ids", TensorProto.FLOAT, [None, None])
+    logits = helper.make_tensor_value_info("logits", TensorProto.FLOAT, [None, None])
 
-
-    node = helper.make_node(
-        "Identity",
-        inputs=["input_ids"],
-        outputs=["logits"]
-    )
+    node = helper.make_node("Identity", inputs=["input_ids"], outputs=["logits"])
 
     graph = helper.make_graph(
-        nodes=[node], 
+        nodes=[node],
         name="identity_graph",
         inputs=[input_ids],  # No inputs
-        outputs=[logits]  # No outputs
+        outputs=[logits],  # No outputs
     )
 
     # Create an empty model
     model = helper.make_model(
         graph,
-        producer_name='onnx-empty-model',
-        opset_imports=[helper.make_opsetid('', 14)]  # Adjust the opset version as needed
+        producer_name="onnx-empty-model",
+        opset_imports=[helper.make_opsetid("", 14)],  # Adjust the opset version as needed
     )
 
     onnx.checker.check_model(model)
 
     onnx.save_model(model, model_output, save_as_external_data=False)
 
+
 def onnx_infer(model_id, model_path="inf_model_onnx_gemma_nonq.onnx", with_past=False, max_length=100):
     """
     Test inference with the provided ONNX inference model. Model needs to have inputs:
@@ -324,16 +435,19 @@ def onnx_infer(model_id, model_path="inf_model_onnx_gemma_nonq.onnx", with_past=
     - position_ids
     """
 
-    session = InferenceSession(model_path, providers=['CPUExecutionProvider'])
+    session = InferenceSession(model_path, providers=["CPUExecutionProvider"])
     input_name = session.get_inputs()[0].name
     output_name = session.get_outputs()[0].name
 
-    tokenizer = AutoTokenizer.from_pretrained(model_id, token=os.environ['HF_TOKEN'])
+    tokenizer = AutoTokenizer.from_pretrained(model_id, token=get_settings().require_hf_token())
     config = AutoConfig.from_pretrained(model_id)
 
     prompt = "Hello, this is a message for the world. How is your day?"
 
-    print(generate_tokens_onnx(prompt, tokenizer, session, config, with_past=with_past, max_length=max_length))
+    print(
+        generate_tokens_onnx(prompt, tokenizer, session, config, with_past=with_past, max_length=max_length)
+    )
+
 
 def onnx_segment_weights(model_path, output_path):
     """
@@ -342,7 +456,8 @@ def onnx_segment_weights(model_path, output_path):
     m = onnx.load(model_path)
     onnx.save(m, output_path, save_as_external_data=True, all_tensors_to_one_file=False)
 
-def onnx_transfer_trained_weights(state : CheckpointState, inference_model):
+
+def onnx_transfer_trained_weights(state: CheckpointState, inference_model):
     """
     Transfer the updated weights from the checkpoint traning session to the inference model and save it.
     """
@@ -365,7 +480,6 @@ def onnx_transfer_trained_weights(state : CheckpointState, inference_model):
     # Overwrite the parameters that require gradient
     for i, initializer in enumerate(onnx_inference_model.graph.initializer):
         if initializer.name in updated_weights:
-
             W = numpy_helper.to_array(initializer)
             if not np.array_equal(W, updated_weights[initializer.name]):
                 print(f"Overwriting {initializer.name}, weights changed...")
@@ -375,25 +489,30 @@ def onnx_transfer_trained_weights(state : CheckpointState, inference_model):
                 if np.array_equal(new_numpy, updated_weights[initializer.name]):
                     print("Copied successfully")
             else:
-                print(f"Weights were not changed, but the training session was performed on these weights?\nParameter: {initializer.name}")
+                print(
+                    f"Weights were not changed, but the training session was performed on these weights?\nParameter: {initializer.name}"
+                )
 
     onnx.save(onnx_inference_model)
     del onnx_inference_model
     gc.collect()
 
-def gen_genai(model_id, 
-              model_path,
-              training_config,
-              new_model_name,
-              new_model_path,
-              weight_input=True,
-              include_metadata=True,
-              large_model=False,
-              test_generation=False,
-              test_generation_config={},
-              force_external=False,
-              check_model=True,
-              opset_version=18):
+
+def gen_genai(
+    model_id,
+    model_path,
+    training_config,
+    new_model_name,
+    new_model_path,
+    weight_input=True,
+    include_metadata=True,
+    large_model=False,
+    test_generation=False,
+    test_generation_config={},
+    force_external=False,
+    check_model=True,
+    opset_version=18,
+):
     """
     Creates a GenAI compatible ONNX graph or a custom inference graph.
 
@@ -405,12 +524,11 @@ def gen_genai(model_id,
     model = onnx.load(model_path)
     model_trainable_weights = {}
 
-    new_model_namepath = f'{new_model_path}/{new_model_name}.onnx'
+    new_model_namepath = f"{new_model_path}/{new_model_name}.onnx"
 
     if weight_input and training_config:
-
         requires_grad_layers = training_config["requires_grad"]
-        
+
         # Extract initializers from the model
         initializers = {init.name: init for init in model.graph.initializer}
 
@@ -428,56 +546,62 @@ def gen_genai(model_id,
 
                 # Remove initializer since it becomes the input
                 model.graph.initializer.remove(initializer)
-        
+
         # Create a new list of inputs (existing inputs + new inputs for specified initializers)
         new_graph_inputs = list(model.graph.input) + new_inputs
-        
+
         # Remove the specified initializers from the model
         new_initializers = [init for init in model.graph.initializer if init.name not in requires_grad_layers]
-        
+
         # Create a new graph with updated inputs and removed initializers
         new_graph = helper.make_graph(
             nodes=model.graph.node,
             name=model.graph.name,
             inputs=new_graph_inputs,
             outputs=model.graph.output,
-            initializer=new_initializers
+            initializer=new_initializers,
         )
-        
+
         # Create a new model with the modified graph
         model = helper.make_model(new_graph, opset_imports=[helper.make_operatorsetid("", opset_version)])
-    
+
     if include_metadata:
-        print(f"[INFO] Adding metadata to the inference model...")
+        print("[INFO] Adding metadata to the inference model...")
         config = AutoConfig.from_pretrained(model_id)
 
-        num_kv_heads = config.num_key_value_heads if hasattr(config, "num_key_value_heads") else config.num_attention_heads
-        head_size = config.head_dim if hasattr(config, "head_dim") else config.hidden_size // config.num_attention_heads
+        num_kv_heads = (
+            config.num_key_value_heads
+            if hasattr(config, "num_key_value_heads")
+            else config.num_attention_heads
+        )
+        head_size = (
+            config.head_dim
+            if hasattr(config, "head_dim")
+            else config.hidden_size // config.num_attention_heads
+        )
         num_layers = config.num_hidden_layers
 
         # Add custom metadata
-        model.metadata_props.append(
-            onnx.StringStringEntryProto(key="model_id", value=str(model_id))
-        )
+        model.metadata_props.append(onnx.StringStringEntryProto(key="model_id", value=str(model_id)))
         model.metadata_props.append(
             onnx.StringStringEntryProto(key="max_context_length", value=str(config.max_position_embeddings))
         )
-        model.metadata_props.append(
-            onnx.StringStringEntryProto(key="head_dim", value=str(head_size))
-        )
-        model.metadata_props.append(
-            onnx.StringStringEntryProto(key="num_kv_heads", value=str(num_kv_heads))
-        )
-        model.metadata_props.append(
-            onnx.StringStringEntryProto(key="num_layers", value=str(num_layers))
-        )
+        model.metadata_props.append(onnx.StringStringEntryProto(key="head_dim", value=str(head_size)))
+        model.metadata_props.append(onnx.StringStringEntryProto(key="num_kv_heads", value=str(num_kv_heads)))
+        model.metadata_props.append(onnx.StringStringEntryProto(key="num_layers", value=str(num_layers)))
 
     # We set size threshold to 0 to force all tensors to be saved as externally and later to be replaced easily in inference session
     if force_external or training_config:
         print("[INFO] Forcing external initializers...")
         model = force_dequantize_external_and_save(model, new_model_namepath)
     print("[INFO] Saving the model...")
-    onnx.save(model, new_model_namepath, save_as_external_data=True, location=f'{new_model_name}.onnx.data', size_threshold=0)
+    onnx.save(
+        model,
+        new_model_namepath,
+        save_as_external_data=True,
+        location=f"{new_model_name}.onnx.data",
+        size_threshold=0,
+    )
 
     if large_model:
         # Wait so it finishes writing to disk
@@ -491,10 +615,19 @@ def gen_genai(model_id,
     print("[INFO] Saved GenAI inference model.")
 
     if test_generation:
-        session = InferenceSession(new_model_namepath, providers=['CPUExecutionProvider'])
-        tokenizer = AutoTokenizer.from_pretrained(model_id, token=os.environ['HF_TOKEN'])
+        session = InferenceSession(new_model_namepath, providers=["CPUExecutionProvider"])
+        tokenizer = AutoTokenizer.from_pretrained(model_id, token=get_settings().require_hf_token())
         config = AutoConfig.from_pretrained(model_id)
-        generate_tokens_onnx(tokenizer, session, config, model_trainable_weights, with_past=True, with_weight_input=weight_input, **test_generation_config)
+        generate_tokens_onnx(
+            tokenizer,
+            session,
+            config,
+            model_trainable_weights,
+            with_past=True,
+            with_weight_input=weight_input,
+            **test_generation_config,
+        )
+
 
 def get_layers_with_grad(model):
     """
@@ -506,6 +639,7 @@ def get_layers_with_grad(model):
             layers_with_grad.append(name)
     return layers_with_grad
 
+
 class CausalLMCE(onnxblock.Block):
     def __init__(self):
         super().__init__()
@@ -517,32 +651,38 @@ def __init__(self):
     def build(self, logits, *args):
         return self._loss1(logits)
 
-def convert_pipeline(model_id,
-                    peft_method,
-                    train_model_name,
-                    train_dir,
-                    inference_model_name,
-                    inference_dir,
-                    embedding_model_path,
-                    build_dir,
-                    gen_train_artifacts = False,
-                    gen_inference_artifacts = False,
-                    gen_rag_config = False,
-                    test_training = True,
-                    test_eval = True,
-                    test_generation = True,
-                    inference_export_config = {},
-                    test_generation_config = {},
-                    inference_config = {},
-                    train_config = {},
-                    rag_config = {},
-                    export_tokenizer = True, 
-                    export_dataset = True,
-                    export_inference_config = True,
-                    export_merger = True,
-                    delete_models=False,
-                    config_file_path="config.yml",
-                    **kwargs):
+
+def convert_pipeline(
+    model_id,
+    peft_method,
+    train_model_name,
+    train_dir,
+    inference_model_name,
+    inference_dir,
+    embedding_model_path,
+    build_dir,
+    gen_train_artifacts=False,
+    gen_inference_artifacts=False,
+    gen_rag_config=False,
+    test_training=True,
+    test_eval=True,
+    test_generation=True,
+    inference_export_config={},
+    test_generation_config={},
+    inference_config={},
+    train_config={},
+    rag_config={},
+    export_tokenizer=True,
+    export_dataset=True,
+    export_inference_config=True,
+    export_merger=True,
+    delete_models=False,
+    # `config/config.yml` is the canonical user-editable YAML (see `config/__init__.py`). This used to
+    # read `"config.yml"` — the repo-root duplicate, which was stale (missing `handoff_mode`) and was
+    # deleted 2026-08-14.
+    config_file_path="config/config.yml",
+    **kwargs,
+):
     """
     ONNX conversion for training, inference, merger and embedding artifacts.
     Creates a build folder with train and inference subfolders each with models needed for tasks.
@@ -555,52 +695,56 @@ def convert_pipeline(model_id,
         # Create the base directory if it doesn't exist
         if not os.path.exists(build_dir):
             os.makedirs(build_dir)
-        
-        train_path = os.path.join(build_dir, 'train')
-        inference_path = os.path.join(build_dir, 'inference')
-        
+
+        train_path = os.path.join(build_dir, "train")
+        inference_path = os.path.join(build_dir, "inference")
+
         os.makedirs(train_path, exist_ok=True)
         os.makedirs(inference_path, exist_ok=True)
-    
+
     except Exception as e:
         print(f"[ERROR] An error occurred: {e}")
-    
+
     extended_train_config = None
     if gen_train_artifacts:
-
         # Add peft method to training config
-        train_config['peftMethod'] = peft_method
-        train_config['modelId'] = model_id
+        train_config["peftMethod"] = peft_method
+        train_config["modelId"] = model_id
 
         # Generate training artifacts
-        extended_train_config = gen_artifacts(train_dir=train_dir, artifact_dir=f'{build_dir}/train', model_name=train_model_name, training_config=train_config)
+        extended_train_config = gen_artifacts(
+            train_dir=train_dir,
+            artifact_dir=f"{build_dir}/train",
+            model_name=train_model_name,
+            training_config=train_config,
+        )
         print("[INFO] Generated training artifacts.")
 
     if test_training:
-        onnx_checktrain(model_dir=f'{build_dir}/train',
-                        model_id=model_id,
-                        test_evaluate=test_eval)
+        onnx_checktrain(model_dir=f"{build_dir}/train", model_id=model_id, test_evaluate=test_eval)
         print("[INFO] Training check completed.")
-    
+
     # Export native inference model
     if gen_inference_artifacts and inference_config["type"] == "native":
-        gen_genai(model_id=model_id,
-                  model_path=f'{inference_dir}/{inference_model_name}',
-                  training_config=extended_train_config,
-                  new_model_name=inference_export_config["output_inference_model"],
-                  new_model_path=f'{build_dir}/inference',
-                  large_model=large_model,
-                  #test_generation=test_generation,
-                  weight_input=inference_export_config["weight_input"],
-                  include_metadata=inference_export_config["include_metadata"],
-                  opset_version=inference_export_config["opset"],
-                  #test_generation_config=test_generation_config,
-                  check_model=inference_export_config["check_model"],
-                  force_external=inference_export_config["force_external_initializers"])
+        gen_genai(
+            model_id=model_id,
+            model_path=f"{inference_dir}/{inference_model_name}",
+            training_config=extended_train_config,
+            new_model_name=inference_export_config["output_inference_model"],
+            new_model_path=f"{build_dir}/inference",
+            large_model=large_model,
+            # test_generation=test_generation,
+            weight_input=inference_export_config["weight_input"],
+            include_metadata=inference_export_config["include_metadata"],
+            opset_version=inference_export_config["opset"],
+            # test_generation_config=test_generation_config,
+            check_model=inference_export_config["check_model"],
+            force_external=inference_export_config["force_external_initializers"],
+        )
         print("[INFO] Generated the artifact inference model graph.")
 
         # Move the rest of the files
-        move_files_excluding(inference_dir, f'{build_dir}/inference', exclude_files=[inference_model_name])
+        move_files_excluding(inference_dir, f"{build_dir}/inference", exclude_files=[inference_model_name])
         print(f"[INFO] Moved the rest of generation configuration files to: {build_dir}/inference")
 
     # NOTE: If the ONNX Runtime versions do not match, you need to use inference.builder to build inference model
@@ -609,48 +753,60 @@ def convert_pipeline(model_id,
 
     # Export generation configuration
     if export_inference_config:
-        with open(f'{build_dir}/inference/generation_config.json', "w", encoding="utf-8") as f:
+        with open(f"{build_dir}/inference/generation_config.json", "w", encoding="utf-8") as f:
             json.dump(inference_config, f, ensure_ascii=False)
 
     # Export tokenizer if needed
     if export_tokenizer:
-        export_tokenizer_config(model_id, build_dir, os.environ['HF_TOKEN'])
+        export_tokenizer_config(model_id, build_dir, get_settings().require_hf_token())
 
     if export_dataset:
         if "taskName" not in train_config or "trainFile" not in train_config:
-            print(f"[WARNING] taskName or trainFile not defined in train_config!")
+            print("[WARNING] taskName or trainFile not defined in train_config!")
         elif train_config["taskName"] not in TASK_NAME_TO_DATASET:
-            print(f"[WARNING] taskName unknown!")
+            print("[WARNING] taskName unknown!")
         else:
-            load_and_save_dataset(TASK_NAME_TO_DATASET[train_config["taskName"]], train_path, train_config["trainFile"], split='train', max_dataset_length=train_config['maxDatasetLength'])
+            load_and_save_dataset(
+                TASK_NAME_TO_DATASET[train_config["taskName"]],
+                train_path,
+                train_config["trainFile"],
+                split="train",
+                max_dataset_length=train_config["maxDatasetLength"],
+            )
 
     if export_merger:
-        if peft_method == "lora":
-            create_lora_merger_model(f'{build_dir}/train/lora_merger_model.onnx', quantized=True)
-            create_lora_merger_model(f'{build_dir}/train/lora_merger_model.onnx', quantized=False)
-        elif peft_method == "mars":
-            # We need both quantized and non-quantized merger models
-            if 'optimization_level' in kwargs["train_builder_config"][peft_method] and kwargs["train_builder_config"][peft_method]['optimization_level'] <= 1:
-                create_mars_merger_model_2(f'{build_dir}/train/mars_merger_model.onnx', quantized_inputs=False, quantized_outputs=inference_export_config["quantized_merged_output"])
-            create_mars_merger_model_2(f'{build_dir}/train/mars_qmerger_model.onnx', quantized_inputs=True, quantized_outputs=inference_export_config["quantized_merged_output"])
-
-            # We also need basic LoRA merger models for this PEFT method
-            create_lora_merger_model_2(f'{build_dir}/train/lora_qmerger_model.onnx', quantized_inputs=True, quantized_outputs=inference_export_config["quantized_merged_output"])
-            create_lora_merger_model_2(f'{build_dir}/train/lora_merger_model.onnx', quantized_inputs=False, quantized_outputs=inference_export_config["quantized_merged_output"])
+        # Registry-driven merger emit (#9): build_merger_model via resolve_merger, descriptive filenames
+        # recorded in the handoff map's mergerModels — replaces the four hand-picked factory calls +
+        # the peft_method == "lora"/"mars" string dispatch. resolve_merger fails closed on unknown method.
+        train_dir = f"{build_dir}/train"
+        quant_out = inference_export_config["quantized_merged_output"]
+        method = PEFTMethod(peft_method)
+        if method is PEFTMethod.MARS:
+            build_cfg = kwargs["train_builder_config"].get(peft_method, {})
+            keep_fp_in = build_cfg.get("optimization_level", 99) <= 1
+            emit_merger_models(
+                train_dir,
+                PEFTMethod.MARS,
+                quant_out=quant_out,
+                quant_ins=((True, False) if keep_fp_in else (True,)),
+            )
+            # MARS packages also carry LoRA mergers for their non-MARS layers (device mixes per-layer).
+            emit_merger_models(train_dir, PEFTMethod.LORA, quant_out=quant_out, quant_ins=(True, False))
         else:
-            raise ValueError("Unsupported PEFT method.")
-        
+            emit_merger_models(train_dir, method, quant_out=quant_out, quant_ins=(True, False))
+
     if gen_rag_config:
         embedding_model_metadata = get_all_metadata_from_onnx(embedding_model_path)
         # Get model id from metadata and export tokenizer in embedding/tokenizer
-        export_tokenizer_config(embedding_model_metadata["model_id"], f'{build_dir}/embedding/', os.environ['HF_TOKEN'])
+        export_tokenizer_config(
+            embedding_model_metadata["model_id"], f"{build_dir}/embedding/", get_settings().require_hf_token()
+        )
 
         # Move onnx embedding model
-        move_onnx_model(embedding_model_path, f'{build_dir}/embedding/', delete=False)
+        move_onnx_model(embedding_model_path, f"{build_dir}/embedding/", delete=False)
 
         # Export embedding config
-        with open(f'{build_dir}/embedding/rag_config.json', "w", encoding="utf-8") as f:
-
+        with open(f"{build_dir}/embedding/rag_config.json", "w", encoding="utf-8") as f:
             # Update embedding config with correct information
             if "embedding_dim" in embedding_model_metadata:
                 rag_config["embeddingDimension"] = embedding_model_metadata["embedding_dim"]
@@ -661,9 +817,10 @@ def convert_pipeline(model_id,
     if delete_models:
         delete_directory(inference_dir)
         delete_directory(train_dir)
-        print(f"[INFO] Deleted previously generated training and inference models.")
+        print("[INFO] Deleted previously generated training and inference models.")
+
 
-def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
+def parse_extra_options(extra_options: list[str]) -> dict[str, str]:
     """
     Parse additional options in KEY=VALUE format into a dictionary.
     """
@@ -674,118 +831,79 @@ def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
             options_dict[key] = value
         else:
             raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
-        
+
     print(f"Extra options: {options_dict}")
     return options_dict
 
-def load_config_from_file(config_file: str):
-    """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
-        config = yaml.safe_load(file)
-    return config
 
 def parse_arguments():
-    parser = argparse.ArgumentParser(description="Converting the given ONNX models into a ONNX artifacts for on-device training and inference.", formatter_class=argparse.RawTextHelpFormatter)
-
-    parser.add_argument(
-        "--model_id",
-        type=str,
-        help="Identifier for the model to be converted."
-    )
-    parser.add_argument(
-        "--build_path",
-        type=str,
-        help="Path to convert the artifact models."
-    )
-    parser.add_argument(
-        "--inference_model",
-        type=str,
-        help="Name of the inference model."
-    )
-    parser.add_argument(
-        "--inference_dir",
-        type=str,
-        help="Path to the inference model directory."
-    )
-    parser.add_argument(
-        "--training_model",
-        type=str,
-        help="Name of the training model."
-    )
-    parser.add_argument(
-        "--embedding_model",
-        type=str,
-        help="Path to the embedding model."
-    )
-    parser.add_argument(
-        "--training_dir",
-        type=str,
-        help="Path to the training model directory."
+    parser = argparse.ArgumentParser(
+        description="Converting the given ONNX models into a ONNX artifacts for on-device training and inference.",
+        formatter_class=argparse.RawTextHelpFormatter,
     )
+
+    parser.add_argument("--model_id", type=str, help="Identifier for the model to be converted.")
+    parser.add_argument("--build_path", type=str, help="Path to convert the artifact models.")
+    parser.add_argument("--inference_model", type=str, help="Name of the inference model.")
+    parser.add_argument("--inference_dir", type=str, help="Path to the inference model directory.")
+    parser.add_argument("--training_model", type=str, help="Name of the training model.")
+    parser.add_argument("--embedding_model", type=str, help="Path to the embedding model.")
+    parser.add_argument("--training_dir", type=str, help="Path to the training model directory.")
     parser.add_argument(
         "--gen_train_artifacts",
         type=bool,
         default=False,
-        help="Whether to generate training artifacts. Default is False."
+        help="Whether to generate training artifacts. Default is False.",
     )
     parser.add_argument(
         "--gen_inference_artifacts",
         type=bool,
         default=False,
-        help="Whether to generate inference artifacts. Default is False."
+        help="Whether to generate inference artifacts. Default is False.",
     )
     parser.add_argument(
         "--gen_rag_config",
         type=bool,
         default=False,
-        help="Whether to generate embedding artifacts. Default is False."
+        help="Whether to generate embedding artifacts. Default is False.",
     )
     parser.add_argument(
         "--test_training",
         type=bool,
         default=True,
-        help="Whether to test training capabilities. Default is True."
+        help="Whether to test training capabilities. Default is True.",
     )
     parser.add_argument(
         "--test_eval",
         type=bool,
         default=True,
-        help="Whether to test evaluation capabilities. Default is True."
+        help="Whether to test evaluation capabilities. Default is True.",
     )
     parser.add_argument(
-        "--delete_models",
-        type=bool,
-        default=True,
-        help="Deletes the previously generated models."
+        "--delete_models", type=bool, default=True, help="Deletes the previously generated models."
     )
     parser.add_argument(
         "--export_tokenizer",
         type=bool,
         default=True,
-        help="Exports tokenizer files and config in seperate dir."
+        help="Exports tokenizer files and config in seperate dir.",
     )
     parser.add_argument(
         "--export_inference_config",
         type=bool,
         default=True,
-        help="Exports inference configuration config in build dir."
+        help="Exports inference configuration config in build dir.",
     )
     parser.add_argument(
         "--config",
         type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
     )
     parser.add_argument(
-        "--export_dataset",
-        type=bool,
-        default=True,
-        help="Exports dataset file in train dir."
+        "--export_dataset", type=bool, default=True, help="Exports dataset file in train dir."
     )
     parser.add_argument(
-        "--export_merger",
-        type=bool,
-        default=True,
-        help="Exports the merger model for adapters."
+        "--export_merger", type=bool, default=True, help="Exports the merger model for adapters."
     )
     parser.add_argument(
         "--inference_export_config",
@@ -796,8 +914,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ...
-            """
-            )
+            """),
     )
     parser.add_argument(
         "--inference_config",
@@ -808,8 +925,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ... TODO add description
-            """
-            )
+            """),
     )
     parser.add_argument(
         "--train_config",
@@ -820,8 +936,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ... TODO add description
-            """
-            )
+            """),
     )
     parser.add_argument(
         "--rag_config",
@@ -832,10 +947,9 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ... TODO add description
-            """
-            )
+            """),
     )
-    #parser.add_argument(
+    # parser.add_argument(
     #    "--test_generation_config",
     #    type=str,
     #    nargs="*",
@@ -852,29 +966,29 @@ def parse_arguments():
     #        top_p = 0.3 : Top P for sampling
     #        """
     #        )
-    #)
+    # )
     args = parser.parse_args()
 
     user_inference_config = {}
     default_user_inference_config = {
-        "type": "genai", # "normal", "genai"
-        "weight_input" : False, # Whether to include trainable weights as model input
-        "test_inference": True, # Whether to perform inference / generation test on the inference exported model
-        "include_metadata": True, # Whether to include the model metadata
-        "output_inference_name": "genai_inference", # The new model name
+        "type": "genai",  # "normal", "genai"
+        "weight_input": False,  # Whether to include trainable weights as model input
+        "test_inference": True,  # Whether to perform inference / generation test on the inference exported model
+        "include_metadata": True,  # Whether to include the model metadata
+        "output_inference_name": "genai_inference",  # The new model name
         "opset_version": 20,
-        "gen_config_file": "genai_config.json"
+        "gen_config_file": "genai_config.json",
     }
 
-    #user_test_generation_config = {}
-    #default_test_generation_config = {
+    # user_test_generation_config = {}
+    # default_test_generation_config = {
     #   "prompt": "Hello, this is a message for the world. How is your day?", # Prompt for test generation
     #        "decode_between": True, # Whether to decode the text while it's generating
     #        "max_length" : 100, # Max length of test sequence to generate
     #       "sampling": "topk", # Sampling method
     #        "temperature": 0.7, # Temperature for sampling
     #        "top_k": 10, # Top K for sampling
-    #}
+    # }
 
     extra_args = {}
 
@@ -884,30 +998,29 @@ def parse_arguments():
         config_dict = load_config_from_file(args.config)
 
         # Specific
-        setattr(args, "model_id", config_dict[TRAIN_CONFIG]["model_id"])
-        setattr(args, "peft_method", config_dict[TRAIN_CONFIG]["train_method"])
-        
+        args.model_id = config_dict[TRAIN_CONFIG]["model_id"]
+        args.peft_method = config_dict[TRAIN_CONFIG]["train_method"]
+
         # Override any command-line argument with values from the config file
         for key, value in config_dict[ARTIFACT_CONFIG].items():
-            
             # Convert to the correct type
             if hasattr(args, key):
                 setattr(args, key, value)
 
-        setattr(args, "training_dir",config_dict[TRAIN_CONFIG]["output"])
-        setattr(args, "inference_dir", config_dict[INFERENCE_CONFIG]["output"])
+        args.training_dir = config_dict[TRAIN_CONFIG]["output"]
+        args.inference_dir = config_dict[INFERENCE_CONFIG]["output"]
 
         extra_args["train_builder_config"] = config_dict[TRAIN_CONFIG]
     else:
         user_inference_config = parse_extra_options(args.inference_config)
         args.inference_export_config = {**default_user_inference_config, **user_inference_config}
-        #user_test_generation_config = parse_extra_options(args.test_generation_config)
-        #args.test_generation_coinfig = {**default_test_generation_config, **user_test_generation_config}
+        # user_test_generation_config = parse_extra_options(args.test_generation_config)
+        # args.test_generation_coinfig = {**default_test_generation_config, **user_test_generation_config}
 
     return args, extra_args
 
-if __name__ == "__main__":
 
+if __name__ == "__main__":
     args, extra_args = parse_arguments()
 
     print(f"{ARTIFACT_CONFIG} arguments:")
@@ -929,8 +1042,8 @@ def parse_arguments():
         test_training=args.test_training,
         test_eval=args.test_eval,
         # We avoid testing generation in this script due to package conflicts
-        #test_generation=args.test_generation,
-        #test_generation_config=args.test_generation_config
+        # test_generation=args.test_generation,
+        # test_generation_config=args.test_generation_config
         inference_export_config=args.inference_export_config,
         export_tokenizer=args.export_tokenizer,
         inference_config=args.inference_config,
@@ -941,5 +1054,5 @@ def parse_arguments():
         export_merger=args.export_merger,
         delete_models=args.delete_models,
         config_file_path=args.config,
-        **extra_args
-    )
\ No newline at end of file
+        **extra_args,
+    )
diff --git a/src/mobiletransformers/artifacts/checkpoint_names.py b/src/mobiletransformers/artifacts/checkpoint_names.py
new file mode 100644
index 0000000..b033cd2
--- /dev/null
+++ b/src/mobiletransformers/artifacts/checkpoint_names.py
@@ -0,0 +1,143 @@
+"""Export-time proof that the handoff map names parameters the checkpoint actually contains.
+
+## Why this exists
+
+`weight_handoff_map.json` records a `trainingBaseLayerName` per entry. At merge time the on-device
+`WeightMerger` turns that name into checkpoint parameter lookups (`<layer>.base_layer.weight`,
+`.weight_scale`, …) and asks `Ort::CheckpointState` for them. Nothing ever checked that those lookups
+could succeed, so a name-shape disagreement between producer and consumer was undetectable until a
+phone ran the merge — and it was undetectable *there* too, for a while, because the merge reported
+success having merged nothing.
+
+Three separate defects were this one gap:
+
+* the C++ asked for `<layer>.weight`; peft stores the frozen weight under `<layer>.base_layer.weight`,
+  so no layer ever resolved;
+* `find_handoff_entry` varied the `.base_layer` suffix but not the `base_model.model.model.` /
+  `backbone.model.` prefix, so all 60 merges wrote nothing;
+* the quantized roles (`.weight_scale` / `.weight_zero_point`) were derived by the same unchecked rule
+  and are equally wrong whenever the non-quantized one is.
+
+Each cost a full export → push → run cycle to find. This check runs on the host in milliseconds and
+fails the export instead.
+
+## How it reads the checkpoint
+
+ORT's checkpoint is a flatbuffer; `CheckpointState.load_checkpoint` in ORT 1.23 exposes no iterable
+`.parameters`, and requiring `onnxruntime-training` here would make a core-profile export depend on the
+heaviest optional profile. Parameter names are stored as plain UTF-8 in the file, so membership is an
+exact byte-substring test — no parsing, no schema assumptions, no false "present" answers. The
+direction that matters is one-way: we assert names ARE there, never enumerate what is.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: Mirrors `cpp/layer_name.h`, `packages/WeightHandoffMap.kt` and
+#: `handoff_map._TRAINING_WRAPPER_PREFIXES`. One wire format, four implementations — if this changes,
+#: change it in all four.
+#:
+#: **The rule is the WRAPPER pair, not a model's module path.** peft wraps the model as
+#: `base_model.model.<hf-path>` and the ORT training wrapper as `backbone.<hf-path>`, so converting one
+#: to the other strips `base_model.model.` and prepends `backbone.` — whatever `<hf-path>` starts with.
+#:
+#: These constants used to read `base_model.model.model.` / `backbone.model.`, which is that same rule
+#: with a decoder's own first module (`model.layers…`) baked in. It produced identical output for every
+#: decoder, and matched NOTHING for an encoder: BERT's path is `bert.encoder.layer…`, so all 12 handoff
+#: entries resolved to a parameter no checkpoint contains and the #33 encoder export failed closed
+#: (correctly — the check exists for exactly this) with
+#: `base_model.model.bert.…base_layer.weight` against a checkpoint holding
+#: `backbone.bert.…base_layer.weight`.
+RAW_PREFIX = "base_model.model."
+CHECKPOINT_PREFIX = "backbone."
+BASE_LAYER_SUFFIX = ".base_layer"
+
+#: The roles `WeightMerger::extract_base_layer_params` looks up. `weight` is required; the quantized
+#: companions are only expected when the package is quantized, so their absence is not an error here.
+REQUIRED_ROLE = "weight"
+
+
+def to_checkpoint_name(name: str) -> str:
+    """`base_model.model.<path>` -> `backbone.<path>`; twin of `layer_name::to_checkpoint`.
+
+    Decoder: `base_model.model.model.layers.0…` -> `backbone.model.layers.0…` (unchanged from before).
+    Encoder: `base_model.model.bert.encoder.layer.0…` -> `backbone.bert.encoder.layer.0…`.
+    """
+    if name.startswith(RAW_PREFIX):
+        return CHECKPOINT_PREFIX + name[len(RAW_PREFIX) :]
+    return name
+
+
+def with_base_layer(name: str) -> str:
+    """Append `.base_layer` unless already present. Idempotent."""
+    return name if name.endswith(BASE_LAYER_SUFFIX) else name + BASE_LAYER_SUFFIX
+
+
+def checkpoint_weight_param(training_base_layer_name: str, role: str = REQUIRED_ROLE) -> str:
+    """The exact checkpoint parameter the device merger will ask for."""
+    return f"{with_base_layer(to_checkpoint_name(training_base_layer_name))}.{role}"
+
+
+def verify_handoff_names_resolve(
+    handoff_map_path: str | Path,
+    checkpoint_path: str | Path,
+) -> list[str]:
+    """Assert every `trainingBaseLayerName` resolves to a real checkpoint parameter.
+
+    Returns the resolved parameter names (one per entry) so callers can log the count.
+
+    Raises:
+        ExportError: naming the first few unresolved parameters. Fails closed: a package whose merge
+            cannot possibly work must not be published as if it can.
+    """
+    import json
+
+    handoff_map_path = Path(handoff_map_path)
+    checkpoint_path = Path(checkpoint_path)
+    if not checkpoint_path.is_file():
+        raise ExportError(f"checkpoint not found for handoff-name verification: {checkpoint_path}")
+
+    data = json.loads(handoff_map_path.read_text(encoding="utf-8"))
+    entries = data.get("entries", [])
+    if not entries:
+        raise ExportError(f"{handoff_map_path} declares no entries; nothing could be merged on device")
+
+    blob = checkpoint_path.read_bytes()
+
+    resolved: list[str] = []
+    missing: list[str] = []
+    for entry in entries:
+        training_name = entry.get("trainingBaseLayerName")
+        if not training_name:
+            missing.append(f"<entry {entry.get('inferenceName', '?')} has no trainingBaseLayerName>")
+            continue
+        param = checkpoint_weight_param(training_name)
+        if param.encode("utf-8") in blob:
+            resolved.append(param)
+        else:
+            missing.append(param)
+
+    if missing:
+        shown = "\n  ".join(missing[:5])
+        more = f"\n  … and {len(missing) - 5} more" if len(missing) > 5 else ""
+        raise ExportError(
+            f"{len(missing)} of {len(entries)} handoff entries name a checkpoint parameter that does "
+            f"not exist in {checkpoint_path.name}. The on-device merge would find no base weight for "
+            f"these layers:\n  {shown}{more}\n"
+            "This is a producer/consumer name-shape disagreement — reconcile "
+            "artifacts/checkpoint_names.py, cpp/layer_name.h and artifacts/handoff_map.py, which must "
+            "all describe the same wire format."
+        )
+
+    logger.info(
+        "handoff-name check: %d/%d trainingBaseLayerName(s) resolve to real checkpoint parameters",
+        len(resolved),
+        len(entries),
+    )
+    return resolved
diff --git a/src/mobiletransformers/artifacts/graph_prep.py b/src/mobiletransformers/artifacts/graph_prep.py
new file mode 100644
index 0000000..8bca004
--- /dev/null
+++ b/src/mobiletransformers/artifacts/graph_prep.py
@@ -0,0 +1,75 @@
+"""ONNX graph fixes a model needs before ORT can build a gradient graph from it.
+
+Pure ``onnx`` — no ``onnxruntime`` — so it imports (and is testable) in the core profile, unlike
+``artifacts/builder.py``, which pulls the training runtime at module scope.
+
+Everything here exists because a graph that is perfectly valid for **inference** can still be
+un-differentiable: ORT's gradient builders read specific forward-node outputs, and exporters omit the
+optional ones nothing else consumes.
+"""
+
+from __future__ import annotations
+
+import os
+
+import onnx
+
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: Suffix for the graph rewritten to be gradient-buildable. Written beside the source model so its
+#: RELATIVE external-data references keep resolving.
+TRAIN_READY_SUFFIX = ".gradready.onnx"
+
+
+def ensure_layernorm_grad_outputs(onnx_model_path: str | os.PathLike[str]) -> str:
+    """Give ``LayerNormalization`` its optional ``Mean``/``InvStdDev`` outputs (#33).
+
+    ORT's ``LayerNormalizationGrad`` reads the forward node's **second and third outputs** — the saved
+    mean and inverse standard deviation — rather than recomputing them. ``torch.onnx`` exports the node
+    with only ``Y``, so building a gradient graph through it trips an assertion deep inside ORT:
+
+        GradientBuilderBase::O(size_t, bool) const i < node_->OutputDefs().size() was false
+
+    which names neither the op nor the node. Finding it took bisecting the trainable set until the
+    failure boundary landed between the pooler (OK) and the encoder layers (fail).
+
+    Decoders never hit it: Llama-family RMSNorm exports as ``SimplifiedLayerNormalization``, which
+    already carries 2 outputs — verified on the shipped decoder package, 61 of them, each with a
+    matching ``SimplifiedLayerNormalizationGrad``. BERT-family encoders use real LayerNorm, so encoder
+    support was the first thing to need this.
+
+    Adding the outputs is safe: the ONNX spec declares them optional, ORT's kernel fills them when
+    present, and nothing downstream consumes them except the gradient builder.
+
+    Returns:
+        The path to hand to ``generate_artifacts`` — the original when nothing needed rewriting, else
+        a sibling file (written next to the source so relative external-data references resolve).
+    """
+    onnx_model_path = os.fspath(onnx_model_path)
+    model = onnx.load(onnx_model_path, load_external_data=False)
+
+    patched = 0
+    for node in model.graph.node:
+        if node.op_type != "LayerNormalization" or len(node.output) >= 3:
+            continue
+        stem = node.name or node.output[0]
+        while len(node.output) < 3:
+            # Order is fixed by the spec: Y, Mean, InvStdDev.
+            suffix = "_saved_mean" if len(node.output) == 1 else "_saved_inv_std"
+            node.output.append(f"{stem}{suffix}")
+        patched += 1
+
+    if not patched:
+        return onnx_model_path
+
+    out_path = onnx_model_path + TRAIN_READY_SUFFIX
+    onnx.save(model, out_path)
+    logger.info(
+        "added Mean/InvStdDev outputs to %d LayerNormalization node(s) so ORT can build their "
+        "gradients; training artifacts will be generated from %s",
+        patched,
+        os.path.basename(out_path),
+    )
+    return out_path
diff --git a/src/mobiletransformers/artifacts/handoff_map.py b/src/mobiletransformers/artifacts/handoff_map.py
new file mode 100644
index 0000000..5949166
--- /dev/null
+++ b/src/mobiletransformers/artifacts/handoff_map.py
@@ -0,0 +1,686 @@
+"""``weight_handoff_map.json`` schema + ``TrainableTensorCodec`` — the ONE source of tensor identity.
+
+This module OWNS the handoff-map contract (schemaVersion 1.0). It replaces the implicit four-way name
+agreement between the merge writer (``weight_merger.cpp``), the load side (``session_cache.h``), and the
+inference graph (``inference/builder.py``) with one declarative artifact. Every consumer (#9 merger, #13
+manifest, #23 native load) reads this shape; none may redefine it.
+
+**Boundary for this cycle (#8):** the Python owner layer — the dataclasses, deterministic
+serialization, fail-closed ``validate()``, and the codec join — all pure and fully tested. The
+build-side *emit* wiring (accumulating observed initializer names in the inference-graph builder;
+feeding ``peft_mapping`` at export time) and the C++/Kotlin consumers ride with their integration plans
+(#9 owns the on-device merge/save; #23 the map-driven load), exactly as #6/#7 deferred cross-boundary
+consumption. The contract here is what those plans build against.
+
+Consumes #6: adapter role vocabulary from ``PEFTMethodSpec.component_schema`` and the name-rewrite rule
+(attention-module name) from ``ArchitectureSpec`` — no naming is hand-rolled here.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.artifacts.checkpoint_names import to_checkpoint_name
+from mobiletransformers.artifacts.versioning import check_compat
+from mobiletransformers.config.constants import HandoffMode
+from mobiletransformers.config.registry.architecture import DEFAULT_ATTENTION_MODULE_NAME
+from mobiletransformers.exceptions import HandoffError
+
+#: Reader schema version for this contract (see ``check_compat``). Bump only when the reader learns a
+#: new schema.
+#: What THIS reader understands. Must be >= any map's `minReaderVersion`; a map at a higher
+#: MINOR version than this still loads (additive fields are ignored).
+HANDOFF_MAP_READER_VERSION = "1.1"
+
+#: Deterministic role order within an entry (JSON is additionally sort_keys=True for byte-stability).
+ROLE_ORDER = ("weight", "weight_quantized", "scale", "zero_point")
+_QUANTIZED_ROLES = ("weight_quantized", "scale", "zero_point")
+
+#: The on-disk inference weight is stored in the SAME orientation the merger computes in.
+NO_TRANSPOSE = "no_transpose"
+#: The on-disk inference weight is the TRANSPOSE of the merger's orientation, so a merged tensor must
+#: be transposed before it is written back.
+ALREADY_TRANSPOSED = "already_transposed_for_inference"
+
+
+def derive_transpose_policy(
+    weight_shape: tuple[int, ...],
+    adapter_shapes: dict[str, tuple[int, ...]],
+) -> str:
+    """Which orientation the on-disk inference weight is in, relative to the merger's.
+
+    **This replaces a field that was never assigned.** ``ObservedInit.transposed`` defaulted to
+    ``False`` and nothing in the codebase ever set it, so every package ever produced declared
+    ``no_transpose`` by omission — including packages where it was demonstrably wrong. The merge
+    honoured that value and wrote every weight transposed, undetected by four independent gates —
+    a norm, a sum, a byte count and a checksum are all transpose-invariant, so none of them can
+    detect a permutation of elements.
+
+    The orientation is *observable*, so it is observed rather than declared. The merger computes
+    ``base + scale * (adapter_B @ adapter_A)``, whose shape is ``(B.rows, A.cols)``. If that equals the
+    on-disk weight shape the two orientations agree; if it equals its reverse, the on-disk tensor is
+    the transpose.
+
+    Square weights are genuinely ambiguous from shape alone — ``[576,576]`` satisfies both — which is
+    exactly why the defect survived: the adapted decoder layers are ``q_proj`` (square) and ``v_proj``
+    (not). Callers should resolve a package-wide policy from the entries that *can* be decided; see
+    :func:`resolve_package_transpose_policy`.
+    """
+    # The down-projection is `adapter_A` under LoRA and `shared_A` under MARS — MARS shares one A
+    # across the layers of a block, which is what the method IS, so the name differs by design.
+    #
+    # Reading only `adapter_A` made every MARS layer take the fail-open branch below and declare
+    # `no_transpose` for an orientation that is fully observable. That is the same shape as the defect
+    # this function was written to kill: a value nobody computed, honoured by a consumer. Caught by
+    # `test_the_derivation_agrees_with_a_real_exported_package` on the first MARS package ever
+    # exported (2026-08-17, gemma-3-270m-it) — the test reads a real artifact for exactly this reason.
+    a = adapter_shapes.get("adapter_A") or adapter_shapes.get("shared_A")
+    b = adapter_shapes.get("adapter_B")
+
+    if b and not a:
+        # B described but A under neither known name: a THIRD convention this function does not
+        # understand. Refuse rather than default — silently returning `no_transpose` here is precisely
+        # how every merged weight came to be written transposed.
+        raise ValueError(
+            f"adapter shapes {sorted(adapter_shapes)} describe an up-projection but no "
+            "down-projection under `adapter_A` or `shared_A`, so orientation cannot be observed. "
+            "Teach this function the new name rather than letting it guess."
+        )
+
+    if not a or not b or len(a) != 2 or len(b) != 2 or len(weight_shape) != 2:
+        # Nothing to observe (no adapters described, or not a 2-D weight): keep the historical value
+        # rather than inventing one.
+        return NO_TRANSPOSE
+    delta = (b[0], a[1])
+    if tuple(weight_shape) == delta:
+        return NO_TRANSPOSE
+    if tuple(weight_shape) == delta[::-1]:
+        return ALREADY_TRANSPOSED
+    raise ValueError(
+        f"adapter factors {b} @ {a} produce a {delta} delta, which is neither the on-disk weight "
+        f"shape {tuple(weight_shape)} nor its transpose. The merge would add tensors that cannot be "
+        f"added; refusing to describe this layer."
+    )
+
+
+def resolve_package_transpose_policy(entries: Sequence[HandoffEntry]) -> str:
+    """One orientation for the whole package, decided by the entries that are not square.
+
+    A single export uses one convention throughout, so an unambiguous layer settles it for the
+    ambiguous (square) ones. Fails closed when non-square layers disagree with each other — that would
+    mean the package mixes conventions, which no consumer could honour.
+    """
+    decided = {
+        e.transpose_policy
+        for e in entries
+        if len(e.shape) == 2 and e.shape[0] != e.shape[1] and e.adapter_shapes
+    }
+    if len(decided) > 1:
+        raise ValueError(
+            f"handoff entries disagree about weight orientation ({sorted(decided)}); a package must "
+            "use one convention throughout"
+        )
+    return decided.pop() if decided else NO_TRANSPOSE
+
+
+#: Inference-graph initializer suffix -> handoff role. The (deferred) inference-export accumulation
+#: uses this to tag each observed initializer; recorded here so both sides share one mapping.
+INFERENCE_SUFFIX_TO_ROLE = {
+    "weight": "weight",  # fp16/fp32 MatMul weight
+    "qweight": "weight_quantized",  # int4 packed weight
+    "scales": "scale",
+    "qzeros": "zero_point",
+}
+
+_DEFAULT_ENGINES = ("native", "genai")
+
+
+@dataclass(frozen=True)
+class TensorSpec:
+    """Deterministic description of one trainable tensor role (codec-internal view of an entry)."""
+
+    name: str  # canonical inference name
+    dtype: str  # "float16" | "float32" | "int8" | "uint8" | "int4"
+    shape: tuple[int, ...]
+    role: str  # "weight" | "weight_quantized" | "scale" | "zero_point"
+    transpose_policy: str
+    aggregation_role: str  # "merged_base_plus_adapter" | "frozen" | "adapter_only"
+
+
+@dataclass(frozen=True)
+class ObservedInit:
+    """One initializer as actually emitted by the inference-graph builder (the codec's ground truth).
+
+    The inference-export accumulation (deferred to the inference-builder migration) produces these;
+    the codec joins them against the training-side ``peft_mapping`` so names are *observed*, never
+    re-derived — a canonical/observed disagreement raises at build time, not silently at runtime."""
+
+    name: str
+    dtype: str
+    shape: tuple[int, ...]
+    role: str
+
+    # NOTE: a `transposed: bool = False` field used to live here and was the sole input to
+    # `transposePolicy`. **Nothing in the codebase ever assigned it**, so every package ever produced
+    # declared `no_transpose` by omission, the on-device merge honoured that, and every merged weight
+    # was written transposed (2026-08-14; a magnitude-based check cannot
+    # detect a permutation"). It is deliberately NOT re-added: the orientation is observable from the
+    # adapter and weight shapes, so `derive_transpose_policy` observes it instead of trusting a flag
+    # someone must remember to set.
+
+
+@dataclass
+class HandoffEntry:
+    """One trainable MatMul's full identity across train -> merge -> inference."""
+
+    training_base_layer_name: str
+    #: Entry-level dtype/shape: the *weight-like* role's. Kept for compatibility and as the fallback
+    #: for readers that predate ``tensorDtypes``/``tensorShapes``.
+    dtype: str
+    shape: tuple[int, ...]
+    #: Per-role on-disk dtype/shape, one pair per role in ``external_data_location``. Required by the
+    #: device loader: each ``<name>.bin`` holds RAW external-data bytes with no header, so the reader
+    #: has no other way to learn the element type and shape of a packed ``weight_quantized`` / ``scale``
+    #: / ``zero_point`` tensor, whose layout differs from the entry-level weight's.
+    tensor_dtypes: dict[str, str] = field(default_factory=dict)
+    tensor_shapes: dict[str, tuple[int, ...]] = field(default_factory=dict)
+    checkpoint_names: dict[str, str] = field(default_factory=dict)
+    #: Per-adapter-role dtype/shape of the TRAINING-side factors (`adapter_A`, `adapter_B`,
+    #: `shared_A`, `intermediate`), read from the training graph's initializers at artifact time.
+    #:
+    #: `checkpoint_names` already NAMED these; nothing described them, so the map was the single
+    #: source of tensor identity for the merged inference initializers only. A consumer exchanging the
+    #: factors themselves (#35 rank-r federation, #36's Kotlin codec) had to infer shapes from the
+    #: rank. ADDITIVE: absent on packages exported before this, and readers tolerate unknown fields by
+    #: the canonical rule, so this is a minor `schemaVersion` bump rather than a breaking one.
+    adapter_dtypes: dict[str, str] = field(default_factory=dict)
+    adapter_shapes: dict[str, tuple[int, ...]] = field(default_factory=dict)
+    merger_output_names: dict[str, str] = field(default_factory=dict)
+    merged_tensor_names: dict[str, str] = field(default_factory=dict)
+    inference_initializer_names: dict[str, str] = field(default_factory=dict)
+    external_data_location: dict[str, str] = field(default_factory=dict)
+    sha256: dict[str, str] = field(default_factory=dict)
+    genai_input_names: dict[str, str] = field(default_factory=dict)
+    quantization: dict[str, str] | None = None
+    transpose_policy: str = "no_transpose"
+
+    @property
+    def roles(self) -> tuple[str, ...]:
+        present = set(self.inference_initializer_names)
+        return tuple(r for r in ROLE_ORDER if r in present)
+
+    @property
+    def is_quantized(self) -> bool:
+        return self.quantization is not None or any(
+            r in self.inference_initializer_names for r in _QUANTIZED_ROLES
+        )
+
+    def dtype_for(self, role: str) -> str:
+        """On-disk dtype of ``role``'s ``.bin``, falling back to the entry-level weight dtype."""
+        return self.tensor_dtypes.get(role, self.dtype)
+
+    def shape_for(self, role: str) -> tuple[int, ...]:
+        """On-disk shape of ``role``'s ``.bin``, falling back to the entry-level weight shape."""
+        return self.tensor_shapes.get(role, self.shape)
+
+    def tensor_specs(self) -> list[TensorSpec]:
+        """One :class:`TensorSpec` per role, in canonical role order."""
+        specs = []
+        for role in self.roles:
+            specs.append(
+                TensorSpec(
+                    name=self.inference_initializer_names[role],
+                    # Per-role, not the entry-level weight's: a scale/zero_point tensor has its own
+                    # dtype and shape, and reporting the weight's here was silently wrong.
+                    dtype=self.dtype_for(role),
+                    shape=self.shape_for(role),
+                    role=role,
+                    transpose_policy=self.transpose_policy,
+                    aggregation_role="merged_base_plus_adapter",
+                )
+            )
+        return specs
+
+    #: Adapter roles in a canonical, deterministic order. Federated exchange serializes in this order
+    #: within each entry, exactly as the merged path serializes in `ROLE_ORDER`.
+    ADAPTER_ROLE_ORDER: tuple[str, ...] = ("shared_A", "intermediate", "adapter_A", "adapter_B")
+
+    def adapter_tensor_specs(self) -> list[TensorSpec]:
+        """One :class:`TensorSpec` per ADAPTER factor, in canonical adapter-role order.
+
+        The rank-r counterpart of :meth:`tensor_specs`. That one describes the MERGED inference
+        initializer (one full-size weight per adapted layer); this one describes the factors the
+        optimizer actually updates (`lora_A` + `lora_B`, or MARS's shared pair), which is what
+        federation exchanges as of #35's vocabulary decision.
+
+        Empty when the map predates the adapter-identity fields — the caller decides whether that is
+        fatal, because silently falling back to the merged specs is precisely the ambiguity that made
+        the two vocabularies collide in the first place.
+        """
+        specs = []
+        for role in self.ADAPTER_ROLE_ORDER:
+            if role not in self.adapter_dtypes or role not in self.adapter_shapes:
+                continue
+            specs.append(
+                TensorSpec(
+                    # The ORT CHECKPOINT PARAMETER name, not the raw PEFT module path: this is the
+                    # identity a client looks the tensor up by, and #36's Kotlin codec mirrors it.
+                    # `to_checkpoint_name` is the existing normalizer (twin of `cpp/layer_name.h`).
+                    name=f"{to_checkpoint_name(self.checkpoint_names[role])}.weight",
+                    dtype=self.adapter_dtypes[role],
+                    shape=self.adapter_shapes[role],
+                    role=role,
+                    transpose_policy=self.transpose_policy,
+                    aggregation_role="adapter_only",
+                )
+            )
+        return specs
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {
+            "trainingBaseLayerName": self.training_base_layer_name,
+            "checkpointNames": dict(self.checkpoint_names),
+            "adapterDtypes": dict(self.adapter_dtypes),
+            "adapterShapes": {r: list(sh) for r, sh in self.adapter_shapes.items()},
+            "mergerOutputNames": dict(self.merger_output_names),
+            "mergedTensorNames": dict(self.merged_tensor_names),
+            "inferenceInitializerNames": dict(self.inference_initializer_names),
+            "externalDataLocation": dict(self.external_data_location),
+            "sha256": dict(self.sha256),
+            "genaiInputNames": dict(self.genai_input_names),
+            "dtype": self.dtype,
+            "shape": list(self.shape),
+            "tensorDtypes": dict(self.tensor_dtypes),
+            "tensorShapes": {role: list(shape) for role, shape in self.tensor_shapes.items()},
+            "transposePolicy": self.transpose_policy,
+        }
+        if self.quantization is not None:
+            out["quantization"] = dict(self.quantization)
+        return out
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> HandoffEntry:
+        return cls(
+            training_base_layer_name=data["trainingBaseLayerName"],
+            dtype=data["dtype"],
+            shape=tuple(data.get("shape", [])),
+            tensor_dtypes=dict(data.get("tensorDtypes", {})),
+            tensor_shapes={role: tuple(shape) for role, shape in data.get("tensorShapes", {}).items()},
+            checkpoint_names=dict(data.get("checkpointNames", {})),
+            # Absent on packages exported before the adapter-identity fields existed; an empty dict
+            # simply means "this map cannot describe the factors", which readers must handle.
+            adapter_dtypes=dict(data.get("adapterDtypes", {})),
+            adapter_shapes={role: tuple(shape) for role, shape in data.get("adapterShapes", {}).items()},
+            merger_output_names=dict(data.get("mergerOutputNames", {})),
+            merged_tensor_names=dict(data.get("mergedTensorNames", {})),
+            inference_initializer_names=dict(data.get("inferenceInitializerNames", {})),
+            external_data_location=dict(data.get("externalDataLocation", {})),
+            sha256=dict(data.get("sha256", {})),
+            genai_input_names=dict(data.get("genaiInputNames", {})),
+            quantization=dict(data["quantization"]) if data.get("quantization") is not None else None,
+            transpose_policy=data.get("transposePolicy", "no_transpose"),
+        )
+
+
+@dataclass
+class HandoffMap:
+    """The whole ``weight_handoff_map.json`` document."""
+
+    entries: list[HandoffEntry] = field(default_factory=list)
+    handoff_mode: HandoffMode = HandoffMode.EXTERNAL_INITIALIZER
+    #: 1.1 adds `adapterDtypes`/`adapterShapes` per entry — purely ADDITIVE, so this is a MINOR bump
+    #: and `min_reader_version` deliberately stays 1.0: a 1.0 reader ignores the new fields by the
+    #: canonical unknown-fields rule and keeps working, and packages written at 1.0 still load.
+    schema_version: str = "1.1"
+    min_reader_version: str = "1.0"
+    engines: tuple[str, ...] = _DEFAULT_ENGINES
+    external_data_layout: str = "one_file_per_tensor"
+    frozen_base_blob: str = "frozen_base.onnx.data"
+    merger_models: dict[str, str] = field(default_factory=dict)
+
+    def _sorted_entries(self) -> list[HandoffEntry]:
+        """Entries sorted by their canonical weight name (byte-deterministic serialization)."""
+
+        def key(e: HandoffEntry) -> str:
+            return e.inference_initializer_names.get("weight") or e.training_base_layer_name
+
+        return sorted(self.entries, key=key)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schemaVersion": self.schema_version,
+            "minReaderVersion": self.min_reader_version,
+            "handoffMode": self.handoff_mode.value,
+            "engines": list(self.engines),
+            "externalDataLayout": self.external_data_layout,
+            "frozenBaseBlob": self.frozen_base_blob,
+            "mergerModels": dict(self.merger_models),
+            "entries": [e.to_dict() for e in self._sorted_entries()],
+        }
+
+    def to_json(self) -> str:
+        """Byte-deterministic JSON (sorted keys + sorted entries) for stable checksums (#13)."""
+        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> HandoffMap:
+        return cls(
+            entries=[HandoffEntry.from_dict(e) for e in data.get("entries", [])],
+            handoff_mode=HandoffMode(data.get("handoffMode", HandoffMode.EXTERNAL_INITIALIZER.value)),
+            schema_version=data.get("schemaVersion", "1.0"),
+            min_reader_version=data.get("minReaderVersion", "1.0"),
+            engines=tuple(data.get("engines", _DEFAULT_ENGINES)),
+            external_data_layout=data.get("externalDataLayout", "one_file_per_tensor"),
+            frozen_base_blob=data.get("frozenBaseBlob", "frozen_base.onnx.data"),
+            merger_models=dict(data.get("mergerModels", {})),
+        )
+
+    @classmethod
+    def load(cls, path: str | Path) -> HandoffMap:
+        """Parse + version-gate + validate a map file. Fail closed on any problem."""
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+        check_compat(
+            data.get("schemaVersion", "1.0"),
+            data.get("minReaderVersion", "1.0"),
+            HANDOFF_MAP_READER_VERSION,
+        )
+        handoff_map = cls.from_dict(data)
+        handoff_map.validate()
+        return handoff_map
+
+    def save(self, path: str | Path) -> None:
+        self.validate()
+        Path(path).write_text(self.to_json(), encoding="utf-8")
+
+    def validate(self) -> None:
+        """Enforce the handoff-map invariants. Raise :class:`HandoffError` naming the offender."""
+        check_compat(self.schema_version, self.min_reader_version, HANDOFF_MAP_READER_VERSION)
+
+        # v1 supports only external_initializer; the other modes are fail-closed stubs (F7).
+        if self.handoff_mode != HandoffMode.EXTERNAL_INITIALIZER:
+            raise HandoffError(
+                f"handoffMode {self.handoff_mode.value!r} is not supported in this version "
+                "(v1 supports only 'external_initializer')"
+            )
+
+        seen_external: dict[str, str] = {}
+        seen_inference: dict[str, str] = {}
+        for entry in self.entries:
+            where = entry.training_base_layer_name
+
+            # external_initializer: the merged name the writer stamps MUST equal the inference name.
+            for role, inf_name in entry.inference_initializer_names.items():
+                merged = entry.merged_tensor_names.get(role)
+                if merged is None:
+                    raise HandoffError(f"{where}: role {role!r} missing mergedTensorNames entry")
+                if merged != inf_name:
+                    raise HandoffError(
+                        f"{where}: mergedTensorNames[{role!r}]={merged!r} != "
+                        f"inferenceInitializerNames[{role!r}]={inf_name!r} (external_initializer)"
+                    )
+
+            # Quantized names MUST come from the observed inference initializers, never base_layer_name.
+            if entry.quantization is not None:
+                for map_key, role in (
+                    ("weightQuantizedName", "weight_quantized"),
+                    ("scaleName", "scale"),
+                    ("zeroPointName", "zero_point"),
+                ):
+                    q_name = entry.quantization.get(map_key)
+                    obs_name = entry.inference_initializer_names.get(role)
+                    if q_name is None or obs_name is None:
+                        raise HandoffError(f"{where}: quantized entry missing {map_key!r}/{role!r} name")
+                    if q_name != obs_name:
+                        raise HandoffError(
+                            f"{where}: quantization[{map_key!r}]={q_name!r} must equal the observed "
+                            f"inference initializer {obs_name!r} (not derived from base_layer_name)"
+                        )
+
+            # Every role with a .bin must declare its OWN on-disk dtype/shape: the device loader reads
+            # raw external-data bytes (no TensorProto header), so a missing pair leaves the tensor
+            # unloadable. Entries predating tensorDtypes/tensorShapes carry neither and fall back to
+            # the entry-level pair — sound only for a single non-quantized role, hence the extra gate.
+            if entry.tensor_dtypes or entry.tensor_shapes:
+                for role in entry.external_data_location:
+                    if role not in entry.tensor_dtypes:
+                        raise HandoffError(f"{where}: role {role!r} missing tensorDtypes entry")
+                    if role not in entry.tensor_shapes:
+                        raise HandoffError(f"{where}: role {role!r} missing tensorShapes entry")
+            elif entry.quantization is not None:
+                raise HandoffError(
+                    f"{where}: quantized entry must declare per-role tensorDtypes/tensorShapes "
+                    "(the entry-level dtype/shape describes only the weight-like role)"
+                )
+
+            # No two entries may claim the same external file or the same inference initializer name.
+            for loc in entry.external_data_location.values():
+                if loc in seen_external:
+                    raise HandoffError(
+                        f"duplicate externalDataLocation {loc!r} ({where} and {seen_external[loc]})"
+                    )
+                seen_external[loc] = where
+            for inf_name in entry.inference_initializer_names.values():
+                if inf_name in seen_inference:
+                    raise HandoffError(
+                        f"duplicate inferenceInitializerName {inf_name!r} "
+                        f"({where} and {seen_inference[inf_name]})"
+                    )
+                seen_inference[inf_name] = where
+
+
+#: Wrapper prefixes the training stack puts in front of the model's own module path. `OnnxTrainerWrapper`
+#: contributes ``backbone.``; peft's ``get_peft_model`` contributes ``base_model.model.`` — so a LoRA'd
+#: SmolLM2 layer arrives as ``base_model.model.model.layers.0.self_attn.q_proj``. The inference graph
+#: knows nothing of either, so they must come off before the two sides can be compared.
+_TRAINING_WRAPPER_PREFIXES = ("backbone.", "base_model.model.", "base_model.")
+
+
+def _strip_wrapper_prefixes(name: str) -> str:
+    """Reduce a training-side parameter path to the model's own module path.
+
+    Applied repeatedly because the wrappers nest (``backbone.base_model.model.…``). Order matters:
+    ``base_model.model.`` is tried before ``base_model.`` so the longer wrapper wins.
+    """
+    changed = True
+    while changed:
+        changed = False
+        for prefix in _TRAINING_WRAPPER_PREFIXES:
+            if name.startswith(prefix):
+                name = name[len(prefix) :]
+                changed = True
+                break
+    return name
+
+
+class TrainableTensorCodec:
+    """Pure (no I/O) builder of :class:`HandoffEntry` objects from the three name sources."""
+
+    @staticmethod
+    def canonical_inference_name(base_layer_name: str, arch_spec: Any) -> str:
+        """The single Python implementation of the ``weight_merger.cpp:904`` rewrite rules.
+
+        Strip a leading ``backbone.``; rewrite the architecture's attention-module token
+        (``arch_spec.attention_module_name``, e.g. ``self_attn``) to ``attn``; rewrite ``base_layer``
+        to ``MatMul``. Rules are *data* from #6's architecture registry, not literals baked here. Used
+        only to seed a lookup against observed names — the observed name wins, and a mismatch raises.
+        """
+        return TrainableTensorCodec.candidate_inference_names(base_layer_name, arch_spec)[0]
+
+    @staticmethod
+    def candidate_inference_names(base_layer_name: str, arch_spec: Any) -> tuple[str, ...]:
+        """Every spelling an adapted layer's inference MatMul seed may legitimately take.
+
+        Two inference exporters are in play and they name the attention module differently:
+
+        * the legacy ``inference/builder.py`` graphs use ``attn`` — which is what the
+          ``weight_merger.cpp:904`` rewrite (and :meth:`canonical_inference_name`) was written against;
+        * the Optimum export that #7 made the front door preserves HF-canonical ``self_attn``.
+
+        Seeding the lookup with only the rewritten spelling meant **no** trainable tensor in an
+        Optimum-produced package could be matched, so `export_inference_package` failed with
+        "inference/training naming drifted" and no handoff map could be built for the very packages the
+        project now ships. The seed is only a lookup key — the *observed* initializer name is what is
+        recorded and what the device reads back out of `inferenceInitializerNames` — so accepting both
+        spellings is safe and keeps the C++ mirror valid for legacy packages.
+
+        Ordered: the rewritten (legacy) spelling first, so :meth:`canonical_inference_name` and the C++
+        mirror keep their existing meaning.
+        """
+        name = _strip_wrapper_prefixes(base_layer_name)
+        name = name.replace(".base_layer", ".MatMul")
+
+        # Falls back to the registry's declared default rather than a literal spelled here —
+        # `arch_spec` is `Any` and legacy callers pass None.
+        attn = getattr(arch_spec, "attention_module_name", None) or DEFAULT_ATTENTION_MODULE_NAME
+        candidates = []
+        if attn and attn != "attn":
+            candidates.append(name.replace(f".{attn}.", ".attn."))
+        candidates.append(name)
+        # Preserve order, drop duplicates (an architecture whose module already *is* `attn`).
+        return tuple(dict.fromkeys(candidates))
+
+    @classmethod
+    def from_peft_mapping(
+        cls,
+        peft_mapping: dict[str, dict[str, str]],
+        requires_grad: Iterable[str],
+        observed_inference_inits: Iterable[ObservedInit],
+        peft_spec: Any,
+        arch_spec: Any,
+        trainable_tensor_specs: dict[str, dict[str, Any]] | None = None,
+    ) -> list[HandoffEntry]:
+        """Join training-side (``peft_mapping`` + ``requires_grad``) with inference-side observed
+        initializers, one :class:`HandoffEntry` per trainable MatMul.
+
+        The ``peft_spec.component_schema`` supplies the adapter role vocabulary (order-of-truth); the
+        ``arch_spec`` supplies the name-rewrite. Raises :class:`HandoffError` if a mapping's
+        canonical-derived name has no observed inference initializer (drift caught at build time).
+        """
+        # Group observed inits by their base (canonical seed) name: "seed.weight" -> "seed".
+        by_seed: dict[str, list[ObservedInit]] = {}
+        for obs in observed_inference_inits:
+            seed = obs.name.rsplit(".", 1)[0]
+            by_seed.setdefault(seed, []).append(obs)
+
+        known_roles = {c.role for c in getattr(peft_spec, "component_schema", ())}
+        entries: list[HandoffEntry] = []
+        for base_layer_name, role_names in peft_mapping.items():
+            training_base = (
+                base_layer_name
+                if base_layer_name.endswith(".base_layer")
+                else base_layer_name + ".base_layer"
+            )
+            seeds = cls.candidate_inference_names(training_base, arch_spec)
+            group = next((g for g in (by_seed.get(s) for s in seeds) if g), None)
+            if not group:
+                raise HandoffError(
+                    f"no observed inference initializer for {base_layer_name!r} "
+                    f"(tried seeds {list(seeds)}); inference/training naming drifted"
+                )
+
+            inference_names = {obs.role: obs.name for obs in group}
+            weight_like = next((o for o in group if o.role in ("weight", "weight_quantized")), group[0])
+
+            # checkpointNames = adapter roles from the mapping (validated against the PEFT schema)
+            # plus the frozen base weight the merger reads from the CheckpointState.
+            checkpoint_names = {
+                role: name for role, name in role_names.items() if not known_roles or role in known_roles
+            }
+            checkpoint_names.setdefault("weight", f"{training_base}.weight")
+
+            # Describe the adapter factors, not just name them. `trainable_tensor_specs` is keyed by
+            # the TRAINING GRAPH's initializer name (`backbone.model...lora_A.lora.weight`), while
+            # `checkpoint_names` holds the PEFT module path (`base_model.model.model...lora_A.lora`) —
+            # two of the five spellings of one layer. `to_checkpoint_name` is the existing normalizer
+            # (twin of `cpp/layer_name.h`); re-deriving the rewrite here is what the layer-identity
+            # work exists to prevent. A role whose tensor is not found is simply left undescribed
+            # rather than guessed.
+            adapter_dtypes: dict[str, str] = {}
+            adapter_shapes: dict[str, tuple[int, ...]] = {}
+            if trainable_tensor_specs:
+                for role, module_path in checkpoint_names.items():
+                    if role == "weight":
+                        continue  # the frozen base, described by tensor_dtypes/tensor_shapes already
+                    initializer = f"{to_checkpoint_name(module_path)}.weight"
+                    spec = trainable_tensor_specs.get(initializer)
+                    if spec is None:
+                        continue
+                    adapter_dtypes[role] = str(spec["dtype"])
+                    adapter_shapes[role] = tuple(int(d) for d in spec["shape"])
+
+            quantization = None
+            if any(o.role in _QUANTIZED_ROLES for o in group):
+                quantization = {
+                    "weightQuantizedName": inference_names.get("weight_quantized", ""),
+                    "scaleName": inference_names.get("scale", ""),
+                    "zeroPointName": inference_names.get("zero_point", ""),
+                }
+
+            entries.append(
+                HandoffEntry(
+                    training_base_layer_name=training_base,
+                    dtype=weight_like.dtype,
+                    shape=weight_like.shape,
+                    # Keep each role's OWN observed dtype/shape. The device reads raw external-data
+                    # bytes with no header, so collapsing these onto the weight-like role left a
+                    # packed weight_quantized/scale/zero_point unloadable.
+                    tensor_dtypes={obs.role: obs.dtype for obs in group},
+                    tensor_shapes={obs.role: obs.shape for obs in group},
+                    checkpoint_names=checkpoint_names,
+                    adapter_dtypes=adapter_dtypes,
+                    adapter_shapes=adapter_shapes,
+                    merger_output_names={role: f"merged_{role}" for role in inference_names},
+                    merged_tensor_names=dict(inference_names),
+                    inference_initializer_names=dict(inference_names),
+                    external_data_location={role: f"{name}.bin" for role, name in inference_names.items()},
+                    quantization=quantization,
+                    transpose_policy=derive_transpose_policy(weight_like.shape, adapter_shapes),
+                )
+            )
+
+        # Fail closed on total adapter-spec drift. Every role above is looked up by a DERIVED
+        # initializer name, and a miss leaves the role merely "undescribed" — deliberate, since a
+        # partially-described entry is still usable. But if specs were supplied and NOT ONE entry
+        # matched, the derivation is not lenient, it is broken: `adapter_shapes` is empty everywhere,
+        # so orientation becomes unobservable and the whole package silently reverts to
+        # `no_transpose`. That is precisely the defect this field was rebuilt to prevent, reached by
+        # a name spelling drift instead of by an unassigned field. Name the lookup that missed.
+        if trainable_tensor_specs and entries and not any(e.adapter_shapes for e in entries):
+            probe = entries[0]
+            attempted = [
+                f"{to_checkpoint_name(path)}.weight"
+                for role, path in probe.checkpoint_names.items()
+                if role != "weight"
+            ]
+            raise HandoffError(
+                f"{len(trainable_tensor_specs)} trainable tensor specs were supplied but none matched "
+                f"any adapter role across {len(entries)} entries — for example "
+                f"{probe.training_base_layer_name!r} looked for {attempted}. The training-graph "
+                "initializer spelling has drifted from `to_checkpoint_name`. Refusing to emit a map "
+                "that describes no adapter factors: weight orientation would be unobservable and the "
+                "package would silently declare 'no_transpose'."
+            )
+
+        # One convention per package. A square weight cannot decide its own orientation, so the
+        # entries that CAN decide settle it for the ones that cannot — otherwise `q_proj` (square) and
+        # `v_proj` (not) would describe the same export two different ways.
+        package_policy = resolve_package_transpose_policy(entries)
+        for entry in entries:
+            entry.transpose_policy = package_policy
+        return entries
+
+
+__all__ = [
+    "HANDOFF_MAP_READER_VERSION",
+    "ROLE_ORDER",
+    "INFERENCE_SUFFIX_TO_ROLE",
+    "TensorSpec",
+    "ObservedInit",
+    "HandoffEntry",
+    "HandoffMap",
+    "TrainableTensorCodec",
+]
diff --git a/src/mobiletransformers/artifacts/manifest.py b/src/mobiletransformers/artifacts/manifest.py
new file mode 100644
index 0000000..d0c89b0
--- /dev/null
+++ b/src/mobiletransformers/artifacts/manifest.py
@@ -0,0 +1,207 @@
+"""Manifest validator + variant selection (#13) — the read/validate/select half of the package contract.
+
+The manifest *schema/field-list* is owned by #14 (``hub/package_format.py``); this module owns the
+**validator**, the **variant-selection** algorithm, and (on the Kotlin side, mirrored) the cache-install
+semantics. It reuses the one canonical ``check_compat`` (``artifacts/versioning.py``) with a
+``MANIFEST_READER_VERSION`` and the handoff-map contract (``artifacts/handoff_map.py``) to assert every
+``externalDataLocation`` a variant advertises actually resolves to a file on disk.
+
+``select_variant`` is the language-agnostic algorithm the Kotlin ``VariantSelector`` mirrors byte-for-byte.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.artifacts.versioning import check_compat
+from mobiletransformers.exceptions import ManifestError, NoCompatibleVariant
+
+#: Oldest manifest schema this reader understands (see ``check_compat``).
+MANIFEST_READER_VERSION = "1.0"
+
+
+@dataclass(frozen=True)
+class SelectedVariant:
+    """The variant chosen by :meth:`MobileTransformersManifest.select_variant`."""
+
+    id: str
+    execution_provider: str
+    quantization: str
+    supported_engines: tuple[str, ...]
+    features: tuple[str, ...]
+    paths: dict[str, str]
+    weight_handoff: str
+    recommended_device_memory_mb: int | None
+
+
+@dataclass
+class MobileTransformersManifest:
+    """A parsed ``mobiletransformers_manifest.json``. Unknown fields are preserved for round-trip."""
+
+    data: dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> MobileTransformersManifest:
+        if not isinstance(data, dict):
+            raise ManifestError("manifest must be a JSON object")
+        return cls(data=data)
+
+    @classmethod
+    def load(cls, path: str | Path) -> MobileTransformersManifest:
+        path = Path(path)
+        if not path.is_file():
+            raise ManifestError(f"manifest not found: {path}")
+        return cls.from_dict(json.loads(path.read_text(encoding="utf-8")))
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.data
+
+    def to_json(self) -> str:
+        return json.dumps(self.data, indent=2, sort_keys=True) + "\n"
+
+    # -- typed accessors ----------------------------------------------------
+    @property
+    def schema_version(self) -> str:
+        return self.data.get("schemaVersion", "")
+
+    @property
+    def min_reader_version(self) -> str:
+        return self.data.get("minReaderVersion", "")
+
+    @property
+    def default_variant(self) -> str:
+        return self.data.get("defaultVariant", "")
+
+    @property
+    def variants(self) -> list[dict[str, Any]]:
+        return self.data.get("variants", [])
+
+    def _variant(self, variant_id: str) -> dict[str, Any] | None:
+        return next((v for v in self.variants if v.get("id") == variant_id), None)
+
+    # -- validation ---------------------------------------------------------
+    def validate(self, package_dir: str | Path) -> None:
+        """Fail closed (``ManifestError``) unless the manifest is version-compatible, internally
+        consistent, and every advertised file/handoff tensor resolves on disk."""
+        package_dir = Path(package_dir)
+        # F1 schema gate (raises SchemaVersionError, a MobileTransformersError, on incompatibility).
+        check_compat(self.schema_version, self.min_reader_version, MANIFEST_READER_VERSION)
+
+        if not self.variants:
+            raise ManifestError("manifest declares no variants")
+        if self._variant(self.default_variant) is None:
+            raise ManifestError(
+                f"defaultVariant {self.default_variant!r} is not among variants "
+                f"{[v.get('id') for v in self.variants]}"
+            )
+
+        for v in self.variants:
+            vid = v.get("id")
+            paths = v.get("paths", {})
+            features = set(v.get("features", ()))
+            # Every claimed feature that needs a subtree must have a path entry.
+            for feature, required_path in (
+                ("train", "train"),
+                ("inference", "inference"),
+                ("rag", "embedding"),
+            ):
+                if feature in features and required_path not in paths:
+                    raise ManifestError(
+                        f"variant {vid!r} claims feature {feature!r} but has no '{required_path}' path"
+                    )
+            # weightHandoff must resolve, and every externalDataLocation it names must exist.
+            self._validate_handoff(package_dir, vid, v.get("weightHandoff"), paths.get("inference"))
+
+        # requiredFiles floor.
+        for rel in self.data.get("requiredFiles", []):
+            if not (package_dir / rel).exists():
+                raise ManifestError(f"requiredFile missing on disk: {rel}")
+
+    def _validate_handoff(
+        self, package_dir: Path, variant_id: Any, handoff_rel: str | None, inference_rel: str | None
+    ) -> None:
+        if not handoff_rel:
+            raise ManifestError(f"variant {variant_id!r} has no weightHandoff pointer")
+        handoff_path = package_dir / handoff_rel
+        if not handoff_path.is_file():
+            raise ManifestError(f"variant {variant_id!r} weightHandoff does not resolve: {handoff_rel}")
+        inference_dir = (package_dir / inference_rel) if inference_rel else handoff_path.parent
+        handoff = HandoffMap.load(handoff_path)  # runs check_compat + validate() on the handoff itself
+        for entry in handoff.entries:
+            for role, location in entry.external_data_location.items():
+                if not (inference_dir / location).is_file():
+                    raise ManifestError(
+                        f"variant {variant_id!r} handoff entry {entry.training_base_layer_name!r} "
+                        f"role {role!r} points at missing external file: {location}"
+                    )
+
+    # -- variant selection --------------------------------------------------
+    def select_variant(
+        self,
+        *,
+        abis: tuple[str, ...] | list[str],
+        quantization: str | None = None,
+        total_mem_mb: int | None = None,
+        requested_features: tuple[str, ...] | list[str] = (),
+        requested_engine: str = "native",
+    ) -> SelectedVariant:
+        """Pick the best variant for the given device caps + requests, or raise ``NoCompatibleVariant``.
+
+        Filters: ABI overlap (variant ``abi=null`` means any), quantization (if requested), memory
+        (``recommendedDeviceMemoryMb <= total_mem_mb``), features ⊇ requested, engine ∈ supportedEngines.
+        Tie-break: smallest ``recommendedDeviceMemoryMb``, then the ``defaultVariant``, then id order.
+        """
+        abis_set = set(abis)
+        req_features = set(requested_features)
+        candidates: list[dict[str, Any]] = []
+        for v in self.variants:
+            v_abi = v.get("abi")
+            if v_abi is not None and not (abis_set & set(v_abi)):
+                continue
+            if quantization is not None and v.get("quantization") != quantization:
+                continue
+            mem = v.get("recommendedDeviceMemoryMb")
+            if total_mem_mb is not None and mem is not None and mem > total_mem_mb:
+                continue
+            if not req_features.issubset(set(v.get("features", ()))):
+                continue
+            if requested_engine not in set(v.get("supportedEngines", ())):
+                continue
+            candidates.append(v)
+
+        if not candidates:
+            raise NoCompatibleVariant(
+                f"no variant matches abis={sorted(abis_set)} quant={quantization} "
+                f"mem={total_mem_mb} features={sorted(req_features)} engine={requested_engine!r}"
+            )
+
+        def _key(v: dict[str, Any]) -> tuple[int, int, str]:
+            mem = v.get("recommendedDeviceMemoryMb")
+            return (
+                mem if mem is not None else 1 << 30,
+                0 if v.get("id") == self.default_variant else 1,
+                str(v.get("id")),
+            )
+
+        best = min(candidates, key=_key)
+        return SelectedVariant(
+            id=best["id"],
+            execution_provider=best.get("executionProvider", ""),
+            quantization=best.get("quantization", ""),
+            supported_engines=tuple(best.get("supportedEngines", ())),
+            features=tuple(best.get("features", ())),
+            paths=dict(best.get("paths", {})),
+            weight_handoff=best.get("weightHandoff", ""),
+            recommended_device_memory_mb=best.get("recommendedDeviceMemoryMb"),
+        )
+
+
+__all__ = [
+    "MANIFEST_READER_VERSION",
+    "SelectedVariant",
+    "MobileTransformersManifest",
+]
diff --git a/src/mobiletransformers/artifacts/package_paths.py b/src/mobiletransformers/artifacts/package_paths.py
new file mode 100644
index 0000000..7a755d3
--- /dev/null
+++ b/src/mobiletransformers/artifacts/package_paths.py
@@ -0,0 +1,160 @@
+"""One resolver for every stage path in a package. No consumer appends a stage name to a string.
+
+## Why this exists
+
+A package has **two** on-disk layouts, and until now both were built by string concatenation at every
+call site:
+
+===================  ==========================================  ==========================
+layout               shape                                        who produces it
+===================  ==========================================  ==========================
+hub package          ``variants/<variantId>/{train,inference,     ``export/pipeline.py``
+                     embedding}`` + ``shared/tokenizer``
+device cache (flat)  ``<cacheDir>/<repoId>/{train,inference,      ``ModelPackageInstaller``,
+                     embedding,tokenizer}``                        ``scripts/device_package.sh``
+===================  ==========================================  ==========================
+
+The manifest has always *declared* the hub layout — ``variant.paths`` — but exactly one consumer in the
+whole repo read it (``cli/federated.py``); roughly twenty others spelled the join by hand, in four
+languages. The #35 simulation lost a cycle to precisely this: the client looked for ``<package>/train/``
+(the cache layout) in a hub package, and ORT reported ``INVALID_ARGUMENT : Invalid fd was supplied: -1``,
+naming no file.
+
+This is the layer-identity problem in a second namespace. The fix is the same one ``cpp/layer_name.h``
+applied there: **one place that knows the spelling**, and a guard that keeps it that way.
+
+## The rule
+
+Ask a :class:`PackagePaths` for a stage. Never write ``dir / "train"``.
+
+Mirrored in Kotlin by ``packages/PackagePaths.kt``; the two must agree, because the same package is
+read by both.
+
+**C++ deliberately has no mirror.** It never resolves a stage — Kotlin hands it an already-resolved
+directory over JNI, and its joins (``inference_dir + "/weight_handoff_map.json"``) append a *filename*
+to a resolved directory, which is not this defect. Adding a third copy for symmetry would create the
+very duplication this module exists to remove.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from mobiletransformers.exceptions import ManifestError
+
+#: Stage keys as they appear in the manifest's ``paths`` map. These are wire names.
+STAGE_INFERENCE = "inference"
+STAGE_TRAIN = "train"
+STAGE_EMBEDDING = "embedding"
+STAGE_TOKENIZER = "tokenizer"
+
+#: Every stage a package can declare, in a deterministic order.
+STAGES: tuple[str, ...] = (STAGE_INFERENCE, STAGE_TRAIN, STAGE_EMBEDDING, STAGE_TOKENIZER)
+
+#: Directory name each stage takes in the FLAT device-cache layout.
+#:
+#: Note ``embedding`` keeps its name while ``tokenizer`` moves from ``shared/tokenizer`` to a sibling —
+#: the cache layout is not simply the hub layout with the ``variants/<id>/`` prefix removed, which is
+#: exactly why open-coding it in nine places produced two different answers.
+_CACHE_DIRNAMES: dict[str, str] = {
+    STAGE_INFERENCE: "inference",
+    STAGE_TRAIN: "train",
+    STAGE_EMBEDDING: "embedding",
+    STAGE_TOKENIZER: "tokenizer",
+}
+
+#: Filename of the weight handoff map inside the inference stage.
+WEIGHT_HANDOFF_FILENAME = "weight_handoff_map.json"
+
+
+@dataclass(frozen=True)
+class PackagePaths:
+    """Resolved absolute stage directories for one package in one layout.
+
+    Build with :meth:`for_hub` or :meth:`for_cache`; do not construct directly unless you are writing a
+    third layout, in which case add a factory here rather than joining strings at the call site.
+    """
+
+    root: Path
+    #: Stage key -> absolute directory. Only stages the layout actually declares are present.
+    stages: dict[str, Path]
+    #: Which layout produced this, for error messages that need to say so.
+    layout: str
+
+    @classmethod
+    def for_hub(cls, package_dir: str | Path, variant: object) -> PackagePaths:
+        """Resolve against a hub package using the variant's **declared** ``paths``.
+
+        :param variant: a ``SelectedVariant`` (anything exposing a ``paths`` mapping). The manifest is
+            the source of truth here — a variant may legitimately place a stage somewhere this module
+            would not have guessed, and re-deriving ``variants/<id>/<stage>`` would silently ignore it.
+        """
+        package_dir = Path(package_dir)
+        declared = getattr(variant, "paths", None)
+        if not isinstance(declared, dict):
+            raise ManifestError(
+                "variant declares no `paths` map; a package built before the manifest carried per-variant "
+                "paths cannot be resolved — re-export it."
+            )
+        stages = {stage: package_dir / rel for stage, rel in declared.items() if isinstance(rel, str) and rel}
+        return cls(root=package_dir, stages=stages, layout="hub")
+
+    @classmethod
+    def for_cache(cls, cache_dir: str | Path, repo_id: str) -> PackagePaths:
+        """Resolve against the FLAT on-device cache layout.
+
+        ``repo_id`` must already be sanitized (``/`` -> ``__``) if it came from a hub id; that mapping is
+        owned by ``hub/package_format.py::sanitize_repo_id`` and mirrored in Kotlin, and is deliberately
+        not repeated here.
+        """
+        base = Path(cache_dir) / repo_id
+        return cls(
+            root=base,
+            stages={stage: base / name for stage, name in _CACHE_DIRNAMES.items()},
+            layout="cache",
+        )
+
+    # -- accessors ----------------------------------------------------------
+
+    def stage(self, name: str) -> Path:
+        """The directory for ``name``, or :class:`ManifestError` naming what is available.
+
+        Fails closed rather than returning a plausible path that does not exist: a silently-wrong stage
+        directory surfaces later as an unrelated-looking IO error, which is the failure mode this module
+        was written to end.
+        """
+        if name not in STAGES:
+            raise ManifestError(f"unknown stage {name!r}; known stages are {list(STAGES)}")
+        try:
+            return self.stages[name]
+        except KeyError:
+            raise ManifestError(
+                f"this {self.layout} package does not declare a {name!r} stage "
+                f"(declared: {sorted(self.stages)})"
+            ) from None
+
+    @property
+    def inference(self) -> Path:
+        return self.stage(STAGE_INFERENCE)
+
+    @property
+    def train(self) -> Path:
+        return self.stage(STAGE_TRAIN)
+
+    @property
+    def embedding(self) -> Path:
+        return self.stage(STAGE_EMBEDDING)
+
+    @property
+    def tokenizer(self) -> Path:
+        return self.stage(STAGE_TOKENIZER)
+
+    @property
+    def weight_handoff(self) -> Path:
+        """The handoff map, which lives inside the inference stage in both layouts."""
+        return self.inference / WEIGHT_HANDOFF_FILENAME
+
+    def has(self, name: str) -> bool:
+        """Whether the layout declares ``name`` at all (says nothing about what is on disk)."""
+        return name in self.stages
diff --git a/src/mobiletransformers/artifacts/parameter_budget.py b/src/mobiletransformers/artifacts/parameter_budget.py
new file mode 100644
index 0000000..763d617
--- /dev/null
+++ b/src/mobiletransformers/artifacts/parameter_budget.py
@@ -0,0 +1,250 @@
+"""Export-time proof that the training graph carries the model's parameters.
+
+## Why this exists
+
+Every assertion the export and the device suite made about the training stage was byte-level or
+structural: the merge rewrote 60/60 `.bin` files, the handoff names resolved (`checkpoint_names.py`),
+the reload succeeded. All of them were correct, and none of them looked at a number. A training package
+that carried a fraction of the model would have passed every one.
+
+That gap produced a real cost even without a real defect. A session read
+``checkpoint 176.3 MB / 4 bytes ≈ 44M parameters`` against SmolLM2-135M's ~135M and concluded that "two
+thirds of the model is in neither artifact" — a v1 blocker that went into `HANDOFF.md`, the `CHANGELOG`
+Known issues and a deliberately-failing device test. The division was wrong: **~90% of the checkpoint
+tensors are uint8, not fp32.** The graph carries all 135,436,915 parameters. Counting bytes without
+counting dtypes is exactly the mistake this module exists to make impossible — which is why
+:func:`summarize_training_parameters` reports **per dtype** and never divides by a single element size.
+
+## What it checks
+
+Two things, both cheap and both on the host:
+
+* **Budget** — the training graph's parameter total against the parameter count of the HF model it was
+  exported from, recorded by ``optimum_hf_export`` into ``training_config.json`` at the moment the
+  torch model was in memory. This is exact and architecture-agnostic; no re-derivation from
+  ``AutoConfig`` shapes, which would have to be maintained per architecture and would be wrong for the
+  next model family added to the registry.
+* **Split** — the fp32/quantized breakdown, logged and returned. A package whose trainable adapters got
+  swept into quantization has a characteristic signature here (no float parameters outside the
+  layernorms), and that defect has happened before — see the ``exclude_weights`` note in
+  ``export/training_export.py``.
+
+## How the parameters are found
+
+ORT's ``TrainingBlock`` moves every name in ``requires_grad ∪ frozen_params`` out of
+``graph.initializer`` and into graph **inputs**, storing the values in the checkpoint. So the training
+graph's parameters are its inputs, minus the data inputs. The two are told apart by shape, not by name:
+a data input carries at least one symbolic dimension (``batch_size``/``sequence_length``); a parameter
+is fully concrete. Name-matching would be a second wire-format assumption to keep in sync, and this
+module exists because assumptions went unchecked.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: How far below the reference count the training graph may sit before the export fails.
+#:
+#: Not a guess about noise. The graph and the reference count legitimately differ in both directions:
+#: PEFT **adds** adapter parameters, while tied embeddings are one tensor in the graph and one entry in
+#: torch's de-duplicated ``parameters()``. Neither moves the total by a percent. The failure this gates
+#: is a *structural* one — a stage that dropped a projection, a layer range, or the embedding table —
+#: and the smallest such loss on a real architecture is several percent. 5% separates the two without
+#: encoding any one model.
+DEFAULT_TOLERANCE = 0.05
+
+#: ONNX ``TensorProto`` element types treated as quantized parameter storage.
+_QUANTIZED_ELEM_TYPES = {2, 3, 21, 22}  # UINT8, INT8, UINT4, INT4
+
+
+@dataclass
+class ParameterSummary:
+    """The training graph's parameter accounting, per dtype."""
+
+    total: int = 0
+    #: elements keyed by ONNX ``TensorProto`` elem_type, so a byte total is never inferred from one size.
+    by_elem_type: dict[int, int] = field(default_factory=dict)
+    tensor_count: int = 0
+    data_input_names: list[str] = field(default_factory=list)
+
+    @property
+    def quantized(self) -> int:
+        """Elements held in quantized storage."""
+        return sum(n for t, n in self.by_elem_type.items() if t in _QUANTIZED_ELEM_TYPES)
+
+    @property
+    def float_elements(self) -> int:
+        """Elements held in float storage (the adapters, layernorms and anything left unquantized)."""
+        return self.total - self.quantized
+
+    def describe(self) -> str:
+        parts = ", ".join(
+            f"elem_type={t}: {n:,}" for t, n in sorted(self.by_elem_type.items(), key=lambda kv: -kv[1])
+        )
+        return f"{self.total:,} parameters across {self.tensor_count} tensors ({parts})"
+
+
+def summarize_training_parameters(training_model_path: str | Path) -> ParameterSummary:
+    """Count the parameters an ORT training graph carries, split by element type.
+
+    Parameters live in ``graph.input`` (ORT's ``TrainingBlock`` moves them there); data inputs are told
+    apart by carrying a symbolic dimension.
+
+    Raises:
+        ExportError: if the graph cannot be read, or declares no parameter inputs at all.
+    """
+    import onnx
+
+    training_model_path = Path(training_model_path)
+    if not training_model_path.is_file():
+        raise ExportError(f"training model not found for parameter-budget check: {training_model_path}")
+
+    # The values live in the checkpoint, not the graph, so the parameter *shapes* are all we need —
+    # loading external data here would read hundreds of MB to count elements we can read from dims.
+    model = onnx.load(str(training_model_path), load_external_data=False)
+
+    summary = ParameterSummary()
+    for graph_input in model.graph.input:
+        tensor_type = graph_input.type.tensor_type
+        dims = []
+        symbolic = False
+        for dim in tensor_type.shape.dim:
+            if dim.HasField("dim_value") and dim.dim_value > 0:
+                dims.append(dim.dim_value)
+            else:
+                symbolic = True
+                break
+        if symbolic:
+            summary.data_input_names.append(graph_input.name)
+            continue
+
+        elements = 1
+        for d in dims:
+            elements *= d
+        summary.total += elements
+        summary.tensor_count += 1
+        summary.by_elem_type[tensor_type.elem_type] = (
+            summary.by_elem_type.get(tensor_type.elem_type, 0) + elements
+        )
+
+    if summary.tensor_count == 0:
+        raise ExportError(
+            f"{training_model_path.name} declares no fully-shaped parameter inputs. Either the graph is "
+            "not an ORT training graph, or generate_artifacts moved nothing into the checkpoint."
+        )
+    return summary
+
+
+#: ONNX ``TensorProto`` elem_type -> the name used when declaring a graph's observed precision.
+_ELEM_TYPE_NAMES = {
+    1: "float32",
+    2: "uint8",
+    3: "int8",
+    10: "float16",
+    16: "bfloat16",
+    21: "uint4",
+    22: "int4",
+}
+
+#: Integer/bool elem_types that hold shape, index and mask constants rather than weights. Counting them
+#: would report a pure-fp32 graph as "mixed" purely because it has `Reshape` targets.
+_NON_WEIGHT_ELEM_TYPES = {6, 7, 9}  # INT32, INT64, BOOL
+
+
+def describe_graph_precision(model_path: str | Path) -> str:
+    """What precision a graph's weights are ACTUALLY stored in, measured from its initializers.
+
+    Exists because a variant directory named ``cpu-int4`` was found shipping a pure fp32 inference
+    graph: the variant id names the *requested* quantization, which the inference export does not
+    apply. Declaring the measured answer beside the graph means no reader has to infer precision from
+    a directory name again.
+
+    Returns a single dtype name when the weights are homogeneous, else ``mixed(a/b)`` ordered by
+    element count, or ``unknown`` for a graph with no initializers (weights held externally as graph
+    inputs — the training-graph shape, which :func:`summarize_training_parameters` handles instead).
+    """
+    import onnx
+
+    model = onnx.load(str(model_path), load_external_data=False)
+
+    elements: dict[int, int] = {}
+    for init in model.graph.initializer:
+        if init.data_type in _NON_WEIGHT_ELEM_TYPES:
+            continue
+        count = 1
+        for dim in init.dims:
+            count *= dim
+        elements[init.data_type] = elements.get(init.data_type, 0) + count
+
+    if not elements:
+        return "unknown"
+    ordered = sorted(elements.items(), key=lambda kv: -kv[1])
+    names = [_ELEM_TYPE_NAMES.get(t, f"elem_type={t}") for t, _ in ordered]
+    return names[0] if len(names) == 1 else f"mixed({'/'.join(names)})"
+
+
+def verify_checkpoint_parameter_budget(
+    training_model_path: str | Path,
+    expected_total: int | None,
+    *,
+    tolerance: float = DEFAULT_TOLERANCE,
+) -> ParameterSummary:
+    """Assert the training graph carries (about) as many parameters as the source model has.
+
+    Args:
+        training_model_path: the exported ``training_model.onnx``.
+        expected_total: the source HF model's parameter count, as recorded by ``optimum_hf_export``
+            into ``training_config.json``. ``None`` skips the comparison — the summary is still
+            computed and logged, and the caller is expected to say the check was not run.
+        tolerance: allowed shortfall as a fraction of ``expected_total``. See
+            :data:`DEFAULT_TOLERANCE` for why a tolerance is correct here rather than equality.
+
+    Returns:
+        The :class:`ParameterSummary`, so callers can record the split in the package report.
+
+    Raises:
+        ExportError: naming both counts. Fails closed: a training package that cannot carry the
+            pretrained weights must not ship looking like one that can.
+    """
+    summary = summarize_training_parameters(training_model_path)
+
+    if expected_total is None:
+        logger.warning(
+            "parameter-budget check: no reference count recorded by the export; counted %s but "
+            "verified nothing. The training stage is UNVERIFIED against the source model.",
+            summary.describe(),
+        )
+        return summary
+
+    floor = int(expected_total * (1.0 - tolerance))
+    if summary.total < floor:
+        shortfall = 1.0 - (summary.total / expected_total)
+        raise ExportError(
+            f"training graph carries {summary.total:,} parameters but the source model has "
+            f"{expected_total:,} — {shortfall:.1%} short (floor {floor:,} at {tolerance:.0%} "
+            f"tolerance).\n  {summary.describe()}\n"
+            "A training package this far below its own model cannot start from the pretrained "
+            "weights. Check which parameters generate_artifacts moved into the checkpoint vs left as "
+            "graph initializers, and whether the quantizer swept tensors it should have excluded "
+            "(export/training_export.py, `exclude_weights`)."
+        )
+
+    logger.info(
+        "parameter-budget check: %s (reference %s, %+.1f%%)",
+        summary.describe(),
+        f"{expected_total:,}",
+        100.0 * (summary.total / expected_total - 1.0),
+    )
+    if summary.float_elements == 0:
+        raise ExportError(
+            f"training graph has {summary.total:,} parameters but NONE in float storage. The PEFT "
+            "adapters were swept into quantization, so there is nothing trainable to compute a "
+            "gradient for (see `exclude_weights` in export/training_export.py)."
+        )
+    return summary
diff --git a/src/mobiletransformers/artifacts/train_inference_parity.py b/src/mobiletransformers/artifacts/train_inference_parity.py
new file mode 100644
index 0000000..64c4c30
--- /dev/null
+++ b/src/mobiletransformers/artifacts/train_inference_parity.py
@@ -0,0 +1,378 @@
+"""Export-time proof that a package's train and inference halves agree numerically.
+
+## Why this exists
+
+A package ships two graphs built by two different toolchains from one model: ``inference/model.onnx``
+(optimum export, external-initializer split) and ``train/training_model.onnx`` (torch → ONNX →
+dynamic quantization → ``generate_artifacts``). Everything that compared them compared *names*. Nothing
+compared *numbers*, in either direction, at any point in the pipeline or the device suite.
+
+That is not hypothetical. A variant directory named ``cpu-int4`` was found shipping a **pure fp32**
+inference graph (273 initializers, all float32) beside a **uint8 weight-quantized** training graph. Both
+halves work; nobody had established what the gap between them is, so when a device test read a
+higher-than-expected training loss there was no reference to judge it against, and the number was
+misread as missing weights (see ``parameter_budget.py``).
+
+This module supplies that reference: the same tokens through both graphs, one loss each, one delta.
+
+## What "agreement" means here
+
+Not equality. The two graphs are *deliberately* different — quantization is the whole point of the
+training half — so the check is a **bound on the disagreement**, not a bit-parity assertion. Measured
+weight-quantization error on the embedding table alone is ~3.2% RMS, which moves a cross-entropy by
+tenths of a nat. A structural defect — wrong weights, a dropped layer range, a mis-parameterised graph
+— moves it by whole nats and pushes the loss toward or past the uniform-prediction floor
+``ln(vocab_size)``. :data:`MAX_LOSS_DELTA_NATS` sits between those two regimes.
+
+## Runtime requirements
+
+Both legs need ``onnxruntime``; the training leg additionally needs ``onnxruntime.training``. Those live
+in mutually-exclusive dependency profiles from the export profile, so this check runs when the training
+stage runs (``ort-training-local``) and reports honestly that it did not run otherwise. It never
+silently passes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    import numpy as np
+
+logger = get_logger(__name__)
+
+#: Largest train-vs-inference cross-entropy gap, in nats, that is attributed to quantization.
+#:
+#: Calibrated, not guessed. Weight-only uint8 quantization has a ~3.2% RMS error on the embedding table,
+#: which moves a cross-entropy by tenths of a nat. A graph that had genuinely lost its pretrained
+#: weights would sit at or above ``ln(vocab_size)``, i.e. nats away. 1.5 admits the former and excludes
+#: the latter by a wide margin.
+#:
+#: **Re-measured 2026-08-15**, after :func:`probe_token_ids` started tokenizing with the package's own
+#: tokenizer. The figures this constant used to cite (SmolLM2 "13.861 fp32 vs 14.254") came from the
+#: borrowed-id probe and are not comparable to anything now:
+#:
+#: ===========================  ==========  =========  =======
+#: package                      inference   training   delta
+#: ===========================  ==========  =========  =======
+#: SmolLM2-135M-Instruct            3.1803     3.3264   0.1461
+#: google/gemma-3-270m              3.2870     3.3057   0.0188
+#: google/functiongemma-270m-it     5.1658     6.0495   0.8837
+#: ===========================  ==========  =========  =======
+#:
+#: FunctionGemma's higher absolute loss and wider gap are the probe being off-distribution for it, not
+#: a defect: it is fine-tuned hard on function-call JSON, and re-probed on such JSON the same package
+#: gives 4.4513 / 4.1526 for a delta of **0.2987**. Quantization error is largest exactly where the
+#: model is least confident, so a specialised model measured on generic English is the worst case this
+#: bound has to tolerate — which is the reason to keep 1.5 rather than tighten it toward the 0.02-0.15
+#: the general-purpose models show.
+MAX_LOSS_DELTA_NATS = 1.5
+
+#: FALLBACK token ids, used only when the package ships no tokenizer to derive better ones from.
+#:
+#: These are **Llama-family ids** — they decode to English under SmolLM2's tokenizer and to nothing in
+#: particular under anyone else's. That was fine while the claim was only "both graphs see the same
+#: tokens", but it makes the absolute losses meaningless off that family and, worse, it makes the
+#: DELTA fragile: on a sequence the model finds absurd it is confidently wrong, and quantization error
+#: on a confident-but-wrong distribution is far larger than on text the model expects.
+#:
+#: Measured 2026-08-15 on `google/functiongemma-270m-it` (vocab 262144, ln(vocab) = 12.48):
+#: inference 25.70 / training 27.14 nats — both roughly TWICE uniform-random — for a delta of 1.4417
+#: against a 1.5 bound. The package was fine; the probe was gibberish to it. A good package came within
+#: 0.06 nats of failing its own integrity gate.
+#:
+#: :func:`_probe_batch` therefore prefers the package's OWN tokenizer. Keep these as the last resort.
+FALLBACK_PROBE_INPUT_IDS: tuple[tuple[int, ...], ...] = (
+    (1, 338, 263, 1243, 310, 278, 1904, 29889),
+    (1, 450, 4996, 17354, 1701, 29916, 432, 17204),
+)
+
+#: Deprecated alias for :data:`FALLBACK_PROBE_INPUT_IDS`, kept so external references keep resolving.
+PROBE_INPUT_IDS = FALLBACK_PROBE_INPUT_IDS
+
+#: The probe text, tokenized with the package's own tokenizer when one is available.
+#:
+#: Ordinary English, deliberately: the point of the check is to compare two graphs on input the model
+#: was trained to model, so that the gap between them is quantization error and nothing else.
+PROBE_TEXTS: tuple[str, ...] = (
+    "This is a test of the model.",
+    "The quick brown fox jumps over the lazy dog.",
+)
+
+#: How many tokens of each probe text to keep. Fixed so the batch is rectangular without padding, and
+#: short enough that every tokenizer produces at least this many for the texts above.
+PROBE_SEQUENCE_LENGTH = 8
+
+
+@dataclass
+class ParityResult:
+    """Outcome of the train-vs-inference comparison."""
+
+    inference_loss: float
+    training_loss: float
+
+    @property
+    def delta(self) -> float:
+        return abs(self.training_loss - self.inference_loss)
+
+    def describe(self) -> str:
+        return (
+            f"inference {self.inference_loss:.4f} vs training {self.training_loss:.4f} nats "
+            f"(delta {self.delta:.4f})"
+        )
+
+
+def causal_cross_entropy(logits: np.ndarray, input_ids: np.ndarray) -> float:
+    """Mean next-token cross-entropy in nats, HF-style.
+
+    Applies the causal shift the way the exported graphs do — ``logits[:, :-1]`` against
+    ``input_ids[:, 1:]`` — so a caller cannot accidentally double-shift, which is the exact defect that
+    made the old host-side ``onnx_checktrain`` number incomparable to the device's.
+
+    Pure numpy so it is unit-testable in the core profile, with no onnxruntime present.
+    """
+    import numpy as np
+
+    if logits.ndim != 3:
+        raise ValueError(f"expected logits [batch, seq, vocab], got shape {logits.shape}")
+
+    shifted_logits = logits[:, :-1, :]
+    targets = input_ids[:, 1:]
+
+    # Log-softmax in a numerically stable form; float64 so the subtraction below cannot lose precision
+    # at the magnitudes a broken graph produces (fp values in the 1e8 range have been observed).
+    x = shifted_logits.astype(np.float64)
+    x = x - x.max(axis=-1, keepdims=True)
+    log_probs = x - np.log(np.exp(x).sum(axis=-1, keepdims=True))
+
+    batch_idx, pos_idx = np.indices(targets.shape)
+    token_log_probs = log_probs[batch_idx, pos_idx, targets]
+    return float(-token_log_probs.mean())
+
+
+def find_package_tokenizer(reference: str | Path) -> Path | None:
+    """Locate ``tokenizer.json`` for the package containing ``reference`` (an inference model or dir).
+
+    Looks beside the graph first (the flat ``inference/`` layout puts one there), then at the package's
+    ``shared/tokenizer/``. Returns ``None`` rather than raising: a missing tokenizer degrades the probe,
+    it does not invalidate the comparison.
+    """
+    reference = Path(reference)
+    start = reference.parent if reference.is_file() else reference
+    candidates = [
+        start / "tokenizer.json",
+        start.parent / "tokenizer" / "tokenizer.json",
+        # <pkg>/variants/<variant>/inference -> <pkg>/shared/tokenizer
+        start.parent.parent.parent / "shared" / "tokenizer" / "tokenizer.json",
+    ]
+    return next((c for c in candidates if c.is_file()), None)
+
+
+def probe_token_ids(tokenizer_json: str | Path | None) -> tuple[tuple[int, ...], ...]:
+    """Tokenize :data:`PROBE_TEXTS` with the package's tokenizer, or fall back to fixed ids.
+
+    Using the package's OWN tokenizer is what makes the resulting loss interpretable: an absolute
+    cross-entropy is only comparable to ``ln(vocab_size)`` if the ids actually mean the text they were
+    meant to mean. With borrowed ids a Gemma-vocabulary model scored ~25 nats against a 12.5-nat
+    uniform bound, and the train/inference delta inflated to within 0.06 of the failure threshold.
+    """
+    if tokenizer_json is not None:
+        try:
+            from tokenizers import Tokenizer
+
+            tok = Tokenizer.from_file(str(tokenizer_json))
+            rows = []
+            for text in PROBE_TEXTS:
+                ids = tok.encode(text).ids
+                if len(ids) < PROBE_SEQUENCE_LENGTH:
+                    raise ValueError(f"{text!r} tokenized to only {len(ids)} ids")
+                rows.append(tuple(ids[:PROBE_SEQUENCE_LENGTH]))
+            return tuple(rows)
+        except Exception as exc:  # noqa: BLE001 — any tokenizer problem degrades, never fails, the probe
+            logger.warning(
+                "could not tokenize the parity probe with %s (%s); falling back to fixed ids, so the "
+                "absolute losses below are NOT comparable to ln(vocab_size)",
+                tokenizer_json,
+                exc,
+            )
+    return FALLBACK_PROBE_INPUT_IDS
+
+
+def _probe_batch(
+    tokenizer_json: str | Path | None = None,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """(input_ids, attention_mask, position_ids) for the probe, in the package's own vocabulary."""
+    import numpy as np
+
+    input_ids = np.asarray(probe_token_ids(tokenizer_json), dtype=np.int64)
+    attention_mask = np.ones_like(input_ids, dtype=np.int64)
+    position_ids = np.arange(input_ids.shape[1], dtype=np.int64)[None, :].repeat(input_ids.shape[0], 0)
+    return input_ids, attention_mask, position_ids
+
+
+def inference_graph_loss(inference_model_path: str | Path, tokenizer_json: str | Path | None = None) -> float:
+    """Run the packaged inference graph on the probe batch and return its next-token loss.
+
+    External initializers resolve relative to the model file, which is exactly the flat ``inference/``
+    layout the package defines, so no weight wiring is needed here.
+    """
+    import numpy as np
+    import onnxruntime as ort
+
+    inference_model_path = Path(inference_model_path)
+    if not inference_model_path.is_file():
+        raise ExportError(f"inference model not found for parity check: {inference_model_path}")
+
+    session = ort.InferenceSession(str(inference_model_path), providers=["CPUExecutionProvider"])
+    if tokenizer_json is None:
+        tokenizer_json = find_package_tokenizer(inference_model_path)
+    input_ids, attention_mask, position_ids = _probe_batch(tokenizer_json)
+
+    supplied: dict[str, np.ndarray] = {}
+    available = {i.name for i in session.get_inputs()}
+    for name, value in (
+        ("input_ids", input_ids),
+        ("attention_mask", attention_mask),
+        ("position_ids", position_ids),
+    ):
+        if name in available:
+            supplied[name] = value
+
+    # A KV-cache-enabled graph declares empty past_key_values inputs; feed zero-length tensors so the
+    # first (prefill) step is what runs — the same thing the device does on a fresh conversation.
+    for model_input in session.get_inputs():
+        if model_input.name in supplied:
+            continue
+        if not model_input.name.startswith("past_key_values"):
+            raise ExportError(
+                f"inference graph declares an input the parity probe cannot supply: {model_input.name}"
+            )
+        shape = [d if isinstance(d, int) else 0 for d in model_input.shape]
+        shape[0] = input_ids.shape[0]
+        supplied[model_input.name] = np.zeros(shape, dtype=np.float32)
+
+    logits = session.run(["logits"], supplied)[0]
+    return causal_cross_entropy(np.asarray(logits), input_ids)
+
+
+def training_graph_loss(train_dir: str | Path, tokenizer_json: str | Path | None = None) -> float:
+    """Run one forward pass of the training graph on the probe batch and return its loss.
+
+    No optimizer step is taken: the question is what the graph's loss IS at step 0, not whether it
+    falls. Requires ``onnxruntime.training`` (the ``ort-training-local`` profile).
+    """
+    from onnxruntime.training.api import CheckpointState, Module
+
+    train_dir = Path(train_dir)
+    for required in ("training_model.onnx", "eval_model.onnx", "checkpoint"):
+        if not (train_dir / required).exists():
+            raise ExportError(f"training artifact missing for parity check: {train_dir / required}")
+
+    state = CheckpointState.load_checkpoint(str(train_dir / "checkpoint"))
+    module = Module(
+        str(train_dir / "training_model.onnx"),
+        state,
+        str(train_dir / "eval_model.onnx"),
+    )
+    input_ids, attention_mask, position_ids = _probe_batch(tokenizer_json)
+
+    # Feed BY NAME, in the order the graph declares — not by a hardcoded decoder tuple.
+    #
+    # This used to be `module(input_ids, attention_mask, position_ids, labels)`, which silently
+    # assumed every trainable graph takes those four inputs in that order. Gemma-3 does not:
+    # `Gemma3TextOnnxConfig` declares no `position_ids`, so its training graph has three user inputs
+    # and the fourth positional argument fell off the end as
+    # "Train input name index out of range. Expected in range [0-3). Actual: 3" — an ORT-internal
+    # message that names neither the graph nor the offending input.
+    #
+    # Reading the names off the graph makes the probe follow whatever the exporter actually produced,
+    # so a new architecture with a different input set needs no edit here. Anything unrecognised fails
+    # closed rather than being fed a zero tensor that would quietly change the measured loss.
+    available = {
+        "input_ids": input_ids,
+        "attention_mask": attention_mask,
+        "position_ids": position_ids,
+        # Labels UNSHIFTED — the graph applies the causal shift itself. See the note in
+        # `artifacts/builder.py::onnx_checktrain`, where pre-shifting inflated every printed loss.
+        "labels": input_ids.copy(),
+    }
+    # ORT's OWN list of user inputs, not a re-derivation from the graph. In a `generate_artifacts`
+    # training graph the trainable weights are graph *inputs* too (that is the format), so filtering
+    # `graph.input` against the initializers yields every LoRA factor and layernorm as well — the
+    # parameters ORT feeds itself from the checkpoint. `Module.input_names()` is the same list
+    # `train_step` indexes into, which is precisely the one that must match.
+    module.train()
+    user_inputs = list(module.input_names())
+
+    unknown = [name for name in user_inputs if name not in available]
+    if unknown:
+        raise ExportError(
+            f"the training graph declares inputs the parity probe cannot supply: {unknown} "
+            f"(graph inputs: {user_inputs}). Add them to the probe batch, or the measured loss would "
+            "be taken against tensors this check never set."
+        )
+
+    outputs = module(*(available[name] for name in user_inputs))
+    return float(outputs[0])
+
+
+def verify_train_inference_parity(
+    inference_model_path: str | Path,
+    train_dir: str | Path,
+    *,
+    max_delta_nats: float = MAX_LOSS_DELTA_NATS,
+) -> ParityResult | None:
+    """Assert both halves of the package agree on the same tokens, within quantization error.
+
+    Returns ``None`` (and warns) when the runtime for either leg is unavailable — the check is skipped
+    loudly, never passed silently.
+
+    Raises:
+        ExportError: naming both losses and the delta, when the two halves disagree by more than
+            ``max_delta_nats``.
+    """
+    try:
+        import onnxruntime  # noqa: F401
+        from onnxruntime.training.api import CheckpointState  # noqa: F401
+    except ImportError as exc:
+        logger.warning(
+            "train/inference parity check SKIPPED (%s). The two halves of this package have not been "
+            "compared numerically; run the training stage under the ort-training-local profile to "
+            "verify them.",
+            exc,
+        )
+        return None
+
+    # Resolve the tokenizer ONCE and hand the same one to both legs. Letting each find its own would
+    # reintroduce the very failure mode this check exists to catch: two graphs scored on different
+    # tokens produce a delta that means nothing, and it would look exactly like a real disagreement.
+    tokenizer_json = find_package_tokenizer(inference_model_path)
+    if tokenizer_json is None:
+        logger.warning(
+            "no tokenizer.json found for %s — the parity probe falls back to fixed Llama-family ids. "
+            "The DELTA below is still a like-for-like comparison, but the absolute losses are not "
+            "meaningful for this model's vocabulary.",
+            inference_model_path,
+        )
+
+    inference_loss = inference_graph_loss(inference_model_path, tokenizer_json)
+    training_loss = training_graph_loss(train_dir, tokenizer_json)
+    result = ParityResult(inference_loss=inference_loss, training_loss=training_loss)
+
+    if result.delta > max_delta_nats:
+        raise ExportError(
+            f"train and inference halves of this package disagree: {result.describe()}, over the "
+            f"{max_delta_nats} nat bound.\n"
+            "Quantization alone does not move a cross-entropy this far. Either the training graph is "
+            "not carrying the same weights as the inference graph, or the two were exported from "
+            "different models/revisions. Check the quantization settings the training stage used "
+            "against what the inference stage shipped."
+        )
+
+    logger.info("train/inference parity: %s, within the %.1f nat bound", result.describe(), max_delta_nats)
+    return result
diff --git a/src/mobiletransformers/artifacts/trainable_gate.py b/src/mobiletransformers/artifacts/trainable_gate.py
new file mode 100644
index 0000000..473a0cb
--- /dev/null
+++ b/src/mobiletransformers/artifacts/trainable_gate.py
@@ -0,0 +1,90 @@
+"""Requested-vs-realized trainable-tensor gate.
+
+Split out of ``artifacts/builder.py`` so it is importable — and therefore testable — in the core env.
+``builder.py`` imports ``onnxruntime.training`` at module scope, so nothing in it can be unit-tested
+outside the ``ort-training-local`` profile; this decision is pure, and the same extract-the-decision
+move as ``cpp/training_inputs.h``.
+
+## The seam this closes
+
+``training_config.json`` declares which parameters require a gradient. The exported graph declares
+which initializers exist, and in what dtype. Both halves were correct on their own and **nothing
+compared them** — the recurring failure shape in this project.
+
+What slipped through: the dynamic quantizer replaced MARS's shared adapter with
+``_quantized``/``_scale``/``_zero_point`` companions. Those are integer tensors and cannot take a
+gradient, so ``gen_artifacts`` correctly routed them to ``frozen_params`` — silently demoting tensors
+the export had just declared trainable. Training still ran and the loss still fell, because the
+per-module factors were still trainable; MARS was simply not training the shared matrices that make it
+MARS. Measured before the fix: **12 realized against 24 requested** on a BERT encoder, **4 against 8**
+on a Llama decoder. LoRA was unaffected, which is why it went unnoticed.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from mobiletransformers.exceptions import ExportError
+
+#: Quantizer-produced companions of a weight: the packed payload plus its dequantization parameters.
+#: Mirrors the quantized-triple vocabulary `HandoffMap.validate` guards on the emit side.
+QUANT_COMPANION_SUFFIXES = ("_quantized", "_scale", "_zero_point")
+
+
+def is_quant_companion(name: str) -> bool:
+    """True for a quantizer-produced companion of a weight (packed payload / scale / zero-point).
+
+    ``requires_grad`` is matched by **substring**, so a trainable ``…lora_B.lora.weight`` also matches
+    ``…lora_B.lora.weight_quantized`` and its ``_scale``/``_zero_point``. Those are not differentiable —
+    ORT rejects the whole artifact generation with *"Cannot compute the partial derivative for
+    '…weight_quantized' as it's unreachable from the output node(s)"*, so a quantized PEFT export could
+    not produce training artifacts at all.
+    """
+    return name.endswith(QUANT_COMPANION_SUFFIXES)
+
+
+def assert_every_requested_tensor_is_trainable(
+    requested: Sequence[str], realized: Sequence[str], frozen: Sequence[str]
+) -> None:
+    """Fail closed when a tensor the export declared trainable did not survive as trainable.
+
+    Compares **sets**, not counts: a count can coincide while the wrong tensors are frozen. The error
+    names the lost tensors and says *why* they were lost, because this failure mode is otherwise
+    completely invisible — every structural assertion passes and the loss still falls.
+
+    :param requested: parameter names from ``training_config.json``'s ``requires_grad``.
+    :param realized: graph initializers that will actually be handed to ``generate_artifacts``.
+    :param frozen: graph initializers that will be frozen (used only to explain a loss).
+    """
+    lost: list[tuple[str, bool]] = []
+    for name in requested:
+        if any(name in realized_name for realized_name in realized):
+            continue
+        quantized_away = any(name in f and is_quant_companion(f) for f in frozen)
+        lost.append((name, quantized_away))
+
+    if not lost:
+        return
+
+    quantized = [name for name, was_quantized in lost if was_quantized]
+    missing = [name for name, was_quantized in lost if not was_quantized]
+    detail: list[str] = []
+    if quantized:
+        detail.append(
+            f"{len(quantized)} were QUANTIZED and so cannot take a gradient (e.g. {quantized[0]}) — "
+            "exclude them from quantization: a tensor declared trainable must never be quantized"
+        )
+    if missing:
+        detail.append(f"{len(missing)} are absent from the graph entirely (e.g. {missing[0]})")
+
+    raise ExportError(
+        f"{len(lost)} of {len(requested)} tensors declared trainable in training_config.json are not "
+        "trainable in the graph: " + "; ".join(detail)
+    )
+
+
+__all__ = [
+    "QUANT_COMPANION_SUFFIXES",
+    "is_quant_companion",
+    "assert_every_requested_tensor_is_trainable",
+]
diff --git a/inference/validator.py b/src/mobiletransformers/artifacts/validation.py
similarity index 65%
rename from inference/validator.py
rename to src/mobiletransformers/artifacts/validation.py
index b3ad2dc..384d71d 100644
--- a/inference/validator.py
+++ b/src/mobiletransformers/artifacts/validation.py
@@ -2,66 +2,80 @@
 Script that validates the generation / inference of the inference artifact model.
 """
 
-import argparse, os, json
+import argparse
+import json
+import os
 import textwrap
-from typing import Dict, List
-import numpy as np
-import yaml
 
+import numpy as np
 from dotenv import load_dotenv
-load_dotenv()
 
-from inference.generator import generate_tokens_onnx
-from tools.utils import create_chat_input
-from tools.parser_config import TRAIN_CONFIG, ARTIFACT_CONFIG, ARTIFACT_VALIDATOR_CONFIG
+from mobiletransformers.utils.yaml import load_config_from_file
+
+load_dotenv()
 
 import onnxruntime as rt
 from onnxruntime import InferenceSession, SessionOptions
-from transformers import AutoTokenizer, AutoConfig
+from transformers import AutoConfig, AutoTokenizer
+
+from mobiletransformers.config.constants import ARTIFACT_CONFIG, ARTIFACT_VALIDATOR_CONFIG, TRAIN_CONFIG
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.inference.generator import generate_tokens_onnx
+from mobiletransformers.utils.templating import create_chat_input
 
-def validate_generation(model_id, model_name, model_dir, test_generation, test_generation_config, load_merged_weights=False, **kwargs):
+
+def validate_generation(
+    model_id,
+    model_name,
+    model_dir,
+    test_generation,
+    test_generation_config,
+    load_merged_weights=False,
+    **kwargs,
+):
 
     model_path = os.path.join(model_dir, model_name)
 
-    tokenizer_config_path = kwargs.get('tokenizer_dir', model_dir)
+    tokenizer_config_path = kwargs.get("tokenizer_dir", model_dir)
     tokenizer_config_path = os.path.join(tokenizer_config_path, "tokenizer_config.json")
 
-    if test_generation_config['type'] == 'genai':
+    if test_generation_config["type"] == "genai":
         genai_config_path = os.path.join(model_dir, "genai_config.json")
         # Overwrite the generation config
-        with open(genai_config_path, "r", encoding="utf-8") as infile:
+        with open(genai_config_path, encoding="utf-8") as infile:
             test_generation_config = json.load(infile)["search"]
-    elif test_generation_config['type'] == 'native':
+    elif test_generation_config["type"] == "native":
         genai_config_path = os.path.join(model_dir, "generation_config.json")
-        with open(genai_config_path, "r", encoding="utf-8") as infile:
+        with open(genai_config_path, encoding="utf-8") as infile:
             file_generation_config = json.load(infile)
-        
+
         # Overwrite from test_generation_config
         for key, v in file_generation_config.items():
             test_generation_config[key] = v
-    
+
     if test_generation:
+        tokenizer = AutoTokenizer.from_pretrained(model_id, token=get_settings().require_hf_token())
 
-        tokenizer = AutoTokenizer.from_pretrained(model_id, token=os.environ['HF_TOKEN'])
-        
         if test_generation_config["hf_tokenizer"]:
             if tokenizer.chat_template is not None:
-                messages = [
-                    {"role": "user", "content": test_generation_config["prompt"]}
-                ]
-                test_generation_config["prompt"] = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+                messages = [{"role": "user", "content": test_generation_config["prompt"]}]
+                test_generation_config["prompt"] = tokenizer.apply_chat_template(
+                    messages, add_generation_prompt=True, tokenize=False
+                )
         else:
             tokenizer_config = {}
             # Load the tokenizer configuration from the JSON file
-            with open(tokenizer_config_path, 'r') as f:
+            with open(tokenizer_config_path) as f:
                 tokenizer_config = json.load(f)
 
             if "chat_template" in tokenizer_config:
-                test_generation_config["prompt"] = create_chat_input(test_generation_config["prompt"], tokenizer_config)
+                test_generation_config["prompt"] = create_chat_input(
+                    test_generation_config["prompt"], tokenizer_config
+                )
                 print("[INFO] Updated the prompt with chat template:")
                 print(test_generation_config["prompt"])
 
-        sess_options = SessionOptions()    
+        sess_options = SessionOptions()
         sess_options.enable_profiling = False
         sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_ALL
 
@@ -69,12 +83,11 @@ def validate_generation(model_id, model_name, model_dir, test_generation, test_g
         # e.g. enable CPU memory arena for faster allocation
         sess_options.enable_mem_pattern = True
         sess_options.enable_cpu_mem_arena = True
-        
+
         external_initializers = []
 
         if load_merged_weights:
-
-            merged_weights_dir = kwargs.get('temp_weights_dir', './build/train/temp_weights/')
+            merged_weights_dir = kwargs.get("temp_weights_dir", "./build/train/temp_weights/")
 
             print(f"[INFO] Loading external initializers from {merged_weights_dir}")
             for fname in os.listdir(merged_weights_dir):
@@ -97,48 +110,63 @@ def validate_generation(model_id, model_name, model_dir, test_generation, test_g
             session = InferenceSession(
                 model_path,
                 sess_options=sess_options,
-                providers=['CPUExecutionProvider'],
-                external_initializers=external_init_map
+                providers=["CPUExecutionProvider"],
+                external_initializers=external_init_map,
             )
             print("[DEBUG] Session initializers:")
             for init in session.get_overridable_initializers():
                 print(f"  - {init}")
         else:
             session = InferenceSession(
-                model_path,
-                sess_options=sess_options,
-                providers=['CPUExecutionProvider']
+                model_path, sess_options=sess_options, providers=["CPUExecutionProvider"]
             )
 
-        config = AutoConfig.from_pretrained(model_id, token=os.environ['HF_TOKEN'])
+        config = AutoConfig.from_pretrained(model_id, token=get_settings().require_hf_token())
 
         input_names = [input_name.name for input_name in session.get_inputs()]
 
-        generate_tokens_onnx(tokenizer,
-                             session,
-                             config,
-                             with_past=any("past_key" in inpn for inpn in input_names),
-                             with_position_ids=("position_ids" in input_names),
-                             with_labels=any("labels" in inpn for inpn in input_names),
-                             **test_generation_config)
+        generate_tokens_onnx(
+            tokenizer,
+            session,
+            config,
+            with_past=any("past_key" in inpn for inpn in input_names),
+            with_position_ids=("position_ids" in input_names),
+            with_labels=any("labels" in inpn for inpn in input_names),
+            **test_generation_config,
+        )
+
 
-class ORTransformerGenerator:
+class MobileTransformerGenerator:
     """
     A reusable class for ONNX model generation that loads configuration once
     and allows multiple generation calls.
     """
-    
-    def __init__(self, model_id, model_name, model_dir, generation_config = {'type': 'native'}, 
-                 load_merged_weights=False, merged_weights_dir = None, **kwargs):
+
+    def __init__(
+        self,
+        model_id,
+        model_name,
+        model_dir,
+        generation_config={"type": "native"},
+        load_merged_weights=False,
+        merged_weights_dir=None,
+        architecture_spec=None,
+        **kwargs,
+    ):
         """
         Initialize the ONNX model generator.
-        
+
         Args:
             model_id (str): HuggingFace model ID
             model_name (str): Name of the model file
             model_dir (str): Directory containing the model
             generation_config (dict): Generation configuration
             load_merged_weights (bool): Whether to load merged weights
+            architecture_spec (ArchitectureSpec | None): resolved architecture, used to rewrite
+                checkpoint names into inference-graph names. When ``None`` the registry's default
+                decoder naming is used — correct for every decoder, and the honest fallback here
+                because this class reconstructs names from ``.npz`` FILENAMES and so has no config to
+                resolve from. Pass one explicitly for an encoder.
             **kwargs: Additional configuration parameters
         """
         self.model_id = model_id
@@ -147,104 +175,108 @@ def __init__(self, model_id, model_name, model_dir, generation_config = {'type':
         self.model_path = os.path.join(model_dir, model_name)
         self.kwargs = kwargs
         self.merged_weights_dir = merged_weights_dir
-        
+        # The attention module spelling is DATA, not a literal. This used to be a hardcoded
+        # `replace("self_attn", "attn")`, allow-listed in the architecture-literal guard with a note
+        # that the fix was to thread a spec in rather than widen the allowance. This is that thread.
+        self.architecture_spec = architecture_spec
+
         # Load and process generation config
         self.generation_config = self._load_generation_config(generation_config)
-        
+
         # Initialize tokenizer
         self.tokenizer = self._initialize_tokenizer()
-        
+
         # Initialize ONNX session
         self.session = self._initialize_session(load_merged_weights)
-        
+
         # Load model config
-        self.config = AutoConfig.from_pretrained(model_id, token=os.environ.get('HF_TOKEN'))
-        
+        self.config = AutoConfig.from_pretrained(model_id, token=os.environ.get("HF_TOKEN"))
+
         # Get input configuration
         self.input_names = [input_name.name for input_name in self.session.get_inputs()]
         self.input_config = self._determine_input_config()
-        
-        print(f"[INFO] ORTransformerGenerator initialized successfully")
+
+        print("[INFO] MobileTransformerGenerator initialized successfully")
         print(f"[INFO] Model: {model_name}")
-    
+
     def _load_generation_config(self, test_generation_config):
         """Load and process generation configuration."""
         config = test_generation_config.copy()
-        
-        if config['type'] == 'genai':
+
+        if config["type"] == "genai":
             genai_config_path = os.path.join(self.model_dir, "genai_config.json")
-            with open(genai_config_path, "r", encoding="utf-8") as infile:
+            with open(genai_config_path, encoding="utf-8") as infile:
                 config = json.load(infile)["search"]
-        elif config['type'] == 'native':
+        elif config["type"] == "native":
             genai_config_path = os.path.join(self.model_dir, "generation_config.json")
-            with open(genai_config_path, "r", encoding="utf-8") as infile:
+            with open(genai_config_path, encoding="utf-8") as infile:
                 file_generation_config = json.load(infile)
-            
+
             # Merge configurations
             for key, v in file_generation_config.items():
                 config[key] = v
-        
+
         return config
-    
+
     def _initialize_tokenizer(self):
         """Initialize the tokenizer with chat template support."""
-        tokenizer = AutoTokenizer.from_pretrained(
-            self.model_id, 
-            token=os.environ.get('HF_TOKEN')
-        )
-        
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id, token=os.environ.get("HF_TOKEN"))
+
         # Store tokenizer configuration for chat template
-        tokenizer_config_path = self.kwargs.get('tokenizer_dir', self.model_dir)
+        tokenizer_config_path = self.kwargs.get("tokenizer_dir", self.model_dir)
         tokenizer_config_path = os.path.join(tokenizer_config_path, "tokenizer_config.json")
-        
+
         self.tokenizer_config = {}
         if os.path.exists(tokenizer_config_path):
-            with open(tokenizer_config_path, 'r') as f:
+            with open(tokenizer_config_path) as f:
                 self.tokenizer_config = json.load(f)
-        
+
         return tokenizer
-    
+
     def _initialize_session(self, load_merged_weights):
         """Initialize ONNX runtime session with optional external initializers."""
-        sess_options = SessionOptions()    
+        sess_options = SessionOptions()
         sess_options.enable_profiling = False
         sess_options.enable_mem_pattern = True
         sess_options.enable_cpu_mem_arena = True
-        #sess_options.log_severity_level = 0  # Enable verbose logging
-        #sess_options.log_verbosity_level = 0
+        # sess_options.log_severity_level = 0  # Enable verbose logging
+        # sess_options.log_verbosity_level = 0
         sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_EXTENDED
 
         if load_merged_weights:
             external_names, external_values = self._load_external_initializers()
-        
+
         if load_merged_weights:
             sess_options.add_external_initializers(external_names, external_values)
             session = InferenceSession(
-                self.model_path,
-                sess_options=sess_options,
-                providers=['CPUExecutionProvider']
+                self.model_path, sess_options=sess_options, providers=["CPUExecutionProvider"]
             )
             print(f"[INFO] Loaded {len(external_names)} external initializers")
         else:
             session = InferenceSession(
-                self.model_path,
-                sess_options=sess_options,
-                providers=['CPUExecutionProvider']
+                self.model_path, sess_options=sess_options, providers=["CPUExecutionProvider"]
             )
-        
+
         return session
-    
+
+    def _attention_module_name(self) -> str:
+        """The attention module spelling for this model, from the registry rather than a literal."""
+        from mobiletransformers.config.registry.architecture import DEFAULT_ATTENTION_MODULE_NAME
+
+        spec = self.architecture_spec
+        return getattr(spec, "attention_module_name", None) or DEFAULT_ATTENTION_MODULE_NAME
+
     def _load_external_initializers(self):
         """Load external initializers from merged weights directory."""
-        
+
         external_initializers = []
-        
+
         if not os.path.exists(self.merged_weights_dir):
             print(f"[WARNING] Merged weights directory not found: {self.merged_weights_dir}")
             return external_initializers
-        
+
         print(f"[INFO] Loading external initializers from {self.merged_weights_dir}")
-        
+
         external_names = []
         external_values = []
 
@@ -253,13 +285,15 @@ def _load_external_initializers(self):
                 npz_path = os.path.join(self.merged_weights_dir, fname)
                 weights = np.load(npz_path)
                 base_layer_name = os.path.splitext(fname)[0]
-                
+
                 for key in weights.files:
                     arr = weights[key]
                     full_key_name = f"{base_layer_name}.{key}"
 
-                    # Renaming conventions
-                    full_key_name = full_key_name.replace("self_attn", "attn")
+                    # Renaming conventions. The source spelling comes from the architecture registry
+                    # (`attention_module_name`), not from a literal — BERT-family encoders spell it
+                    # `attention`, and a hardcoded `self_attn` silently matched nothing there.
+                    full_key_name = full_key_name.replace(self._attention_module_name(), "attn")
                     full_key_name = full_key_name.replace("base_layer", "MatMul")
                     full_key_name = full_key_name.replace("backbone.model", "model")
 
@@ -267,17 +301,17 @@ def _load_external_initializers(self):
                     external_values.append(initializer)
                     external_names.append(full_key_name)
                     print(f"[DEBUG] External initializer: {full_key_name} shape={arr.shape}")
-        
+
         return external_names, external_values
-    
+
     def _determine_input_config(self):
         """Determine input configuration based on model inputs."""
         return {
-            'with_past': any("past_key" in inpn for inpn in self.input_names),
-            'with_position_ids': "position_ids" in self.input_names,
-            'with_labels': any("labels" in inpn for inpn in self.input_names),
+            "with_past": any("past_key" in inpn for inpn in self.input_names),
+            "with_position_ids": "position_ids" in self.input_names,
+            "with_labels": any("labels" in inpn for inpn in self.input_names),
         }
-    
+
     def _prepare_prompt(self, prompt):
         """Prepare prompt with chat template if available."""
         if self.generation_config.get("hf_tokenizer", True):
@@ -289,20 +323,22 @@ def _prepare_prompt(self, prompt):
         else:
             if "chat_template" in self.tokenizer_config:
                 return create_chat_input(prompt, self.tokenizer_config)
-        
+
         return prompt
-    
-    def generate(self, 
-                 prompt="Hello, how is your day?",
-                 max_length=100,
-                 sampling=None,
-                 output_name="logits",
-                 decode_between=False,
-                 use_chat_template=False,
-                 **generation_kwargs):
+
+    def generate(
+        self,
+        prompt="Hello, how is your day?",
+        max_length=100,
+        sampling=None,
+        output_name="logits",
+        decode_between=False,
+        use_chat_template=False,
+        **generation_kwargs,
+    ):
         """
         Generate text using the loaded ONNX model.
-        
+
         Args:
             prompt (str): Input prompt for generation
             max_length (int): Maximum length of generated text
@@ -310,21 +346,21 @@ def generate(self,
             output_name (str): Name of the output tensor
             decode_between (bool): Whether to decode between generation steps
             **generation_kwargs: Additional generation parameters
-            
+
         Returns:
             Generated text or tokens based on configuration
         """
         # Default sampling configuration
         if sampling is None:
             sampling = self.generation_config["sampling"]
-        
+
         # Prepare the prompt with chat template if needed
         if use_chat_template:
             prompt = self._prepare_prompt(prompt)
-        
+
         if decode_between:
             print(f"[INFO] Generating with prompt:\n{prompt}")
-        
+
         # Call the generation function with all necessary parameters
         return generate_tokens_onnx(
             tokenizer=self.tokenizer,
@@ -336,49 +372,50 @@ def generate(self,
             output_name=output_name,
             decode_between=decode_between,
             **self.input_config,
-            **generation_kwargs
+            **generation_kwargs,
         )
-    
+
     def batch_generate(self, prompts, **generation_kwargs):
         """
         Generate text for multiple prompts.
-        
+
         Args:
             prompts (list): List of input prompts
             **generation_kwargs: Generation parameters
-            
+
         Returns:
             List of generated texts
         """
         results = []
         for i, prompt in enumerate(prompts):
-            print(f"[INFO] Processing prompt {i+1}/{len(prompts)}")
+            print(f"[INFO] Processing prompt {i + 1}/{len(prompts)}")
             result = self.generate(prompt=prompt, **generation_kwargs)
             results.append(result)
         return results
-    
+
     def update_generation_config(self, new_config):
         """
         Update generation configuration.
-        
+
         Args:
             new_config (dict): New configuration parameters
         """
         self.generation_config.update(new_config)
-        print(f"[INFO] Generation configuration updated")
-    
+        print("[INFO] Generation configuration updated")
+
     def get_model_info(self):
         """Get information about the loaded model."""
         return {
-            'model_id': self.model_id,
-            'model_path': self.model_path,
-            'input_names': self.input_names,
-            'input_config': self.input_config,
-            'vocab_size': len(self.tokenizer) if self.tokenizer else None,
-            'generation_config': self.generation_config
+            "model_id": self.model_id,
+            "model_path": self.model_path,
+            "input_names": self.input_names,
+            "input_config": self.input_config,
+            "vocab_size": len(self.tokenizer) if self.tokenizer else None,
+            "generation_config": self.generation_config,
         }
 
-def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
+
+def parse_extra_options(extra_options: list[str]) -> dict[str, str]:
     """
     Parse additional options in KEY=VALUE format into a dictionary.
     """
@@ -389,50 +426,36 @@ def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
             options_dict[key] = value
         else:
             raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
-        
+
     print(f"Extra options: {options_dict}")
     return options_dict
 
-def load_config_from_file(config_file: str):
-    """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
-        config = yaml.safe_load(file)
-    return config
 
 def parse_arguments():
-    parser = argparse.ArgumentParser(description="Validator for exported ONNX artifacts for on-device inference.", formatter_class=argparse.RawTextHelpFormatter)
-
-    parser.add_argument(
-        "--model_id",
-        type=str,
-        help="Identifier for the model to be converted."
+    parser = argparse.ArgumentParser(
+        description="Validator for exported ONNX artifacts for on-device inference.",
+        formatter_class=argparse.RawTextHelpFormatter,
     )
+
+    parser.add_argument("--model_id", type=str, help="Identifier for the model to be converted.")
     parser.add_argument(
         "--config_file",
         type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
-    )
-    parser.add_argument(
-        "--inference_artifact_dir",
-        type=str,
-        help="Path to inference artifact directory."
-    )
-    parser.add_argument(
-        "--inference_artifact_name",
-        type=str,
-        help="Name of the inference artifact model."
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
     )
+    parser.add_argument("--inference_artifact_dir", type=str, help="Path to inference artifact directory.")
+    parser.add_argument("--inference_artifact_name", type=str, help="Name of the inference artifact model.")
     parser.add_argument(
         "--test_generation",
         type=bool,
         default=True,
-        help="Whether to perform inference / generation test on the inference exported model."
+        help="Whether to perform inference / generation test on the inference exported model.",
     )
     parser.add_argument(
         "--load_merged_weights",
         type=bool,
         default=True,
-        help="Whether to load the merged weights into inference model."
+        help="Whether to load the merged weights into inference model.",
     )
     parser.add_argument(
         "--test_generation_config",
@@ -450,20 +473,19 @@ def parse_arguments():
             top_k = 10 : Top K for sampling
             top_p = 0.3 : Top P for sampling
             hf_tokenizer = False : Whether to use HF tokenizer or tokenizer from local files
-            """
-            )
+            """),
     )
     args = parser.parse_args()
 
     user_test_generation_config = {}
     default_test_generation_config = {
-       "prompt": "Hello, this is a message for the world. How is your day?", # Prompt for test generation
-        "decode_between": True, # Whether to decode the text while it's generating
-        "max_length" : 100, # Max length of test sequence to generate
-        "sampling": "top_k", # Sampling method
-        "temperature": 0.7, # Temperature for sampling
-        "top_k": 10, # Top K for sampling,
-        "hf_tokenizer": False
+        "prompt": "Hello, this is a message for the world. How is your day?",  # Prompt for test generation
+        "decode_between": True,  # Whether to decode the text while it's generating
+        "max_length": 100,  # Max length of test sequence to generate
+        "sampling": "top_k",  # Sampling method
+        "temperature": 0.7,  # Temperature for sampling
+        "top_k": 10,  # Top K for sampling,
+        "hf_tokenizer": False,
     }
 
     config_dict = None
@@ -474,22 +496,24 @@ def parse_arguments():
         config_dict = load_config_from_file(args.config_file)
 
         # Specific
-        setattr(args, "model_id", config_dict[TRAIN_CONFIG]["model_id"])
-        setattr(args, "inference_artifact_dir", os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "inference"))
-        setattr(args, "inference_artifact_name", f'{config_dict[ARTIFACT_CONFIG]["inference_export_config"]["output_inference_model"]}.onnx')
+        args.model_id = config_dict[TRAIN_CONFIG]["model_id"]
+        args.inference_artifact_dir = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "inference")
+        args.inference_artifact_name = (
+            f"{config_dict[ARTIFACT_CONFIG]['inference_export_config']['output_inference_model']}.onnx"
+        )
+
+        extra_args["tokenizer_dir"] = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "tokenizer")
+        extra_args["temp_weights_dir"] = os.path.join(
+            config_dict[ARTIFACT_CONFIG]["build_path"], "train", "temp_weights"
+        )
 
-        extra_args['tokenizer_dir'] = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "tokenizer")
-        extra_args['temp_weights_dir'] = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "train", "temp_weights")
-        
         # Override any command-line argument with values from the config file
         for key, value in config_dict[ARTIFACT_VALIDATOR_CONFIG].items():
-            
             # Convert to the correct type
             if hasattr(args, key):
                 setattr(args, key, value)
             if key in extra_args:
                 extra_args[key] = value
-            
 
     else:
         user_test_generation_config = parse_extra_options(args.test_generation_config)
@@ -514,5 +538,5 @@ def parse_arguments():
         test_generation=args.test_generation,
         test_generation_config=args.test_generation_config,
         load_merged_weights=args.load_merged_weights,
-        **extra_args
-    )
\ No newline at end of file
+        **extra_args,
+    )
diff --git a/src/mobiletransformers/artifacts/versioning.py b/src/mobiletransformers/artifacts/versioning.py
new file mode 100644
index 0000000..236f64e
--- /dev/null
+++ b/src/mobiletransformers/artifacts/versioning.py
@@ -0,0 +1,55 @@
+"""The ONE canonical ``check_compat`` for every schema-versioned cross-boundary contract.
+
+Owned by #8 (weight-handoff-map plan), reused by the manifest (#13), support matrix (#20), and the
+federated record (#35). Mirrored byte-for-byte in Kotlin/C++ (a shared table-driven fixture,
+``tests/fixtures/check_compat_cases.json``, pins the behaviour across languages).
+
+Semantics (do not improvise): versions are ``"MAJOR.MINOR"`` strings; comparison is on the
+``(major, minor)`` **integer tuple**, never string comparison. A document with a *lower* major than the
+reader is accepted (readers keep old-major compatibility until a deliberate major bump); a *higher*
+document minor is accepted (additive fields, ignored). Fail closed on: malformed versions, a document
+major beyond the reader, or a reader below the document's ``minReaderVersion``.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.exceptions import MobileTransformersError
+
+
+class SchemaVersionError(MobileTransformersError):
+    """A versioned contract is incompatible with this SDK (needs a newer/older reader)."""
+
+
+def parse_version(version: str) -> tuple[int, int]:
+    """Parse ``"MAJOR.MINOR"`` into ``(major, minor)``. Fail closed on anything malformed."""
+    parts = str(version).split(".")
+    if len(parts) != 2:
+        raise SchemaVersionError(f"malformed schema version {version!r} (expected 'MAJOR.MINOR')")
+    try:
+        major, minor = int(parts[0]), int(parts[1])
+    except ValueError as exc:
+        raise SchemaVersionError(f"non-integer schema version {version!r}") from exc
+    if major < 0 or minor < 0:
+        raise SchemaVersionError(f"negative schema version {version!r}")
+    return major, minor
+
+
+def check_compat(doc_schema_version: str, doc_min_reader_version: str, reader_schema_version: str) -> None:
+    """Raise :class:`SchemaVersionError` unless a reader at ``reader_schema_version`` can read a
+    document at ``doc_schema_version`` that requires ``doc_min_reader_version``. Returns ``None`` on
+    accept (fail-closed: only accepts explicitly)."""
+    doc_major, doc_minor = parse_version(doc_schema_version)
+    req_major, req_minor = parse_version(doc_min_reader_version)
+    rdr_major, rdr_minor = parse_version(reader_schema_version)
+
+    if doc_major > rdr_major:
+        raise SchemaVersionError(
+            f"document schema v{doc_major}.{doc_minor} needs a newer SDK (reader supports major {rdr_major})"
+        )
+    if (rdr_major, rdr_minor) < (req_major, req_minor):
+        raise SchemaVersionError(
+            f"document requires reader >= {doc_min_reader_version}; this SDK is {reader_schema_version}"
+        )
+
+
+__all__ = ["SchemaVersionError", "parse_version", "check_compat"]
diff --git a/peft_models/__init__.py b/src/mobiletransformers/cli/__init__.py
similarity index 100%
rename from peft_models/__init__.py
rename to src/mobiletransformers/cli/__init__.py
diff --git a/src/mobiletransformers/cli/agent_dataset.py b/src/mobiletransformers/cli/agent_dataset.py
new file mode 100644
index 0000000..c0fe3c2
--- /dev/null
+++ b/src/mobiletransformers/cli/agent_dataset.py
@@ -0,0 +1,159 @@
+"""`mobiletransformers agent-dataset` — build the #37 tool-call training set.
+
+Two sources, one output shape:
+
+* ``--source google/mobile-actions`` (or any Hub id / local JSONL in that format) imports a real
+  function-calling corpus;
+* ``--source generated --allowlist actions.json`` synthesises a per-user set from an app's own
+  allowlist (`agent/mobile_actions.py`).
+
+Both write ``<output>/<name>.jsonl`` — the `{"prompt", "completion"}` rows `ORTDataCurator` reads on
+device under the `mobile_actions` task — plus ``<output>/action_schema.json``, the allowlist
+`FunctionCallValidator` is constructed from. Emitting both together is the point: the training targets
+and the validator's boundary come out of one command, so they cannot drift.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from mobiletransformers.exceptions import MobileTransformersError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser(
+        "agent-dataset",
+        help="Build the #37 tool-call training set from a corpus or an app allowlist.",
+    )
+    parser.add_argument(
+        "--source",
+        default="google/mobile-actions",
+        help="Hub dataset id, a local .jsonl, or 'generated' to synthesise from --allowlist.",
+    )
+    parser.add_argument("--output", default="build/agent", help="Directory to write into.")
+    parser.add_argument("--name", default="mobile_actions", help="Basename of the emitted .jsonl.")
+    parser.add_argument(
+        "--allowlist",
+        default=None,
+        help="Action-schema JSON. Required for --source generated; ignored otherwise (the corpus "
+        "declares its own tools).",
+    )
+    parser.add_argument("--split", default="train", help="Corpus split to keep ('train'/'eval'/'all').")
+    parser.add_argument("--limit", type=int, default=None, help="Keep at most N rows (after shuffling).")
+    parser.add_argument("--per-action", type=int, default=8, help="Rows per action for 'generated'.")
+    parser.add_argument(
+        "--templates",
+        default=None,
+        help="JSON {actionName: [prompt template, ...]} overriding the built-in phrasings for "
+        "'generated'. Slots name the action's OWN parameters. Needed whenever your allowlist declares "
+        "different parameters than the built-in demo actions — the generator refuses a template that "
+        "references a parameter the action does not declare, so without this an app whose 'set_alarm' "
+        "takes only 'time' cannot use the built-in 'set_alarm' phrasings at all.",
+    )
+    parser.add_argument("--seed", type=int, default=0, help="Determinism for 'generated' and --limit.")
+    parser.add_argument(
+        "--prompt-style",
+        default="context",
+        choices=("context", "user"),
+        help="'context' prepends the corpus's date/day preamble (relative dates need it); "
+        "'user' is the bare instruction.",
+    )
+    parser.add_argument(
+        "--multi-call",
+        default="skip",
+        choices=("skip", "first"),
+        help="Records with several tool calls: drop them (default), or keep the first.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Report what would be written.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def run(args: argparse.Namespace) -> int:
+    import random
+
+    from mobiletransformers.agent.mobile_actions_import import write_action_schema
+
+    out = Path(args.output)
+    dataset_path = out / f"{args.name}.jsonl"
+    schema_path = out / "action_schema.json"
+
+    try:
+        if args.source == "generated":
+            from mobiletransformers.agent.mobile_actions import (
+                generate_examples,
+                load_allowlist,
+                write_jsonl,
+            )
+
+            if not args.allowlist:
+                raise MobileTransformersError("--source generated requires --allowlist <action_schema.json>")
+            specs = load_allowlist(args.allowlist)
+            templates = None
+            if args.templates:
+                try:
+                    templates = {
+                        action: tuple(phrasings)
+                        for action, phrasings in json.loads(
+                            Path(args.templates).read_text(encoding="utf-8")
+                        ).items()
+                    }
+                except (OSError, ValueError, AttributeError) as exc:
+                    raise MobileTransformersError(
+                        f"--templates {args.templates} is not a readable "
+                        f'{{"actionName": ["phrasing", ...]}} JSON object: {exc}'
+                    ) from exc
+            rows = generate_examples(specs, per_action=args.per_action, seed=args.seed, templates=templates)
+        else:
+            from mobiletransformers.agent.mobile_actions import write_jsonl
+            from mobiletransformers.agent.mobile_actions_import import (
+                extract_allowlist,
+                read_records,
+                resolve_source,
+                to_training_rows,
+            )
+
+            path = resolve_source(args.source)
+            # Read once into memory: the allowlist is the union over every record, so a single
+            # streaming pass cannot produce both halves, and the corpus is ~25 MB.
+            records = list(read_records(path))
+            specs = extract_allowlist(records)
+            rows = to_training_rows(
+                records,
+                split=None if args.split == "all" else args.split,
+                prompt_style=args.prompt_style,
+                multi_call=args.multi_call,
+            )
+
+        if not rows:
+            raise MobileTransformersError(
+                f"no rows produced from {args.source!r} (split={args.split!r}) — nothing to train on"
+            )
+        if args.limit is not None and args.limit < len(rows):
+            random.Random(args.seed).shuffle(rows)
+            rows = rows[: args.limit]
+    except MobileTransformersError as exc:
+        print(f"agent-dataset: {exc}")
+        return 1
+
+    actions = ", ".join(sorted(s.action_name for s in specs))
+    if args.dry_run:
+        print(f"[dry-run] {len(rows)} rows, {len(specs)} actions ({actions})")
+        print(f"[dry-run] would write {dataset_path} and {schema_path}")
+        return 0
+
+    write_jsonl(rows, dataset_path)
+    write_action_schema(specs, schema_path)
+    unbindable = sorted(s.action_name for s in specs if not s.allowed_intent)
+    print(f"agent-dataset: wrote {len(rows)} rows -> {dataset_path}")
+    print(f"agent-dataset: wrote {len(specs)} actions -> {schema_path} ({actions})")
+    if unbindable:
+        # Trainable and validatable, but IntentBinder can never fire them. Said out loud because a
+        # silent empty intent would look like a binder bug much later.
+        print(f"agent-dataset: no Android intent mapped for {unbindable} — validated but never bound")
+    return 0
diff --git a/src/mobiletransformers/cli/export.py b/src/mobiletransformers/cli/export.py
new file mode 100644
index 0000000..22fb22e
--- /dev/null
+++ b/src/mobiletransformers/cli/export.py
@@ -0,0 +1,180 @@
+"""`mobiletransformers export` — HF model -> device-ready #14 package (one-command export, #15).
+
+Thin CLI over ``export.pipeline``. ``--dry-run`` resolves the plan + prints a manifest skeleton without
+touching large files or heavy deps; a real run is env-gated (export + ORT-training profiles).
+
+``--config`` supplies defaults for any knob not given on the command line (precedence: CLI > YAML >
+default, as documented in ``docs/EXPORT.md``). ``--validate`` re-reads the package that was just
+written and runs the #13 manifest validation over it, so a broken export fails the command rather than
+being discovered later on device.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from mobiletransformers.exceptions import MobileTransformersError
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("export", help="Export an HF model to a device-ready package.")
+    # Not argparse-required: --config may supply either. run() enforces that one of the two
+    # sources provided them, with a message naming the missing flag.
+    parser.add_argument("--model", default=None, help="HF repo id to export.")
+    parser.add_argument("--output", default=None, help="Output package directory.")
+    parser.add_argument("--task", default=None, help="Optimum task (auto-selected if omitted).")
+    parser.add_argument("--peft", default="lora", help="lora | lora-xs | mars | mars-opt0..mars-opt4.")
+    parser.add_argument("--rank", type=int, default=8, help="LoRA/MARS rank (default 8).")
+    parser.add_argument("--quant", default="int4", help="qint8 | int4 | fp16 (default int4).")
+    parser.add_argument("--variant", default=None, help="Variant id (default cpu-<quant>).")
+    parser.add_argument(
+        "--peft-target",
+        default=None,
+        help=(
+            "Comma-separated modules PEFT adapts (e.g. 'q_proj,v_proj'). Omit to use the architecture "
+            "registry's row for the model, which is the per-model default and the place to add a new "
+            "architecture."
+        ),
+    )
+    parser.add_argument(
+        "--include-rag", action="store_true", help="Also emit the embedding/RAG variant subtree."
+    )
+    parser.add_argument("--embedding-model", default=None, help="Embedding model id for RAG.")
+    parser.add_argument("--genai", action="store_true", help="Declare GenAI engine support for the variant.")
+    parser.add_argument(
+        "--stages",
+        default=None,
+        help="Comma-separated stages to build: inference,training,embedding (default: auto by profile).",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Config YAML supplying defaults for any flag not passed (CLI > YAML > default).",
+    )
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Validate the written package against the manifest contract before returning.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Resolve + print the plan; write nothing.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+#: CLI dest -> its argparse default. A dest still holding its default is "unset", so the YAML overlay
+#: may supply it; anything the user typed wins.
+_OVERLAYABLE: dict[str, object] = {
+    "model": None,
+    "output": None,
+    "task": None,
+    "peft": "lora",
+    "rank": 8,
+    "quant": "int4",
+    "variant": None,
+    "peft_target": None,
+    "include_rag": False,
+    "embedding_model": None,
+    "genai": False,
+    "stages": None,
+}
+
+
+def _apply_config_overlay(args: argparse.Namespace) -> None:
+    """Fill unset knobs from ``--config``'s ``export:`` block (or its top level).
+
+    The flag was previously accepted and silently ignored while ``docs/EXPORT.md`` documented it as a
+    working overlay — so a user's YAML had no effect and nothing said so.
+    """
+    if not getattr(args, "config", None):
+        return
+    from mobiletransformers.utils.yaml import load_config_from_file
+
+    document = load_config_from_file(args.config) or {}
+    if not isinstance(document, dict):
+        raise MobileTransformersError(f"{args.config}: expected a YAML mapping at the top level")
+    section = document.get("export", document)
+    if not isinstance(section, dict):
+        raise MobileTransformersError(f"{args.config}: 'export' must be a mapping")
+
+    unknown = sorted(set(section) - set(_OVERLAYABLE))
+    if unknown:
+        raise MobileTransformersError(
+            f"{args.config}: unknown export key(s) {unknown}; supported: {sorted(_OVERLAYABLE)}"
+        )
+    for dest, default in _OVERLAYABLE.items():
+        if dest in section and getattr(args, dest, default) == default:
+            setattr(args, dest, section[dest])
+
+
+def run(args: argparse.Namespace) -> int:
+    from mobiletransformers.export.pipeline import (
+        ExportPlan,
+        export_package,
+        manifest_skeleton,
+    )
+
+    try:
+        _apply_config_overlay(args)
+    except MobileTransformersError as exc:
+        print(f"export failed: {exc}")
+        return 1
+    for required in ("model", "output"):
+        if not getattr(args, required, None):
+            print(f"export failed: --{required} is required (pass it, or set it in --config)")
+            return 1
+
+    engines = ("native", "genai") if getattr(args, "genai", False) else ("native",)
+    stages = (
+        {s.strip() for s in args.stages.split(",") if s.strip()} if getattr(args, "stages", None) else None
+    )
+    # Empty tuple -> the architecture registry decides. Accepts a comma-separated string (CLI) or an
+    # already-split list (YAML), so a config file can write it as a natural list.
+    raw_targets = getattr(args, "peft_target", None)
+    if isinstance(raw_targets, str):
+        peft_targets = tuple(t.strip() for t in raw_targets.split(",") if t.strip())
+    else:
+        peft_targets = tuple(raw_targets or ())
+    try:
+        result = export_package(
+            model=args.model,
+            output=args.output,
+            task=args.task,
+            peft=args.peft,
+            rank=args.rank,
+            quant=args.quant,
+            variant=args.variant,
+            include_rag=args.include_rag,
+            embedding_model=args.embedding_model,
+            engines=engines,
+            peft_targets=peft_targets,
+            dry_run=args.dry_run,
+            stages=stages,
+        )
+    except MobileTransformersError as exc:
+        print(f"export failed: {exc}")
+        return 1
+
+    if args.dry_run:
+        assert isinstance(result, ExportPlan)
+        skeleton = manifest_skeleton(result)
+        print(
+            f"[dry-run] would export {result.model_id} (task={result.task}, "
+            f"peft={result.peft_method.value}, variant={result.variant_id}) -> {result.output_dir}"
+        )
+        print(json.dumps(skeleton, indent=2, sort_keys=True))
+        return 0
+
+    assert not isinstance(result, ExportPlan)
+    print(f"exported package -> {result.output_dir} (manifest: {result.manifest_path})")
+
+    if getattr(args, "validate", False):
+        from mobiletransformers.cli.validate import validate_package
+
+        try:
+            validate_package(result.output_dir)
+        except MobileTransformersError as exc:
+            print(f"export wrote a package that does not validate: {exc}")
+            return 1
+        print(f"validated package at {result.output_dir}")
+    return 0
diff --git a/src/mobiletransformers/cli/federated.py b/src/mobiletransformers/cli/federated.py
new file mode 100644
index 0000000..5a15f3b
--- /dev/null
+++ b/src/mobiletransformers/cli/federated.py
@@ -0,0 +1,154 @@
+"""`mobiletransformers federated simulate` (#35) — Option-A Flower adapter-aggregation simulation.
+
+Thin CLI over `federated.flower_sim.run_simulation`. The heavy deps (flwr + ORT-training) are imported
+lazily inside the runner, so `--help` and the dispatcher work in the core env.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from mobiletransformers.artifacts.package_paths import PackagePaths
+from mobiletransformers.exceptions import MobileTransformersError
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    fed = subparsers.add_parser("federated", help="Federated adapter experiments (Flower simulation).")
+    fed_sub = fed.add_subparsers(dest="federated_command", metavar="{simulate,serve}")
+
+    sim = fed_sub.add_parser("simulate", help="Run an N-client FedAvg adapter-aggregation simulation.")
+    sim.add_argument("--package", required=True, help="Path to a MobileTransformers package dir.")
+    sim.add_argument("--strategy", default="fedavg", help="Aggregation strategy (v1: fedavg).")
+    sim.add_argument("--clients", type=int, default=4, help="Number of simulated clients.")
+    sim.add_argument("--rounds", type=int, default=3, help="Number of federated rounds.")
+    sim.add_argument("--local-max-steps", type=int, default=2, help="Local ORT steps per client per round.")
+    sim.add_argument("--output", required=True, help="Directory for per-round global adapter artifacts.")
+    sim.set_defaults(func=run_simulate)
+
+    serve = fed_sub.add_parser(
+        "serve", help="Aggregate one round of client adapter records into a global record."
+    )
+    serve.add_argument("--package", required=True, help="Path to a MobileTransformers package dir.")
+    serve.add_argument("--strategy", default="fedavg", help="Aggregation strategy (v1: fedavg).")
+    serve.add_argument(
+        "--updates",
+        required=True,
+        nargs="+",
+        help="Client record files (`<client_id>:<path>:<num_examples>`, or just a path).",
+    )
+    serve.add_argument("--min-clients", type=int, default=2, help="Fewest accepted clients per round.")
+    serve.add_argument("--round", type=int, default=0, help="Round number to stamp on the global record.")
+    serve.add_argument("--output", required=True, help="Path for the aggregated global record.")
+    serve.set_defaults(func=run_serve)
+
+    fed.set_defaults(func=_no_subcommand)
+    return fed
+
+
+def _no_subcommand(args: argparse.Namespace) -> int:
+    print("usage: mobiletransformers federated {simulate,serve} ...")
+    return 2
+
+
+def _parse_update(spec: str) -> tuple[str, str, int]:
+    """`<client_id>:<path>:<num_examples>`, or a bare path (client id = the filename, weight 1).
+
+    The weight matters: FedAvg is example-weighted, so passing bare paths silently makes every client
+    count equally. Accepted for convenience, but it is a different aggregation and worth knowing.
+    """
+    parts = spec.rsplit(":", 2)
+    if len(parts) == 3 and parts[2].isdigit():
+        return parts[0], parts[1], int(parts[2])
+    from pathlib import Path as _P
+
+    return _P(spec).stem, spec, 1
+
+
+def run_serve(args: argparse.Namespace) -> int:
+    from pathlib import Path
+
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+    from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+    from mobiletransformers.federated.gateway import FederatedGateway
+
+    if args.strategy != "fedavg":
+        print(f"unsupported strategy {args.strategy!r} (v1 supports: fedavg)")
+        return 2
+
+    try:
+        pkg = Path(args.package)
+        manifest = MobileTransformersManifest.load(pkg / "mobiletransformers_manifest.json")
+        handoff = HandoffMap.load(pkg / manifest.data["weightHandoff"])
+        gateway = FederatedGateway(
+            handoff,
+            base_model_id=manifest.data.get("baseModelId", "unknown"),
+            peft_method=(manifest.data.get("peftMethods") or ["lora"])[0],
+            min_clients=args.min_clients,
+        )
+
+        submissions = []
+        for spec in args.updates:
+            client_id, path, num_examples = _parse_update(spec)
+            submissions.append((client_id, Path(path).read_bytes(), num_examples))
+
+        result = gateway.aggregate(submissions, round_number=args.round)
+        out = Path(args.output)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(result.blob)
+
+        print(result.describe())
+        for client_id, reason in result.rejected:
+            print(f"  rejected {client_id}: {reason}")
+        print(f"global record -> {out}")
+    except MobileTransformersError as exc:
+        print(f"error: {exc}")
+        return 1
+    return 0
+
+
+def run_simulate(args: argparse.Namespace) -> int:
+    from pathlib import Path
+
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+    from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+    from mobiletransformers.federated.flower_sim import run_simulation
+
+    try:
+        pkg = Path(args.package)
+        manifest = MobileTransformersManifest.load(pkg / "mobiletransformers_manifest.json")
+        handoff = HandoffMap.load(pkg / manifest.data["weightHandoff"])
+        peft_methods = manifest.data.get("peftMethods") or ["lora"]
+
+        # The manifest is the single source of truth for where a stage lives. A hub package puts the
+        # train stage at `variants/<variantId>/train`; only the on-device CACHE layout has it flat at
+        # `<root>/train`. Resolving it here (rather than appending "train" in the client) is what
+        # makes `--package` accept a real exported package.
+        variant = manifest.select_variant(
+            abis=("arm64-v8a",),
+            requested_features=("train",),
+        )
+        paths = PackagePaths.for_hub(pkg, variant)
+        train_dir = paths.train
+        tokenizer_dir = paths.tokenizer
+        if not (train_dir / "checkpoint").exists():
+            raise MobileTransformersError(
+                f"no training checkpoint at {train_dir} — export the package with the training stage "
+                "(`mobiletransformers export --stages training`) before simulating"
+            )
+        run_simulation(
+            handoff,
+            base_model_id=manifest.data.get("baseModelId", "unknown"),
+            peft_method=peft_methods[0],
+            clients=args.clients,
+            rounds=args.rounds,
+            local_max_steps=args.local_max_steps,
+            output_dir=args.output,
+            train_dir=train_dir,
+            tokenizer_dir=tokenizer_dir,
+            strategy=args.strategy,
+        )
+    except MobileTransformersError as exc:
+        print(f"federated simulate failed: {exc}")
+        return 1
+    print(f"federated simulation complete -> {args.output}")
+    return 0
diff --git a/src/mobiletransformers/cli/main.py b/src/mobiletransformers/cli/main.py
new file mode 100644
index 0000000..65cea8e
--- /dev/null
+++ b/src/mobiletransformers/cli/main.py
@@ -0,0 +1,72 @@
+"""MobileTransformers CLI entry point.
+
+Canonical argparse dispatcher. Every later CLI plan (one-command export, hub
+pull/install, ...) registers its subcommand into *this* dispatcher via the
+``add_parser(subparsers)`` / ``run(args) -> int`` shape used by the stub modules
+below. Do not add a ``cli/__main__.py`` or switch to typer/click.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from mobiletransformers import __version__
+from mobiletransformers.cli import (
+    agent_dataset,
+    export,
+    federated,
+    package_model,
+    pull,
+    push,
+    push_adapter,
+    support_matrix,
+    validate,
+)
+
+_SUBCOMMANDS = (
+    export,
+    validate,
+    package_model,
+    push,
+    support_matrix,
+    pull,
+    push_adapter,
+    federated,
+    agent_dataset,
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="mobiletransformers",
+        description="Export and Android runtime tooling for on-device transformers.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(
+        dest="command",
+        metavar=(
+            "{export,validate,package-model,push,support-matrix,pull,install-package,"
+            "push-adapter,federated,agent-dataset}"
+        ),
+    )
+    for module in _SUBCOMMANDS:
+        module.add_parser(subparsers)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Argparse dispatcher. Subcommands: export, validate, package-model.
+
+    Returns a process exit code. Both ``mobiletransformers --help`` and
+    ``python -m mobiletransformers.cli.main --help`` work.
+    """
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if getattr(args, "command", None) is None:
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/mobiletransformers/cli/package_model.py b/src/mobiletransformers/cli/package_model.py
new file mode 100644
index 0000000..7be1538
--- /dev/null
+++ b/src/mobiletransformers/cli/package_model.py
@@ -0,0 +1,227 @@
+"""`mobiletransformers package-model` — re-emit a package's manifest + checksums from its tree.
+
+Previously a stub that printed "not yet wired" and **returned 0**, i.e. it reported success for
+anything — including a package that did not exist. `make package-model` and `docs/PUBLIC_API.md`
+advertised it regardless.
+
+Scope: this does NOT run an export (that is `mobiletransformers export`, #15). It re-derives the
+integrity half of `mobiletransformers_manifest.json` — `fileSizes`, `sha256`, `requiredFiles`,
+per-variant `paths` and the `downloadPlan` — by stream-hashing the on-disk tree, reusing the existing
+manifest for the descriptive half (base model, variants, provenance). That is what you need after a
+package tree changes underneath its manifest: a merged checkpoint copied back off a device, a
+hand-swapped tokenizer, a stage directory added.
+
+Fails closed: no directory, no manifest, or an unparseable manifest is a non-zero exit with a typed
+error, never a silent 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.exceptions import MobileTransformersError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: Manifest keys that `build_manifest` reads out of its ``report`` argument. Re-emitting from an
+#: existing manifest means feeding these back in from the manifest's own top level.
+_REPORT_KEYS = (
+    "mobiletransformersVersion",
+    "architectures",
+    "supportedTasks",
+    "selectedTask",
+    "trustRemoteCode",
+    "optimumOnnxVersion",
+    "transformersVersion",
+    "onnxRuntimeTrainingVersion",
+    "onnxRuntimeGenAIVersion",
+    "peftMethods",
+    "quantization",
+    "trainableParameterCount",
+    "trainingParameterCount",
+    "androidRuntime",
+    "license",
+)
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser(
+        "package-model",
+        help="Re-emit a package's manifest + checksums from its on-disk tree.",
+    )
+    parser.add_argument("--package", default=None, help="Package directory to re-emit.")
+    parser.add_argument("--config", help="Path to config YAML (validates it parses).")
+    parser.add_argument("--dry-run", action="store_true", help="Report what would change, write nothing.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def _recover_inference_provenance(package: Path, existing: dict[str, Any], report: dict[str, Any]) -> None:
+    """Fill unset provenance in ``report`` from each variant's ``inference/optimum_config.json``.
+
+    Reads the side-car the inference stage wrote **next to the graph it describes**, rather than
+    re-deriving from the current environment: the profile doing the re-emit need not be the one that
+    exported the graph, and stamping a version that never touched it is worse than the null it
+    replaces. Only unset-shaped values are filled, so a manifest that already knows wins.
+
+    Shares :data:`~mobiletransformers.export.pipeline._INFERENCE_PROVENANCE` with the export path so
+    the two cannot disagree about which fields the inference stage owns.
+    """
+    from mobiletransformers.artifacts.package_paths import PackagePaths
+    from mobiletransformers.export.pipeline import _INFERENCE_PROVENANCE
+
+    for variant in existing.get("variants") or []:
+        # `for_hub` honours the variant's DECLARED `paths`, which need not be `variants/<id>/<stage>`;
+        # re-deriving that layout here would quietly read the wrong directory for a package that says
+        # otherwise, and is what the stage-path guard exists to prevent.
+        #
+        # It fails closed on a variant with no `paths` map (a package predating that field). Recovering
+        # provenance is a best-effort enhancement, so that is a SKIP, not an error: refusing to re-emit
+        # a package whose integrity block is perfectly re-derivable, because an optional nicety could
+        # not be applied, would be strictly worse than the nulls it was meant to fill.
+        try:
+            inference_dir = PackagePaths.for_hub(package, variant).inference
+        except MobileTransformersError:
+            continue
+        config_path = inference_dir / "optimum_config.json"
+        if not config_path.is_file():
+            continue
+        try:
+            recorded = json.loads(config_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):  # a corrupt side-car must not fail an otherwise-good re-emit
+            logger.warning("ignoring unreadable %s while re-emitting provenance", config_path)
+            continue
+
+        for report_key, config_key in _INFERENCE_PROVENANCE:
+            value = recorded.get(config_key)
+            if value in (None, "", [], {}):
+                continue
+            if report_key == "architectures":
+                value = [value]
+            current = report.get(report_key)
+            if current in (None, "", [], {}) or (report_key == "trustRemoteCode" and current is False):
+                report[report_key] = value
+                logger.info("recovered %s=%r from %s", report_key, value, config_path)
+
+
+def repackage(package_dir: str | Path, *, dry_run: bool = False) -> dict[str, Any]:
+    """Re-derive and (unless ``dry_run``) rewrite the manifest for an existing package.
+
+    Returns the freshly built manifest dict. Raises :class:`MobileTransformersError` if the directory
+    or its manifest is missing or unusable — never returns a partially-built manifest.
+    """
+    from mobiletransformers.hub.package_format import (
+        MANIFEST_FILENAME,
+        build_manifest,
+        write_manifest,
+        write_variant_checksums,
+    )
+
+    package = Path(package_dir)
+    if not package.is_dir():
+        raise MobileTransformersError(f"not a package directory: {package}")
+
+    manifest_path = package / MANIFEST_FILENAME
+    if not manifest_path.is_file():
+        raise MobileTransformersError(
+            f"no {MANIFEST_FILENAME} in {package} — run `mobiletransformers export` to create a package"
+        )
+    try:
+        existing = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise MobileTransformersError(f"{manifest_path} is not valid JSON: {exc}") from exc
+
+    variants = existing.get("variants")
+    if not variants:
+        raise MobileTransformersError(f"{manifest_path} declares no variants")
+    base_model_id = existing.get("baseModelId")
+    if not base_model_id:
+        raise MobileTransformersError(f"{manifest_path} has no baseModelId")
+
+    report = {key: existing[key] for key in _REPORT_KEYS if key in existing}
+
+    # Recover the inference-stage provenance the manifest may be missing.
+    #
+    # A train-capable package is necessarily built by two profile-scoped runs (the onnxruntime
+    # profiles cannot co-install), and the second one rebuilds the manifest without the fields only the
+    # inference stage knows. `export/pipeline.py` learned to read them back off
+    # `inference/optimum_config.json` — but a re-emit here rebuilt `report` purely from the manifest,
+    # so nulls stayed null and `package-model` could never repair a package that had them. That is
+    # exactly the package you re-emit before publishing: `build/pkg` reached the Hub-ready state with
+    # `transformersVersion: null`, `architectures: []` and `optimumOnnxVersion: null` while the
+    # `optimum_config.json` next to its graph held all three.
+    _recover_inference_provenance(package, existing, report)
+
+    # `write_variant_checksums` adds files to the tree, so hash twice — the same two-pass shape the
+    # export pipeline uses, so a re-emit is byte-identical to a fresh export of the same tree.
+    def _build() -> dict[str, Any]:
+        return build_manifest(
+            package,
+            variants,
+            base_model_id=base_model_id,
+            report=report,
+            default_variant=existing.get("defaultVariant"),
+            exported_at=existing.get("exportedAt"),
+        )
+
+    def _without_derived(entry: Any) -> Any:
+        """Drop `checksums.json` keys — `sha256`/`fileSizes` are maps, `requiredFiles` is a list."""
+        if isinstance(entry, dict):
+            return {rel: v for rel, v in entry.items() if not str(rel).endswith("/checksums.json")}
+        return [rel for rel in entry if not str(rel).endswith("/checksums.json")]
+
+    if dry_run:
+        rebuilt = _build()
+        # `checksums.json` is derived from the first pass, so on a re-emit it is present where a fresh
+        # export's first pass had nothing. Compare the real content, not that self-reference.
+        changed = sorted(
+            key
+            for key in ("fileSizes", "sha256", "requiredFiles")
+            if _without_derived(rebuilt.get(key, {})) != _without_derived(existing.get(key, {}))
+        )
+        logger.info(
+            "package-model --dry-run: %s would %s",
+            package,
+            f"change {', '.join(changed)}" if changed else "be unchanged",
+        )
+        return rebuilt
+
+    # Reproduce a fresh export's initial condition: the first `build_manifest` must not see the
+    # previous run's `checksums.json`, or each variant's checksum file would grow an entry for itself
+    # and a re-emit would never reach a fixpoint.
+    for variant in variants:
+        stale = package / "variants" / str(variant["id"]) / "checksums.json"
+        stale.unlink(missing_ok=True)
+
+    write_variant_checksums(package, _build())
+    rebuilt = _build()
+    write_manifest(package, rebuilt)
+    return rebuilt
+
+
+def run(args: argparse.Namespace) -> int:
+    package = getattr(args, "package", None)
+    config = getattr(args, "config", None)
+    dry_run = bool(getattr(args, "dry_run", False))
+
+    if not package:
+        print("package-model: pass --package <dir> (the package to re-emit)")
+        return 2
+
+    try:
+        if config:
+            from mobiletransformers.cli.validate import validate_config
+
+            validate_config(config)
+        manifest = repackage(package, dry_run=dry_run)
+    except MobileTransformersError as exc:
+        print(f"package-model: {exc}")
+        return 1
+
+    verb = "would re-emit" if dry_run else "re-emitted"
+    print(f"package-model: {verb} {len(manifest['sha256'])} files for {manifest['baseModelId']}")
+    return 0
diff --git a/src/mobiletransformers/cli/pull.py b/src/mobiletransformers/cli/pull.py
new file mode 100644
index 0000000..f707bc7
--- /dev/null
+++ b/src/mobiletransformers/cli/pull.py
@@ -0,0 +1,77 @@
+"""`mobiletransformers pull` + `install-package` (#21) — download a Hub package and materialize the cache.
+
+`pull` fetches manifest-first, selects a variant, downloads only the requested feature groups
+(sha256-verified). `install-package` reshapes a staged package into the `LLMRepository` cache layout.
+Both are thin CLIs over `hub.pull`.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from mobiletransformers.exceptions import MobileTransformersError
+
+# The dispatcher registers each module's add_parser; expose two here via separate modules is overkill,
+# so this single module contributes both subcommands through add_parser.
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    pull = subparsers.add_parser("pull", help="Download a Hub package (manifest-first, sha256-verified).")
+    pull.add_argument("--repo-id", required=True, help="HF repo id of the package.")
+    pull.add_argument("--revision", default="main", help="Git revision (default main).")
+    pull.add_argument("--variant", default=None, help="Variant id (auto-selected if omitted).")
+    pull.add_argument(
+        "--features", default="inference", help="Comma-separated feature groups (e.g. inference,train,rag)."
+    )
+    pull.add_argument("--out", default=None, help="Staging output dir (default ./.mt-pull/<repo>).")
+    pull.add_argument(
+        "--token",
+        default=None,
+        help="Hub token, for a private or gated repo. Defaults to $HF_TOKEN. `pull_package` has always "
+        "accepted one; the CLI did not pass it, so a private package could only be fetched from Python.",
+    )
+    pull.set_defaults(func=run_pull)
+
+    inst = subparsers.add_parser(
+        "install-package", help="Materialize a staged package into the cache layout."
+    )
+    inst.add_argument("--staging", required=True, help="Staged package directory (from `pull`).")
+    inst.add_argument("--repo-id", required=True, help="HF repo id (used for the sanitized cache dir name).")
+    inst.add_argument("--cache-root", required=True, help="Cache root to install into.")
+    inst.add_argument("--variant", default=None, help="Variant id (default = manifest defaultVariant).")
+    inst.set_defaults(func=run_install)
+    return pull
+
+
+def run_pull(args: argparse.Namespace) -> int:
+    from mobiletransformers.config.settings import get_settings
+    from mobiletransformers.hub.pull import pull_package
+
+    features = tuple(f.strip() for f in args.features.split(",") if f.strip())
+    try:
+        staging = pull_package(
+            args.repo_id,
+            revision=args.revision,
+            variant=args.variant,
+            features=features,
+            dest=args.out,
+            # Via `config.settings`, the one sanctioned credential-read site, so `.env` is honoured.
+            token=getattr(args, "token", None) or get_settings().hf_token,
+        )
+    except MobileTransformersError as exc:
+        print(f"pull failed: {exc}")
+        return 1
+    print(f"pulled {args.repo_id} -> {staging}")
+    return 0
+
+
+def run_install(args: argparse.Namespace) -> int:
+    from mobiletransformers.hub.pull import install_package
+
+    try:
+        target = install_package(args.staging, args.cache_root, args.repo_id, variant=args.variant)
+    except MobileTransformersError as exc:
+        print(f"install-package failed: {exc}")
+        return 1
+    print(f"installed -> {target}")
+    return 0
diff --git a/src/mobiletransformers/cli/push.py b/src/mobiletransformers/cli/push.py
new file mode 100644
index 0000000..760209d
--- /dev/null
+++ b/src/mobiletransformers/cli/push.py
@@ -0,0 +1,109 @@
+"""`mobiletransformers push` — validate a package (#13 gate), render a model card, upload to the Hub (#15).
+
+Fails closed before any upload: the package must pass the #13 manifest validator. ``--dry-run`` renders
+the card + writes ``README.md`` without uploading. The Hub upload lazy-imports ``huggingface_hub``.
+
+The target repo must already exist unless ``--create`` is passed. Creating on demand was the previous
+default, which meant a mistyped repo id produced a new repo rather than an error — the wrong trade for
+a command that normally runs against an organisation account.
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.exceptions import MobileTransformersError
+from mobiletransformers.export.model_card import BANNER_FILENAME, render_model_card
+from mobiletransformers.hub.package_format import MANIFEST_FILENAME
+
+
+def _repo_root() -> Path:
+    """The checkout this package was installed from, for build-time-only assets like the banner.
+
+    `src/mobiletransformers/cli/push.py` -> up four. Returns a path that simply will not exist for a
+    wheel installed outside a checkout, which the caller already handles by skipping the banner —
+    an installed wheel has no `docs/` and should publish a card without a header image rather than
+    fail the push.
+    """
+    return Path(__file__).resolve().parents[3]
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("push", help="Validate + publish a package to the Hugging Face Hub.")
+    parser.add_argument("--package", required=True, help="Package directory to publish.")
+    parser.add_argument("--repo", required=True, help="Target HF repo id.")
+    parser.add_argument(
+        "--create",
+        action="store_true",
+        help="Create the repo if it does not exist. OFF by default: pushing to an existing repo is the "
+        "normal case, and creating on demand means a mistyped id silently makes a new repo instead of "
+        "failing — under an org account that is a stray public repo nobody asked for.",
+    )
+    parser.add_argument("--private", action="store_true", help="With --create, create the repo as private.")
+    parser.add_argument(
+        "--token",
+        default=None,
+        help="Hub token. Defaults to $HF_TOKEN (huggingface_hub's own fallback). Pass this when the "
+        "target is an ORGANISATION repo and the org token lives in a differently-named variable — "
+        "otherwise the upload silently authenticates as the wrong identity or not at all.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Validate + render card; do not upload.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def run(args: argparse.Namespace, *, uploader: Callable[..., Any] | None = None) -> int:
+    """``uploader`` is injectable for tests (defaults to huggingface_hub.upload_folder)."""
+    package_dir = Path(args.package)
+    try:
+        manifest = MobileTransformersManifest.load(package_dir / MANIFEST_FILENAME)
+        manifest.validate(package_dir)  # #13 gate — fail closed before upload
+    except MobileTransformersError as exc:
+        print(f"push aborted — package failed validation: {exc}")
+        return 1
+
+    # Stage the header image INTO the package so the card can reference it relatively. Hot-linking
+    # the framework repository would tie a published page to that repo's visibility, default branch
+    # and directory layout — and it renders as a broken image for as long as any of those disagree.
+    # Copied here rather than at export time because it is a publishing concern: a package pulled to
+    # a device has no use for it.
+    banner_source = _repo_root() / "docs" / "assets" / BANNER_FILENAME
+    banner: str | None = None
+    if banner_source.is_file():
+        shutil.copyfile(banner_source, package_dir / BANNER_FILENAME)
+        banner = BANNER_FILENAME
+    else:
+        # Referencing a name we did not upload is worse than having no banner at all.
+        print(f"note: {banner_source} not found — publishing the card without its header image")
+
+    card = render_model_card(manifest.to_dict(), str(package_dir), banner=banner, repo_id=args.repo)
+    (package_dir / "README.md").write_text(card, encoding="utf-8")
+
+    if args.dry_run:
+        print(f"[dry-run] validated {package_dir}; wrote README.md ({len(card)} chars); not uploading.")
+        return 0
+
+    # Explicit beats ambient: `huggingface_hub` falls back to $HF_TOKEN and then to the cached CLI
+    # login, so an org push with no token argument can succeed as the WRONG identity — into a personal
+    # namespace, or with the cached user's permissions — and look exactly like success.
+    #
+    # The fallback goes through `config.settings` rather than `os.environ` directly: that is the one
+    # sanctioned credential-read site (`test_guards.py::test_no_direct_secret_environment_reads`), and
+    # it also picks up `.env`, which a bare environ read would not.
+    token = getattr(args, "token", None) or get_settings().hf_token
+
+    if uploader is None:
+        from huggingface_hub import create_repo, upload_folder
+
+        if getattr(args, "create", False):
+            create_repo(args.repo, exist_ok=True, private=args.private, token=token)
+        uploader = upload_folder
+    uploader(repo_id=args.repo, folder_path=str(package_dir), token=token)
+    print(f"pushed {package_dir} -> {args.repo}")
+    return 0
diff --git a/src/mobiletransformers/cli/push_adapter.py b/src/mobiletransformers/cli/push_adapter.py
new file mode 100644
index 0000000..2a4aaa8
--- /dev/null
+++ b/src/mobiletransformers/cli/push_adapter.py
@@ -0,0 +1,141 @@
+"""`mobiletransformers push-adapter` (#22) — export a trained adapter from the cache and publish it.
+
+Gate (``adapter.convert.to_peft_layout``): a clean LoRA maps to a **PEFT-compatible** adapter (Mode 1,
+`adapter_config.json` at root); everything else (all MARS) becomes a **MobileTransformers-native**
+adapter (Mode 2, merged tensors + handoff map + `mobiletransformers_adapter.json`). Mirrors `cli/push.py`
+(injectable `uploader`, fail-closed card assertions, Hub upload lazy-imported). `--peft-only` errors
+instead of falling back to native.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.adapter.convert import materialize_peft_weights, to_peft_layout
+from mobiletransformers.adapter.export import AdapterPackage, export_adapter_from_cache
+from mobiletransformers.adapter.model_card import assert_required_sections, render_adapter_card
+from mobiletransformers.artifacts.package_paths import PackagePaths
+from mobiletransformers.exceptions import ExportError, MobileTransformersError
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("push-adapter", help="Publish a trained adapter from the device cache.")
+    parser.add_argument(
+        "--cache-repo", required=True, help="Materialized cache repo dir (train/ + inference/)."
+    )
+    parser.add_argument("--repo-id", required=True, help="Target HF adapter repo id.")
+    parser.add_argument(
+        "--out", default=None, help="Build dir for the adapter (default <cache-repo>/.adapter-push)."
+    )
+    parser.add_argument(
+        "--base-license", default="see upstream", help="Exact upstream base-model license string."
+    )
+    parser.add_argument("--private", action="store_true", help="Create the repo as private.")
+    parser.add_argument(
+        "--peft-only", action="store_true", help="Error instead of falling back to native mode."
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Build + validate the card; do not upload.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def run(args: argparse.Namespace, *, uploader: Callable[..., Any] | None = None) -> int:
+    try:
+        pkg = export_adapter_from_cache(args.cache_repo)
+    except MobileTransformersError as exc:
+        print(f"push-adapter failed: {exc}")
+        return 1
+
+    layout = to_peft_layout(pkg)
+    if args.peft_only and layout is None:
+        print(
+            f"push-adapter --peft-only: {pkg.peft_method!r} does not map to a PEFT adapter "
+            "(would be native mode)"
+        )
+        return 1
+    mode = "peft" if layout is not None else "native"
+
+    out = Path(args.out) if args.out else Path(args.cache_repo) / ".adapter-push"
+    if out.exists():
+        shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    if mode == "peft":
+        assert layout is not None
+        (out / "adapter_config.json").write_text(
+            json.dumps(layout.adapter_config, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+        )
+        # A Mode-1 repo without adapter_model.safetensors is unusable — `PeftModel.from_pretrained`
+        # fails on it — so this must NOT be skipped silently (it was, which shipped weightless pushes).
+        # Materializing needs the `train` extra (torch + safetensors) and onnxruntime-training for the
+        # default factor reader, so `materialize_peft_weights` raises ExportError outside that profile.
+        # A --dry-run stays runnable in the core env and reports what is missing instead of failing.
+        try:
+            materialize_peft_weights(pkg, layout, str(out))
+        except ExportError as exc:
+            if not args.dry_run:
+                raise MobileTransformersError(
+                    f"cannot publish a Mode-1 (PEFT) adapter without adapter_model.safetensors: {exc}"
+                ) from exc
+            print(f"[dry-run] adapter_model.safetensors NOT materialized: {exc}")
+    else:
+        _build_native_subtree(pkg, out)
+
+    card = render_adapter_card(pkg, mode=mode, base_model_license=args.base_license)
+    assert_required_sections(card, pkg)
+    (out / "README.md").write_text(card, encoding="utf-8")
+
+    if args.dry_run:
+        print(f"[dry-run] built {mode} adapter at {out}; card validated; not uploading.")
+        return 0
+
+    if uploader is None:
+        from huggingface_hub import create_repo, upload_folder
+
+        create_repo(args.repo_id, exist_ok=True, private=args.private)
+        uploader = upload_folder
+    uploader(repo_id=args.repo_id, folder_path=str(out))
+    print(f"pushed {mode} adapter {out} -> {args.repo_id}")
+    return 0
+
+
+def _build_native_subtree(pkg: AdapterPackage, out: Path) -> None:
+    """Mode 2: merged per-tensor .bin(s) + weight_handoff_map.json + training_config.json + header."""
+    cache = Path(pkg.cache_repo_dir)
+    paths = PackagePaths.for_cache(cache.parent, cache.name)
+    inference = paths.inference
+    for t in pkg.tensors:
+        src = inference / t.external_data_location
+        if src.is_file():
+            shutil.copy2(src, out / t.external_data_location)
+            sha = src.with_suffix(src.suffix + ".sha256")
+            if sha.is_file():
+                shutil.copy2(sha, out / sha.name)
+    for name in ("weight_handoff_map.json",):
+        src = paths.train / name
+        if src.is_file():
+            shutil.copy2(src, out / name)
+    tc = paths.train / "training_config.json"
+    if tc.is_file():
+        shutil.copy2(tc, out / "training_config.json")
+    (out / "mobiletransformers_adapter.json").write_text(
+        json.dumps(
+            {
+                "mode": "native",
+                "baseModelId": pkg.base_model_id,
+                "peftMethod": pkg.peft_method,
+                "marsOptimizationLevel": pkg.mars_optimization_level,
+                "handoffMode": pkg.handoff_mode,
+                "weightHandoff": "weight_handoff_map.json",
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
diff --git a/src/mobiletransformers/cli/support_matrix.py b/src/mobiletransformers/cli/support_matrix.py
new file mode 100644
index 0000000..dc478be
--- /dev/null
+++ b/src/mobiletransformers/cli/support_matrix.py
@@ -0,0 +1,62 @@
+"""`mobiletransformers support-matrix` — generate model_support_matrix.json (#20).
+
+Reads a candidate list (``--candidates`` JSON, else built-ins), optionally merges an
+``android_probes.json`` (``--probes``), and writes the full matrix (``--out``) plus a filtered
+user-facing view (``--docs``). Detection needs the export profile (transformers/optimum); without it,
+pass ``--candidates`` with pre-resolved tasks is not supported — run under the export profile.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+#: Fallback candidate families if no --candidates file is given (mirrors config.yml SUPPORT_MATRIX).
+_DEFAULT_CANDIDATES = [
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    "Qwen/Qwen2-0.5B",
+    "HuggingFaceTB/SmolLM2-135M",
+]
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("support-matrix", help="Generate the model support matrix (#20).")
+    parser.add_argument("--candidates", default=None, help="JSON file: list of ids or {modelId,...} objects.")
+    parser.add_argument(
+        "--probes", default=None, help="android_probes.json produced by device/CI instrumentation."
+    )
+    parser.add_argument(
+        "--out", default="build/support/model_support_matrix.json", help="Full matrix output path."
+    )
+    parser.add_argument("--docs", default=None, help="Optional filtered user-facing matrix output path.")
+    parser.add_argument(
+        "--md", default=None, help="Optional COMPATIBILITY_MATRIX.md render output path (#31, F6)."
+    )
+    parser.add_argument("--generated-at", default=None, help="ISO timestamp to stamp into the matrix.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def run(args: argparse.Namespace) -> int:
+    from mobiletransformers.support.matrix import build_matrix, write_filtered_docs, write_matrix
+
+    if args.candidates:
+        candidates = json.loads(Path(args.candidates).read_text(encoding="utf-8"))
+    else:
+        candidates = list(_DEFAULT_CANDIDATES)
+
+    matrix = build_matrix(candidates, probes_path=args.probes, generated_at=args.generated_at)
+    out = write_matrix(matrix, args.out)
+    print(f"wrote support matrix ({len(matrix.models)} models) -> {out}")
+    if args.docs:
+        docs = write_filtered_docs(matrix, args.docs)
+        print(f"wrote filtered user-facing matrix -> {docs}")
+    if args.md:
+        from mobiletransformers.support.render import render_matrix_markdown
+
+        md_path = Path(args.md)
+        md_path.parent.mkdir(parents=True, exist_ok=True)
+        md_path.write_text(render_matrix_markdown(matrix), encoding="utf-8")
+        print(f"wrote compatibility matrix doc -> {md_path}")
+    return 0
diff --git a/src/mobiletransformers/cli/validate.py b/src/mobiletransformers/cli/validate.py
new file mode 100644
index 0000000..3951554
--- /dev/null
+++ b/src/mobiletransformers/cli/validate.py
@@ -0,0 +1,81 @@
+"""`mobiletransformers validate` — check a written package against the #13/#14 contract.
+
+Also backs ``mobiletransformers export --validate``. Previously a stub that printed "not yet wired"
+and returned 0, i.e. it reported success for anything — including a package that did not exist.
+
+Validation is deliberately read-only and dependency-light (JSON + the filesystem), so it runs in the
+core env against a package produced under the export or ORT-training profile.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from mobiletransformers.exceptions import MobileTransformersError
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("validate", help="Validate a device-ready package.")
+    parser.add_argument("--package", default=None, help="Package directory to validate.")
+    parser.add_argument("--config", default=None, help="Path to config YAML (validates it parses).")
+    parser.add_argument("--dry-run", action="store_true", help="Parse and report without running.")
+    parser.set_defaults(func=run)
+    return parser
+
+
+def validate_package(package_dir: str | Path) -> None:
+    """Fail closed unless ``package_dir`` is a valid #14 package.
+
+    Checks, in order: the directory exists; the manifest is present and parses; the manifest's own
+    invariants hold (#13 ``MobileTransformersManifest.validate``, which resolves every declared file,
+    the selected variant's subtrees and the weight-handoff reference).
+    """
+    from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+    from mobiletransformers.hub.package_format import MANIFEST_FILENAME
+
+    package = Path(package_dir)
+    if not package.is_dir():
+        raise MobileTransformersError(f"not a package directory: {package}")
+
+    manifest_path = package / MANIFEST_FILENAME
+    if not manifest_path.is_file():
+        raise MobileTransformersError(f"no {MANIFEST_FILENAME} in {package}")
+
+    manifest = MobileTransformersManifest.load(manifest_path)
+    manifest.validate(package)
+
+
+def validate_config(config_path: str | Path) -> None:
+    """Fail closed unless ``config_path`` is a readable YAML mapping."""
+    from mobiletransformers.utils.yaml import load_config_from_file
+
+    path = Path(config_path)
+    if not path.is_file():
+        raise MobileTransformersError(f"config not found: {path}")
+    document = load_config_from_file(path)
+    if not isinstance(document, dict):
+        raise MobileTransformersError(f"{path}: expected a YAML mapping at the top level")
+
+
+def run(args: argparse.Namespace) -> int:
+    package = getattr(args, "package", None)
+    config = getattr(args, "config", None)
+    if not package and not config:
+        print("validate: pass --package and/or --config")
+        return 2
+
+    try:
+        if config:
+            validate_config(config)
+            print(f"config OK: {config}")
+        if package:
+            if getattr(args, "dry_run", False):
+                print(f"[dry-run] would validate the package at {package}")
+            else:
+                validate_package(package)
+                print(f"package OK: {package}")
+    except MobileTransformersError as exc:
+        print(f"validation failed: {exc}")
+        return 1
+    return 0
diff --git a/src/mobiletransformers/codegen/__init__.py b/src/mobiletransformers/codegen/__init__.py
new file mode 100644
index 0000000..02d14e6
--- /dev/null
+++ b/src/mobiletransformers/codegen/__init__.py
@@ -0,0 +1 @@
+"""Code generation / parity tooling (dev-only; not part of the runtime public API)."""
diff --git a/src/mobiletransformers/codegen/enums.py b/src/mobiletransformers/codegen/enums.py
new file mode 100644
index 0000000..51bbab8
--- /dev/null
+++ b/src/mobiletransformers/codegen/enums.py
@@ -0,0 +1,143 @@
+"""Parity generator + checker for the cross-language enum/schema contract.
+
+Run ``python -m mobiletransformers.codegen.enums`` to (re)generate the checked-in artifacts:
+  * ``schemas/<Model>.schema.json`` — from ``Model.model_json_schema(by_alias=True)``.
+  * ``schemas/enums.json`` — the golden ``{enumName: [wire values...]}`` from ``config.constants``.
+
+Run ``python -m mobiletransformers.codegen.enums --check`` (the CI parity gate) to fail on drift:
+  * regenerated schemas / enums.json differ from the checked-in ones, or
+  * the hand-written Kotlin ``constants/*.kt`` wire values != the Python enum values.
+
+It parses the Kotlin mirrors (regex over ``NAME("wire")``) but never writes ``.kt`` files — the
+Kotlin enums are the hand-maintained mirror; this only verifies they agree with the Python source.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from mobiletransformers.config.constants import ENUM_REGISTRY
+from mobiletransformers.config.models import CROSS_BOUNDARY_MODELS
+
+
+def find_repo_root(start: Path | None = None) -> Path:
+    """Walk up from this file (or ``start``) until a directory containing ``pyproject.toml``."""
+    here = (start or Path(__file__)).resolve()
+    for parent in [here, *here.parents]:
+        if (parent / "pyproject.toml").is_file():
+            return parent
+    raise FileNotFoundError("could not locate repo root (no pyproject.toml found)")
+
+
+# Kotlin enum mirrors live under the MobileTransformers library module (Android rename #16, done 2026-07-14).
+KOTLIN_CONSTANTS_RELPATH = (
+    "android/MobileTransformers/MobileTransformers/src/main/java/"
+    "com/martinkorelic/mobiletransformers/constants"
+)
+
+_KOTLIN_ENTRY_RE = re.compile(r'\b([A-Z][A-Z0-9_]*)\s*\(\s*"([^"]*)"\s*\)')
+_KOTLIN_CLASS_RE = re.compile(r"enum\s+class\s+([A-Za-z0-9_]+)")
+
+
+def enums_golden() -> dict[str, list[str]]:
+    """The Python source of truth: ``{enumName: [wire values in declaration order]}``."""
+    return {name: [m.value for m in enum] for name, enum in ENUM_REGISTRY.items()}
+
+
+def schema_for(model: type[BaseModel]) -> dict:
+    return model.model_json_schema(by_alias=True)
+
+
+def generate(repo_root: Path) -> None:
+    """Write the checked-in schemas + enums.json from the Python source of truth."""
+    schemas_dir = repo_root / "schemas"
+    schemas_dir.mkdir(exist_ok=True)
+    (schemas_dir / "enums.json").write_text(
+        json.dumps(enums_golden(), indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    for name, model in CROSS_BOUNDARY_MODELS.items():
+        (schemas_dir / f"{name}.schema.json").write_text(
+            json.dumps(schema_for(model), indent=2, sort_keys=True) + "\n", encoding="utf-8"
+        )
+
+
+def parse_kotlin_enums(constants_dir: Path) -> dict[str, set[str]]:
+    """Parse ``NAME("wire")`` entries per enum file. Returns ``{enumName: {wire values}}``."""
+    result: dict[str, set[str]] = {}
+    for kt in sorted(constants_dir.glob("*.kt")):
+        text = kt.read_text(encoding="utf-8")
+        class_match = _KOTLIN_CLASS_RE.search(text)
+        if not class_match:
+            continue
+        enum_name = class_match.group(1)
+        # Only entries within the enum body (before the companion object, if any).
+        body = text.split("companion", 1)[0]
+        wires = {m.group(2) for m in _KOTLIN_ENTRY_RE.finditer(body)}
+        result[enum_name] = wires
+    return result
+
+
+def check(repo_root: Path) -> list[str]:
+    """Return a list of drift messages (empty == parity holds)."""
+    drifts: list[str] = []
+    schemas_dir = repo_root / "schemas"
+
+    # 1) enums.json + schemas must match regeneration byte-for-byte.
+    expected_enums = json.dumps(enums_golden(), indent=2, sort_keys=True) + "\n"
+    enums_file = schemas_dir / "enums.json"
+    if not enums_file.is_file() or enums_file.read_text(encoding="utf-8") != expected_enums:
+        drifts.append("schemas/enums.json is stale (run: python -m mobiletransformers.codegen.enums)")
+    for name, model in CROSS_BOUNDARY_MODELS.items():
+        expected = json.dumps(schema_for(model), indent=2, sort_keys=True) + "\n"
+        path = schemas_dir / f"{name}.schema.json"
+        if not path.is_file() or path.read_text(encoding="utf-8") != expected:
+            drifts.append(f"schemas/{name}.schema.json is stale (regenerate)")
+
+    # 2) Kotlin wire values must equal the Python enum values.
+    constants_dir = repo_root / KOTLIN_CONSTANTS_RELPATH
+    if not constants_dir.is_dir():
+        drifts.append(f"Kotlin constants dir missing: {KOTLIN_CONSTANTS_RELPATH}")
+        return drifts
+    kotlin = parse_kotlin_enums(constants_dir)
+    python_values = {name: {m.value for m in enum} for name, enum in ENUM_REGISTRY.items()}
+    for name, py_wires in python_values.items():
+        kt_wires = kotlin.get(name)
+        if kt_wires is None:
+            drifts.append(f"Kotlin enum missing: {name}.kt")
+        elif kt_wires != py_wires:
+            drifts.append(f"{name} drift — python={sorted(py_wires)} kotlin={sorted(kt_wires)}")
+    for name in kotlin:
+        if name not in python_values:
+            drifts.append(f"Kotlin enum {name} has no Python counterpart")
+    return drifts
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="mobiletransformers.codegen.enums")
+    parser.add_argument("--check", action="store_true", help="Fail on drift instead of regenerating.")
+    args = parser.parse_args(argv)
+    repo_root = find_repo_root()
+
+    if args.check:
+        drifts = check(repo_root)
+        if drifts:
+            print("PARITY DRIFT:", file=sys.stderr)
+            for d in drifts:
+                print(f"  - {d}", file=sys.stderr)
+            return 1
+        print("parity OK: schemas + enums.json + Kotlin mirrors agree with the Python source.")
+        return 0
+
+    generate(repo_root)
+    print(f"regenerated schemas/ + enums.json under {repo_root}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/mobiletransformers/config/__init__.py b/src/mobiletransformers/config/__init__.py
new file mode 100644
index 0000000..977e83c
--- /dev/null
+++ b/src/mobiletransformers/config/__init__.py
@@ -0,0 +1,30 @@
+"""MobileTransformers config package: settings (secrets), constants, and the precedence helper.
+
+Effective value for any tunable resolves in this strict order (highest first):
+
+1. CLI flag              (owned by ``cli/*.py``)
+2. Environment variable  (via ``settings.get_settings()``)
+3. ``config/config.yml`` value (via ``utils.yaml.load_config_from_file``)
+4. Package default       (``constants.py``)
+
+Secrets skip ranks 1/3/4 — they live only at rank 2 (env via ``Settings``). YAML never holds secrets.
+"""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+def resolve(
+    cli_value: _T | None, env_value: _T | None, yaml_value: _T | None, default: _T | None
+) -> _T | None:
+    """Return the first non-``None`` value in CLI > env > YAML > default order."""
+    for value in (cli_value, env_value, yaml_value, default):
+        if value is not None:
+            return value
+    return None
+
+
+__all__ = ["resolve"]
diff --git a/src/mobiletransformers/config/constants.py b/src/mobiletransformers/config/constants.py
new file mode 100644
index 0000000..0249f31
--- /dev/null
+++ b/src/mobiletransformers/config/constants.py
@@ -0,0 +1,163 @@
+"""Non-secret shared constants + the closed-set enum vocabulary.
+
+Migrated from ``tools/parser_config.py`` (config section names + dataset map) plus the non-secret
+experiment constants from the legacy root ``config.py``. The enums below are the single Python source
+of truth for every closed string set; each is mirrored 1:1 by a hand-written Kotlin ``enum class``
+(``android/.../constants/*.kt``), and ``python -m mobiletransformers.codegen.enums --check`` is the CI
+parity gate that fails on drift.
+
+Secrets never live here — they belong in ``mobiletransformers.config.settings``.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+# --- Enum vocabulary (mirrored Python <-> Kotlin; wire values are the on-disk/JSON strings) -------
+class SamplingMethod(str, Enum):
+    GREEDY = "greedy"
+    TOP_K = "top_k"
+    TOP_P = "top_p"
+
+
+class SchedulerType(str, Enum):
+    LINEAR = "linear"
+    COSINE = "cosine"
+
+
+class ExecutionProvider(str, Enum):
+    CPU = "cpu"
+    XNNPACK = "xnnpack"
+    NNAPI = "nnapi"
+
+
+class CoreConfigId(str, Enum):
+    OPT1 = "opt1"
+    OPT2 = "opt2"
+    OPT3 = "opt3"
+
+
+class MemoryConfigId(str, Enum):
+    LOW_MEM = "low_mem"
+    HIGH_PERF = "high_perf"
+
+
+class SearchType(str, Enum):
+    SEMANTIC = "semantic"
+    TEXT = "text"
+
+
+class IndexingMode(str, Enum):
+    """RAG indexing strategy (#27). v1 supports ``precompute`` only; ``dynamic`` is a fail-closed stub."""
+
+    PRECOMPUTE = "precompute"
+    DYNAMIC = "dynamic"
+
+
+class QuantizationType(str, Enum):
+    QINT8 = "QInt8"
+    QUINT8 = "QUInt8"
+    INT4 = "int4"
+
+
+class PEFTMethod(str, Enum):
+    LORA = "lora"
+    LORA_XS = "lora-xs"
+    MARS = "mars"
+    ALL = "all"
+    NOLORA = "nolora"
+
+
+class TaskType(str, Enum):
+    #: Decoder LM. Autoregressive, KV-cached, labels shaped [batch, seq].
+    TEXT_GENERATION = "text-generation"
+    #: Encoder embedding output (the RAG embedder). Inference/export only — it has no head, so it
+    #: cannot produce a training graph; SEQUENCE_CLASSIFICATION is the trainable encoder task.
+    FEATURE_EXTRACTION = "feature-extraction"
+    #: Encoder classification (#33). Single forward pass, no KV cache, labels shaped [batch].
+    SEQUENCE_CLASSIFICATION = "text-classification"
+
+
+class HandoffMode(str, Enum):
+    EXTERNAL_INITIALIZER = "external_initializer"
+    MODEL_INPUT = "model_input"
+    ADAPTER = "adapter"
+
+
+class MergerVariant(str, Enum):
+    # Device-side *resolved* tag (derived from adapter shape + quantization), not a user choice.
+    LORA = "lora"
+    LORA_Q = "lora_q"
+    MARS_Q = "mars_q"
+
+
+class ExportFrontend(str, Enum):
+    """Export front-door engine selected by ``EXPORT_FRONTEND_REGISTRY`` (F3).
+
+    Build-time / Python-only. Android never sees this value, so it is deliberately NOT registered
+    in :data:`ENUM_REGISTRY` (no Kotlin mirror, no cross-language parity obligation). ``optimum-onnx``
+    is the durable inference exporter; ``torch.onnx`` is the manual graph path used by the
+    training-graph fallback (``OnnxConfigWithLoss`` was removed in optimum 2.1 — see
+    ``spikes/optimum_migration``).
+    """
+
+    OPTIMUM_ONNX = "optimum-onnx"
+    TORCH_ONNX = "torch.onnx"
+
+
+#: Every enum that must stay in Python<->Kotlin parity. Consumed by the codegen parity check.
+#: ``ExportFrontend`` is intentionally excluded — it is a Python build-time concern, never a
+#: cross-boundary (on-device) value, so it needs no Kotlin mirror.
+ENUM_REGISTRY: dict[str, type[Enum]] = {
+    "SamplingMethod": SamplingMethod,
+    "SchedulerType": SchedulerType,
+    "ExecutionProvider": ExecutionProvider,
+    "CoreConfigId": CoreConfigId,
+    "MemoryConfigId": MemoryConfigId,
+    "SearchType": SearchType,
+    "IndexingMode": IndexingMode,
+    "QuantizationType": QuantizationType,
+    "PEFTMethod": PEFTMethod,
+    "TaskType": TaskType,
+    "HandoffMode": HandoffMode,
+    "MergerVariant": MergerVariant,
+}
+
+# --- Config section names (from tools/parser_config.py) ---------------------------
+ARTIFACT_CONFIG = "ARTIFACT_BUILDER"
+ARTIFACT_VALIDATOR_CONFIG = "ARTIFACT_VALIDATOR"
+TRAIN_CONFIG = "TRAIN_BUILDER"
+INFERENCE_CONFIG = "INFERENCE_BUILDER"
+INFERENCE_ARTIFACT_CONFIG = "inference_config"
+TEST_GENERATION_CONFIG = "test_generation_config"
+
+# If a value is prefixed with "data", it is loaded from the local "data/" directory.
+TASK_NAME_TO_DATASET = {
+    "logiqa": "data/logiqa_train",
+    "hellaswag": "Rowan/hellaswag",
+    "arc": "allenai/ai2_arc",
+    "boolq": "google/boolq",
+}
+
+# --- Experiment constants (from legacy root config.py; non-secret) -----------------
+TASK_EPOCHS = {
+    "boolq": 2,
+    "logiqa": 3,
+    "arc_e": 4,
+    "winogrande": 4,
+    "arc_c": 4,
+    "hellaswag": 1,
+    "mini_personalqa": 6,
+}
+BATCH_SIZE = 32
+PER_DEVICE_BATCH_SIZE = 6
+GRADIENT_ACCUMULATION = 2
+EXPERIMENT_RANKS = [2, 8, 32]
+
+# --- Canonical artifact filenames -------------------------------------------------
+DEFAULT_TRAIN_MODEL = "quant_model.onnx"
+DEFAULT_INFERENCE_MODEL = "quant_model.onnx"
+
+#: Supported PEFT method wire names, derived from the enum (superseded the legacy tuple).
+SUPPORTED_PEFT_METHODS = tuple(m.value for m in PEFTMethod)
diff --git a/src/mobiletransformers/config/models.py b/src/mobiletransformers/config/models.py
new file mode 100644
index 0000000..c107c55
--- /dev/null
+++ b/src/mobiletransformers/config/models.py
@@ -0,0 +1,135 @@
+"""Typed config models (Pydantic v2) — the single source of truth for cross-boundary JSON.
+
+Alias-driven so the on-disk JSON keeps the camelCase the Kotlin side already reads (no on-device
+migration). Export writes ``Model.model_dump(by_alias=True, mode="json")``; ``schemas/*.schema.json``
+is generated from ``Model.model_json_schema(by_alias=True)`` and checked in as a **CI parity artifact
+only** — the device does typed fail-closed parsing (Gson + enum ``fromWire`` + ``check_compat``), not
+runtime JSON-Schema validation.
+
+``extra="ignore"`` (not ``forbid``): the schema-versioning contract requires readers to tolerate
+unknown fields so additive minor bumps are non-breaking. Unknown *enum values* still fail closed
+(enum coercion raises).
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from mobiletransformers.config.constants import (
+    CoreConfigId,
+    ExecutionProvider,
+    MemoryConfigId,
+    PEFTMethod,
+    QuantizationType,
+    SamplingMethod,
+    SchedulerType,
+    SearchType,
+)
+
+#: Cross-boundary schema version (MAJOR.MINOR) + minimum reader version. Mirrors the manifest (#13)
+#: and handoff-map (#8) contract: readers fail closed on an unsupported major, tolerate minor bumps.
+SCHEMA_VERSION = "1.0"
+MIN_READER_VERSION = "1.0"
+
+
+class _Base(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="ignore", use_enum_values=True)
+
+
+class _CrossBoundary(_Base):
+    """Base for models written to disk and read by Kotlin/C++ — carries the version block."""
+
+    schema_version: str = Field(SCHEMA_VERSION, alias="schemaVersion")
+    min_reader_version: str = Field(MIN_READER_VERSION, alias="minReaderVersion")
+
+
+# --- nested value objects ---------------------------------------------------------
+class SamplingConfig(_Base):
+    method: SamplingMethod = SamplingMethod.GREEDY
+    temperature: float = 1.0
+    top_k: int = Field(10, alias="topK")
+    top_p: float = Field(0.9, alias="topP")
+    seed: int = 42
+
+
+class DeviceOptions(_Base):
+    enable_profiling: bool = Field(False, alias="enableProfiling")
+    core_config_id: CoreConfigId = Field(CoreConfigId.OPT1, alias="coreConfigId")
+    memory_config_id: MemoryConfigId = Field(MemoryConfigId.HIGH_PERF, alias="memoryConfigId")
+    execution_provider: ExecutionProvider = Field(ExecutionProvider.CPU, alias="executionProvider")
+
+
+class LinearScheduler(_Base):
+    scheduler_type: Literal[SchedulerType.LINEAR] = Field(SchedulerType.LINEAR, alias="schedulerType")
+    learning_rate: float = Field(1e-4, alias="learningRate")
+    start_factor: float = Field(1.0, alias="startFactor")
+    end_factor: float = Field(0.333, alias="endFactor")
+
+
+class CosineScheduler(_Base):
+    scheduler_type: Literal[SchedulerType.COSINE] = Field(SchedulerType.COSINE, alias="schedulerType")
+    learning_rate: float = Field(1e-4, alias="learningRate")
+    min_learning_rate: float = Field(0.0, alias="minLearningRate")
+    warmup_steps: int = Field(10, alias="warmupSteps")
+
+
+#: Discriminated union — the on-disk ``schedulerType`` selects Linear vs Cosine.
+SchedulerConfig = Annotated[LinearScheduler | CosineScheduler, Field(discriminator="scheduler_type")]
+
+
+class QuantizationOptions(_Base):
+    """Lifts the ad-hoc quantization ``extra_options`` dict (trainer/builder.py) into typed config."""
+
+    weight_type: QuantizationType = Field(QuantizationType.QINT8, alias="weightType")
+    activation_symmetric: bool = Field(False, alias="activationSymmetric")
+    weight_symmetric: bool = Field(False, alias="weightSymmetric")
+    enable_subgraph: bool = Field(False, alias="enableSubgraph")
+    force_quantize_no_input_check: bool = Field(True, alias="forceQuantizeNoInputCheck")
+    matmul_const_b_only: bool = Field(True, alias="matMulConstBOnly")
+
+
+# --- cross-boundary top-level models ----------------------------------------------
+class GenerationConfig(_CrossBoundary):
+    max_sequence_length: int = Field(128, alias="maxSequenceLength")
+    sampling: SamplingConfig = Field(default_factory=SamplingConfig)
+    device_options: DeviceOptions = Field(default_factory=DeviceOptions, alias="deviceOptions")
+
+
+class TrainingConfig(_CrossBoundary):
+    peft_method: PEFTMethod = Field(PEFTMethod.LORA, alias="peftMethod")
+    rank: int = 8
+    alpha: int = 16
+    max_steps: int = Field(10, alias="maxSteps")
+    scheduler: SchedulerConfig = Field(default_factory=lambda: LinearScheduler())
+    quantization: QuantizationOptions = Field(default_factory=QuantizationOptions)
+
+
+class RagConfig(_CrossBoundary):
+    search_type: SearchType = Field(SearchType.SEMANTIC, alias="searchType")
+    top_k: int = Field(5, alias="topK")
+    embedding_dim: int = Field(384, alias="embeddingDim")
+
+
+#: Every model that produces a checked-in cross-boundary schema. Consumed by the codegen module.
+CROSS_BOUNDARY_MODELS: dict[str, type[BaseModel]] = {
+    "GenerationConfig": GenerationConfig,
+    "TrainingConfig": TrainingConfig,
+    "RagConfig": RagConfig,
+}
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "MIN_READER_VERSION",
+    "SamplingConfig",
+    "DeviceOptions",
+    "LinearScheduler",
+    "CosineScheduler",
+    "SchedulerConfig",
+    "QuantizationOptions",
+    "GenerationConfig",
+    "TrainingConfig",
+    "RagConfig",
+    "CROSS_BOUNDARY_MODELS",
+]
diff --git a/src/mobiletransformers/config/registry/__init__.py b/src/mobiletransformers/config/registry/__init__.py
new file mode 100644
index 0000000..e3c48c5
--- /dev/null
+++ b/src/mobiletransformers/config/registry/__init__.py
@@ -0,0 +1,47 @@
+"""Data-driven registries: the single source of truth for every closed dispatch choice.
+
+A closed set of choices is **data** (an enum member + a registry row), never an ``if/elif`` chain in
+business logic. Adding a PEFT method, architecture, or merger variant is a registry entry, not a new
+branch. Extended with more registries (task, execution-provider,
+document-loader, export-frontend) as their consumers land.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.config.registry.architecture import (
+    ARCHITECTURE_REGISTRY,
+    ArchitectureSpec,
+    resolve_architecture,
+)
+from mobiletransformers.config.registry.merger import (
+    MergerSpec,
+    build_merger_model,
+    resolve_merger,
+)
+from mobiletransformers.config.registry.peft import (
+    PEFT_REGISTRY,
+    AdapterComponent,
+    PEFTMethodSpec,
+    get_peft_spec,
+)
+from mobiletransformers.config.registry.task import (
+    TASK_REGISTRY,
+    TaskSpec,
+    get_task_spec,
+)
+
+__all__ = [
+    "ARCHITECTURE_REGISTRY",
+    "ArchitectureSpec",
+    "resolve_architecture",
+    "PEFT_REGISTRY",
+    "PEFTMethodSpec",
+    "AdapterComponent",
+    "get_peft_spec",
+    "MergerSpec",
+    "resolve_merger",
+    "build_merger_model",
+    "TASK_REGISTRY",
+    "TaskSpec",
+    "get_task_spec",
+]
diff --git a/src/mobiletransformers/config/registry/architecture.py b/src/mobiletransformers/config/registry/architecture.py
new file mode 100644
index 0000000..b0f12dc
--- /dev/null
+++ b/src/mobiletransformers/config/registry/architecture.py
@@ -0,0 +1,415 @@
+"""Architecture registry — single source of truth for per-architecture export/inference dispatch.
+
+Replaces the parallel architectures-keyed if/elif chains in ``trainer/builder.py`` (training export,
+Optimum ``*OnnxConfig``) and ``inference/builder.py`` (inference graph ``*Model`` builders).
+Adding an architecture is a registry row — no new ``elif``.
+
+Class bindings are **lazy dotted-path strings** (resolved via ``import_from_path`` only when an export
+actually runs) so this registry imports cleanly in the core env without pulling optimum/torch.
+
+The registry now covers **every** branch of ``inference/builder.py``'s 14-branch architecture ladder,
+including the three that did more than pick a class — those side effects are data on the row
+(``option_overrides`` / ``extra_option_overrides`` / ``config_overrides`` / ``warnings``) rather than
+statements in a chain. Adding an architecture is a registry row; no new ``elif``.
+
+**The dispatch site now consumes this** (S6): ``inference/builder.py``'s ladder is gone, the module
+moved into the package, and all 15 branches were verified to resolve to the same class objects the
+chain constructed. ``tests/unit/test_guards.py``'s ``DISPATCH_ALLOWLIST`` is empty as a result.
+"""
+
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass, field
+from typing import Any
+
+from mobiletransformers.config.constants import TaskType
+from mobiletransformers.exceptions import UnsupportedModelError
+
+
+def import_from_path(dotted: str) -> Any:
+    """Import ``pkg.mod.Name`` lazily and return the attribute (raises at call time, not load time)."""
+    module_path, _, attr = dotted.rpartition(".")
+    return getattr(importlib.import_module(module_path), attr)
+
+
+#: The attention module name the decoder family uses. Declared here because this registry OWNS
+#: per-architecture naming: a consumer that needs a fallback must reference this rather than spell
+#: ``"self_attn"`` itself, or the literal spreads back out into the consumers #33 just cleaned.
+DEFAULT_ATTENTION_MODULE_NAME = "self_attn"
+
+#: Attention/MLP projection module names keyed by the PEFT projection ROLE.
+#:
+#: The roles (``q``/``k``/``v``/``o``/``gate``/``up``/``down``) are the vocabulary MARS's
+#: ``SharedAttentionAdapter``/``SharedMLPAdapter`` and ``MarsLayer.projection_type`` already speak;
+#: the *module names* are what differs per architecture. This default is the Llama-family naming that
+#: ``peft/mars/model.py`` used to hardcode in five places (attention-module lookup, three
+#: ``register_proj_hook`` calls, the ``projection_type`` ladder, and the ``qkv``/``mlp`` grouping in
+#: ``_replace_module``). Encoder rows override it — which is the whole reason MARS could not be
+#: transferred to an encoder (#33).
+DEFAULT_PROJECTION_NAMES: dict[str, str] = {
+    "q": "q_proj",
+    "k": "k_proj",
+    "v": "v_proj",
+    "o": "o_proj",
+    "gate": "gate_proj",
+    "up": "up_proj",
+    "down": "down_proj",
+}
+
+#: BERT/RoBERTa name their attention projections ``query``/``key``/``value``, nested one level deeper
+#: than a decoder's (``attention.self.query`` vs ``self_attn.q_proj``). Only q/k/v are mapped: BERT's
+#: output projection lives in a different subtree (``attention.output.dense``) and its MLP is
+#: ``intermediate``/``output``, neither of which MARS's shared-adapter shapes describe — declaring a
+#: name for them would claim a transfer that has not been verified.
+_BERT_PROJECTION_NAMES: dict[str, str] = {"q": "query", "k": "key", "v": "value"}
+
+#: DistilBERT names them ``q_lin``/``k_lin``/``v_lin`` — exactly the per-architecture difference this
+#: registry exists to hold as data.
+_DISTILBERT_PROJECTION_NAMES: dict[str, str] = {"q": "q_lin", "k": "k_lin", "v": "v_lin"}
+
+
+@dataclass(frozen=True)
+class ArchitectureSpec:
+    architecture: str  # config.architectures[0], e.g. "LlamaForCausalLM"
+    # Dotted path to the Optimum OnnxConfig (training export). None for inference-only architectures:
+    # PhiMoE, Phi3Small, Phi3V and ChatGLM have a genai inference builder but NO Optimum config exists
+    # for them, so they can be exported for inference and never trained through the Optimum path.
+    # Verified against optimum-onnx's model_configs, not assumed.
+    onnx_config_class: str | None
+    # Export-path target modules, keyed (like this whole registry) by config.architectures[0].
+    # NOT the same table as PEFT_TARGET_MODULES_BY_MODEL_TYPE in registry/peft.py, which is keyed by
+    # config.model_type and covers the far wider set of PEFT-wrappable models (incl. encoders/seq2seq).
+    target_modules: tuple[str, ...]
+    inference_model_class: str | None = None  # dotted path to the genai inference builder; None = n/a
+    attention_module_name: str = DEFAULT_ATTENTION_MODULE_NAME
+    #: Projection ROLE -> module name (see :data:`DEFAULT_PROJECTION_NAMES`). Consumed by
+    #: ``peft/mars/model.py`` to locate the shared-adapter anchor and to classify a wrapped module,
+    #: replacing the decoder-only ``q_proj``/``gate_proj`` string tests it used to hardcode.
+    projection_names: dict[str, str] = field(default_factory=lambda: dict(DEFAULT_PROJECTION_NAMES))
+    task: TaskType = TaskType.TEXT_GENERATION
+
+    #: Dotted path to the training-graph wrapper, overriding the one the TASK declares. ``None`` = use
+    #: the task's default.
+    #:
+    #: The task owns the *objective* (what is supervised, and therefore the label contract), which is
+    #: why ``TaskSpec.trainer_wrapper_class`` is the right default. But the exported **input set** is
+    #: decided by this row's ``onnx_config_class``, and two architectures with the same objective can
+    #: disagree about it: ``LlamaOnnxConfig`` declares ``position_ids`` and ``Gemma3TextOnnxConfig``
+    #: does not. Optimum feeds the dummy inputs positionally, so a wrapper with one parameter too many
+    #: silently shifts every argument. The override lives here because the OnnxConfig that causes the
+    #: difference lives here.
+    #:
+    #: ``export/training_export.py`` cross-checks the chosen wrapper's signature against the resolved
+    #: config's inputs, so a wrong value here fails closed with both lists named rather than as a
+    #: ``TypeError`` inside ``torch.jit``.
+    trainer_wrapper_class: str | None = None
+    # Variant selection (e.g. Phi3 4K vs 128K keyed on config.max_position_embeddings).
+    variant_key: str | None = None
+    variant_values: dict[int, str] = field(default_factory=dict)  # {variant_value: inference dotted path}
+
+    # --- Side effects the legacy ladder performed inline (the one design gap in #6's registry plan) ---
+    #
+    # Three of `inference/builder.py`'s 14 branches did more than pick a class: they mutated the export
+    # request or the HF config before constructing it. A registry row that only names a class cannot
+    # replace those branches, so the mutations become data too.
+
+    #: Export-option forcings, e.g. `{"execution_provider": "cuda", "precision": "int4"}` for PhiMoE,
+    #: whose `MoE` op ORT implements for CUDA only. Applied over the caller's request.
+    option_overrides: dict[str, Any] = field(default_factory=dict)
+
+    #: `extra_options` forcings, e.g. `{"exclude_embeds": True}` for Phi3V (text component only).
+    extra_option_overrides: dict[str, Any] = field(default_factory=dict)
+
+    #: HF-config attribute forcings applied before the builder reads them, e.g. ChatGLM's
+    #: `hidden_act = "swiglu"` (its config declares an activation the builder does not map).
+    config_overrides: dict[str, Any] = field(default_factory=dict)
+
+    #: Operator-facing warnings the legacy branches `print`ed. Kept as data so a caller can log them
+    #: through the normal logger rather than to stdout.
+    warnings: tuple[str, ...] = ()
+
+    def module_name_for_role(self, role: str) -> str | None:
+        """``"q"`` -> ``"q_proj"`` (decoder) / ``"query"`` (BERT). ``None`` when the role is not mapped."""
+        return self.projection_names.get(role)
+
+    def role_for_module(self, module_name: str) -> str | None:
+        """Inverse of :meth:`module_name_for_role`: ``"query"`` -> ``"q"``.
+
+        Matches the **leaf** module name exactly. The code this replaces used substring tests
+        (``"q_proj" in target_name``), which silently matched nothing at all on an encoder — leaving
+        ``projection_type=None``, which in turn left ``is_standalone=True`` and degraded MARS to
+        unshared adapters without any error. Exact leaf matching makes that a lookup miss the caller
+        can see rather than a silent downgrade.
+        """
+        leaf = module_name.rsplit(".", 1)[-1]
+        for role, name in self.projection_names.items():
+            if name == leaf:
+                return role
+        return None
+
+    def load_onnx_config_class(self) -> Any:
+        if self.onnx_config_class is None:
+            raise UnsupportedModelError(
+                f"{self.architecture} has no Optimum OnnxConfig — it is inference-only and cannot be "
+                "exported for training through the Optimum path."
+            )
+        return import_from_path(self.onnx_config_class)
+
+    def load_inference_model_class(self, variant_value: int | None = None) -> Any:
+        if self.variant_key is not None and variant_value is not None:
+            path = self.variant_values.get(variant_value)
+            if path is None:
+                raise UnsupportedModelError(
+                    f"{self.architecture} has no inference variant for {self.variant_key}={variant_value}"
+                )
+            return import_from_path(path)
+        if self.inference_model_class is None:
+            raise UnsupportedModelError(f"{self.architecture} has no inference builder yet")
+        return import_from_path(self.inference_model_class)
+
+
+_OC = "optimum.exporters.onnx.model_configs"
+_INF = "mobiletransformers.inference.builder"  # S6: in the package — the wheel is self-contained
+
+ARCHITECTURE_REGISTRY: dict[str, ArchitectureSpec] = {
+    "LlamaForCausalLM": ArchitectureSpec(
+        "LlamaForCausalLM", f"{_OC}.LlamaOnnxConfig", ("q_proj", "v_proj"), f"{_INF}.LlamaModel"
+    ),
+    # The whole Gemma line, and Nemotron, omit `position_ids` from their OnnxConfig — this is not a
+    # Gemma-3 peculiarity as it first appeared. Measured 2026-08-17 by
+    # `test_trainer_wrapper_signature_matches_the_configs_input_set`, which checks every row rather
+    # than the one architecture someone happened to export.
+    "GemmaForCausalLM": ArchitectureSpec(
+        "GemmaForCausalLM",
+        f"{_OC}.GemmaOnnxConfig",
+        ("q_proj", "v_proj"),
+        f"{_INF}.GemmaModel",
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxDecoderNoPositionIdsTrainerWrapper"
+        ),
+    ),
+    # Gemma2/Gemma3 bind their OWN Optimum configs. Both rows previously pointed at `GemmaOnnxConfig`,
+    # which is a different architecture — Gemma2 adds alternating sliding-window attention and logit
+    # soft-capping, Gemma3 differs again — so the generic config would have described the wrong graph
+    # (KV-cache layout and attention in particular). Verified present in the pinned optimum-onnx 0.1.0.
+    # NOT exercised end to end here: no profile in this checkout has optimum installed, and the dotted
+    # paths resolve lazily, so this is a correctness fix that the export profile still has to confirm.
+    "Gemma2ForCausalLM": ArchitectureSpec(
+        "Gemma2ForCausalLM",
+        f"{_OC}.Gemma2OnnxConfig",
+        ("q_proj", "v_proj"),
+        f"{_INF}.Gemma2Model",
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxDecoderNoPositionIdsTrainerWrapper"
+        ),
+    ),
+    # `Gemma3TextOnnxConfig`, NOT `Gemma3OnnxConfig`. Gemma-3 ships as two model types and optimum
+    # maps them to two different configs: `gemma3` (multimodal, class
+    # `Gemma3ForConditionalGeneration`) -> `Gemma3OnnxConfig`, whose `__init__` does
+    # `super().__init__(config.text_config, ...)`; and `gemma3_text` (text-only, class
+    # `Gemma3ForCausalLM` — what `google/gemma-3-270m` actually is) -> `Gemma3TextOnnxConfig`.
+    #
+    # This row bound the multimodal config, so the training export would have died with
+    # `AttributeError: 'Gemma3TextConfig' object has no attribute 'text_config'`. It was invisible
+    # because the dotted paths resolve lazily and nothing had ever exercised the row — precisely the
+    # caveat recorded beside it. `test_registry_matches_optimum_task_manager` now cross-checks every
+    # row against optimum's own mapping so a wrong binding cannot hide again.
+    #
+    # The multimodal `Gemma3ForConditionalGeneration` is deliberately NOT added: it is untested here,
+    # and failing closed on an unknown architecture is better than a second unexercised binding.
+    #
+    # `inference_model_class` stays None: that field is the vendored GenAI builder path, and the
+    # shipping inference export goes through optimum's `main_export` (#7), which resolves its own
+    # config via TasksManager. Gemma-3 inference export is PROVEN (2026-08-09, full package).
+    #
+    # `trainer_wrapper_class`: Gemma-3 is the first architecture whose OnnxConfig declares a DIFFERENT
+    # input set from the other decoders. `LlamaOnnxConfig.inputs` is
+    # `[input_ids, attention_mask, position_ids]`; `Gemma3TextOnnxConfig.inputs` is
+    # `[input_ids, attention_mask]` — no `position_ids`. Optimum passes dummy inputs to the traced
+    # module positionally, so the standard four-parameter decoder wrapper received `labels` in the
+    # `position_ids` slot and died inside `torch.jit` with "missing 1 required positional argument:
+    # 'labels'". This row picks the three-parameter wrapper instead. Measured 2026-08-15.
+    "Gemma3ForCausalLM": ArchitectureSpec(
+        "Gemma3ForCausalLM",
+        f"{_OC}.Gemma3TextOnnxConfig",
+        ("q_proj", "v_proj"),
+        None,
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxDecoderNoPositionIdsTrainerWrapper"
+        ),
+    ),
+    "Phi3ForCausalLM": ArchitectureSpec(
+        "Phi3ForCausalLM",
+        f"{_OC}.Phi3OnnxConfig",
+        ("qkv_proj", "o_proj"),
+        variant_key="max_position_embeddings",
+        variant_values={4096: f"{_INF}.Phi3Mini4KModel", 131072: f"{_INF}.Phi3Mini128KModel"},
+    ),
+    "Qwen2ForCausalLM": ArchitectureSpec(
+        "Qwen2ForCausalLM", f"{_OC}.Qwen2OnnxConfig", ("q_proj", "v_proj"), f"{_INF}.QwenModel"
+    ),
+    # --- The #6 remainder: the last 7 rows of `inference/builder.py`'s 14-branch ladder -------------
+    "MistralForCausalLM": ArchitectureSpec(
+        "MistralForCausalLM", f"{_OC}.MistralOnnxConfig", ("q_proj", "v_proj"), f"{_INF}.MistralModel"
+    ),
+    "PhiForCausalLM": ArchitectureSpec(
+        "PhiForCausalLM", f"{_OC}.PhiOnnxConfig", ("q_proj", "v_proj"), f"{_INF}.PhiModel"
+    ),
+    # MoE is CUDA-only in ORT and this builder only emits a quantized graph, so the legacy branch
+    # OVERRODE whatever the caller asked for. Encoded as data rather than lost.
+    "PhiMoEForCausalLM": ArchitectureSpec(
+        "PhiMoEForCausalLM",
+        None,
+        ("q_proj", "v_proj"),
+        variant_key="max_position_embeddings",
+        variant_values={131072: f"{_INF}.Phi3MoE128KModel"},
+        option_overrides={"execution_provider": "cuda", "precision": "int4"},
+        warnings=(
+            "PhiMoE runs on CUDA only (ORT implements `MoE` for CUDA); forcing execution_provider=cuda.",
+            "PhiMoE is supported in quantized form only; forcing precision=int4.",
+        ),
+    ),
+    "Phi3SmallForCausalLM": ArchitectureSpec(
+        "Phi3SmallForCausalLM",
+        None,
+        ("query_key_value", "dense"),
+        variant_key="max_position_embeddings",
+        variant_values={8192: f"{_INF}.Phi3Small8KModel", 131072: f"{_INF}.Phi3Small128KModel"},
+    ),
+    "Phi3VForCausalLM": ArchitectureSpec(
+        "Phi3VForCausalLM",
+        None,
+        ("qkv_proj", "o_proj"),
+        f"{_INF}.Phi3VModel",
+        extra_option_overrides={"exclude_embeds": True},
+        warnings=("Phi3V export covers the TEXT component only; forcing exclude_embeds=true.",),
+    ),
+    "NemotronForCausalLM": ArchitectureSpec(
+        "NemotronForCausalLM",
+        f"{_OC}.NemotronOnnxConfig",
+        ("q_proj", "v_proj"),
+        f"{_INF}.NemotronModel",
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxDecoderNoPositionIdsTrainerWrapper"
+        ),
+    ),
+    # Two architecture strings for one model: a quantized ChatGLM declares
+    # `ChatGLMForConditionalGeneration`, the HF model declares `ChatGLMModel`. Both rows point at the
+    # same builder — the legacy branch `or`-ed them, and a registry keyed by architectures[0] needs both.
+    "ChatGLMForConditionalGeneration": ArchitectureSpec(
+        "ChatGLMForConditionalGeneration",
+        None,
+        ("query_key_value", "dense"),
+        f"{_INF}.ChatGLMModel",
+        config_overrides={"hidden_act": "swiglu"},
+    ),
+    "ChatGLMModel": ArchitectureSpec(
+        "ChatGLMModel",
+        None,
+        ("query_key_value", "dense"),
+        f"{_INF}.ChatGLMModel",
+        config_overrides={"hidden_act": "swiglu"},
+    ),
+    "OPTForCausalLM": ArchitectureSpec(
+        "OPTForCausalLM",
+        f"{_OC}.OPTOnnxConfig",
+        ("q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"),
+    ),
+    "BertModel": ArchitectureSpec(
+        "BertModel",
+        f"{_OC}.BertOnnxConfig",
+        ("query", "value"),
+        attention_module_name="attention",
+        projection_names=dict(_BERT_PROJECTION_NAMES),
+        task=TaskType.FEATURE_EXTRACTION,
+    ),
+    # --- Encoder classification (#33) ---
+    #
+    # Separate rows from `BertModel` because the architecture key IS the head: a checkpoint loaded as
+    # `AutoModelForSequenceClassification` reports `BertForSequenceClassification`, and it is the head
+    # that decides the task, the label shape and the loss. `BertModel` stays feature-extraction (the
+    # RAG embedder), and neither row has to know about the other.
+    #
+    # Targets are the BERT attention projection names (`query`/`value`), the encoder equivalent of the
+    # decoders' `q_proj`/`v_proj` — the LoRA convention of adapting Wq and Wv.
+    "BertForSequenceClassification": ArchitectureSpec(
+        "BertForSequenceClassification",
+        f"{_OC}.BertOnnxConfig",
+        ("query", "value"),
+        attention_module_name="attention",
+        projection_names=dict(_BERT_PROJECTION_NAMES),
+        task=TaskType.SEQUENCE_CLASSIFICATION,
+    ),
+    "RobertaForSequenceClassification": ArchitectureSpec(
+        "RobertaForSequenceClassification",
+        f"{_OC}.RobertaOnnxConfig",
+        ("query", "value"),
+        attention_module_name="attention",
+        projection_names=dict(_BERT_PROJECTION_NAMES),
+        task=TaskType.SEQUENCE_CLASSIFICATION,
+        # RoBERTa has no `token_type_ids` in its exported input set. The *model* accepts the argument
+        # — it is what makes it a drop-in for BERT — but it carries a single segment and RoBERTa was
+        # pretrained without the next-sentence objective, so `RobertaOnnxConfig` does not declare it
+        # while `BertOnnxConfig` does. Only `BertForSequenceClassification` keeps the task's default
+        # four-parameter wrapper. Measured 2026-08-17.
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxSequenceClassificationNoTokenTypeIdsTrainerWrapper"
+        ),
+    ),
+    "DistilBertForSequenceClassification": ArchitectureSpec(
+        "DistilBertForSequenceClassification",
+        f"{_OC}.DistilBertOnnxConfig",
+        # DistilBERT names its projections q_lin/v_lin, not query/value — exactly the per-architecture
+        # difference this registry exists to hold as data.
+        ("q_lin", "v_lin"),
+        attention_module_name="attention",
+        projection_names=dict(_DISTILBERT_PROJECTION_NAMES),
+        task=TaskType.SEQUENCE_CLASSIFICATION,
+        # `trainer_wrapper_class`: the encoder form of the Gemma-3 disagreement above. DistilBERT
+        # dropped BERT's next-sentence-prediction objective and with it the segment embedding, so
+        # `DistilBertOnnxConfig.inputs` is [input_ids, attention_mask] where BERT's and RoBERTa's
+        # carry `token_type_ids` too. The task's default wrapper declares four parameters, Optimum
+        # binds positionally, and `labels` would land in the `token_type_ids` slot. Caught by the
+        # signature/inputs cross-check rather than by `torch.jit`. Measured 2026-08-17.
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxSequenceClassificationNoTokenTypeIdsTrainerWrapper"
+        ),
+    ),
+}
+
+
+def resolve_architecture(config: Any, *, architecture: str | None = None) -> ArchitectureSpec:
+    """Look up the spec for a HF config's first architecture. Fail closed on unknown.
+
+    ``architecture`` overrides the lookup key and should be ``type(model).__name__`` whenever the
+    model has actually been loaded. **The head is part of the architecture identity**, and
+    ``config.architectures`` describes the *checkpoint*, not what was loaded from it: a
+    sentence-transformers encoder declares ``["BertModel"]`` even when loaded through
+    ``AutoModelForSequenceClassification`` as a ``BertForSequenceClassification``. Keying off the
+    config alone therefore resolves an encoder fine-tune to the un-headed, untrainable row.
+
+    For every already-supported path the two agree (`AutoModelForCausalLM` on a Llama checkpoint gives
+    `LlamaForCausalLM`, which is also `architectures[0]`), so passing the loaded class is strictly more
+    accurate rather than a behaviour change.
+    """
+    name = architecture
+    if not name:
+        architectures = getattr(config, "architectures", None) or []
+        if not architectures:
+            raise UnsupportedModelError("model config has no `architectures`")
+        name = architectures[0]
+    spec = ARCHITECTURE_REGISTRY.get(name)
+    if spec is None:
+        raise UnsupportedModelError(f"unsupported architecture: {name}")
+    return spec
+
+
+__all__ = [
+    "ArchitectureSpec",
+    "ARCHITECTURE_REGISTRY",
+    "DEFAULT_ATTENTION_MODULE_NAME",
+    "DEFAULT_PROJECTION_NAMES",
+    "resolve_architecture",
+    "import_from_path",
+]
diff --git a/src/mobiletransformers/config/registry/merger.py b/src/mobiletransformers/config/registry/merger.py
new file mode 100644
index 0000000..9855a1d
--- /dev/null
+++ b/src/mobiletransformers/config/registry/merger.py
@@ -0,0 +1,402 @@
+"""Merger registry — resolves the device-side merger variant + descriptive ONNX filename from data.
+
+Replaces the peft_method-keyed if/elif merger dispatch (``artifact/onnx_builder.py``) and the four
+near-duplicate ``create_*_merger_model{,_2}`` factories (``artifact/merger.py``). The
+resolved ``MergerVariant`` + filename go into the ``weight_handoff_map.json`` so the C++ side selects
+the merger session from data, not string literals.
+
+Scope note: ``resolve_merger`` / ``MergerSpec`` (the registry contract) are owned and implemented here.
+The single ``build_merger_model`` ONNX-graph builder that collapses the four legacy factories — and the
+C++ ``get_merger_type``/``run_merger_model`` rewrite — are *wired* by #9
+which owns the on-disk merge filename contract and the golden-equivalence test.
+Until then ``build_merger_model`` fails closed rather than silently emitting a wrong graph.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from mobiletransformers._typing import PathLike
+from mobiletransformers.config.constants import MergerVariant, PEFTMethod
+from mobiletransformers.config.registry.peft import get_peft_spec
+from mobiletransformers.exceptions import MergeError, UnsupportedModelError
+from mobiletransformers.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    import onnx
+
+logger = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class MergerSpec:
+    peft_method: PEFTMethod
+    quant_in: bool
+    quant_out: bool
+    variant: MergerVariant  # resolved device-side tag ("lora"/"lora_q"/"mars_q")
+    output_filename: str  # descriptive, e.g. "merger_mars_q_qin_qout.onnx" — NO "_2" suffixes
+
+
+def resolve_merger(peft_method: PEFTMethod, quant_in: bool, quant_out: bool) -> MergerSpec:
+    """Resolve the merger variant + descriptive filename for a (method, quant_in, quant_out) tuple.
+
+    The ``_q`` variants correspond to quantized inputs (mirrors the legacy ``*_qmerger`` naming).
+    Fails closed for methods that produce no merger (``all`` / ``nolora``).
+    """
+    spec = get_peft_spec(peft_method)
+    variant = spec.merger_variant_q if quant_in else spec.merger_variant_fp
+    if variant is None:
+        raise UnsupportedModelError(f"PEFT method {peft_method.value} has no merger variant")
+    in_tag = "qin" if quant_in else "fpin"
+    out_tag = "qout" if quant_out else "fpout"
+    output_filename = f"merger_{variant.value}_{in_tag}_{out_tag}.onnx"
+    return MergerSpec(peft_method, quant_in, quant_out, variant, output_filename)
+
+
+def build_merger_model(spec: MergerSpec, output_path: PathLike) -> None:
+    """Build the merger ONNX graph for ``spec`` at ``output_path``.
+
+    The single parameterized builder that collapses the four legacy factories
+    (``create_lora_merger_model{,_2}`` / ``create_mars_merger_model{,_2}`` in ``artifact/merger.py``).
+    Two axes fully determine the graph, both carried on the :class:`MergerSpec`:
+
+    * **family** — ``variant`` root: ``lora``/``lora_q`` → LoRA math; ``mars_q`` → MARS math.
+    * **quantization** — ``quant_in`` / ``quant_out``, honored *independently* (the ``_2``-factory
+      superset). Do NOT re-derive quantization from ``variant``: ``resolve_merger`` keys the ``_q``
+      variant tag on ``quant_in`` only, while the graph's input *and* output quantization are the two
+      spec flags. A float-input variant (``lora``) with ``quant_out=True`` is a valid graph.
+
+    The emitted node topology, IO names, dtypes, opset (11), producer metadata and ``metadata_props``
+    reproduce the legacy ``*_2`` factories so the graph is byte-comparable (golden-equivalence test).
+    """
+    import onnx
+
+    if spec.variant in (MergerVariant.LORA, MergerVariant.LORA_Q):
+        model = _build_lora_merger(spec.quant_in, spec.quant_out)
+    elif spec.variant is MergerVariant.MARS_Q:
+        model = _build_mars_merger(spec.quant_in, spec.quant_out)
+    else:  # pragma: no cover - MergerVariant is a closed enum; guards a future member.
+        raise MergeError(f"no merger graph builder for variant {spec.variant.value!r}")
+
+    onnx.checker.check_model(model)
+    onnx.save(model, str(output_path))
+    logger.info(
+        "built merger model variant=%s quant_in=%s quant_out=%s -> %s",
+        spec.variant.value,
+        spec.quant_in,
+        spec.quant_out,
+        output_path,
+    )
+
+
+def _append_quant_metadata(model: onnx.ModelProto, quant_in: bool, quant_out: bool) -> None:
+    """Append the four ``metadata_props`` the legacy factories emit (byte-comparable)."""
+    entries = (
+        ("quantized_inputs", str(quant_in).lower()),
+        ("quantized_outputs", str(quant_out).lower()),
+        ("input_type", "quantized" if quant_in else "float"),
+        ("output_type", "quantized" if quant_out else "float"),
+    )
+    for key, value in entries:
+        entry = model.metadata_props.add()
+        entry.key = key
+        entry.value = value
+
+
+def _build_lora_merger(quant_in: bool, quant_out: bool) -> onnx.ModelProto:
+    """LoRA merger graph: ``merged = base + alpha * (adapter_B @ adapter_A)``.
+
+    Reproduces ``artifact/merger.py::create_lora_merger_model_2``.
+    """
+    from onnx import TensorProto, helper
+
+    inputs = []
+    outputs = []
+    nodes = []
+
+    if quant_in:
+        inputs.append(
+            helper.make_tensor_value_info(
+                "weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]
+            )
+        )
+        inputs.append(helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []))
+        inputs.append(helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []))
+    else:
+        inputs.append(
+            helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"])
+        )
+
+    inputs.append(helper.make_tensor_value_info("adapter_A", TensorProto.FLOAT, ["rank", "in_features"]))
+    inputs.append(helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]))
+    inputs.append(helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []))
+
+    if quant_out:
+        outputs.append(
+            helper.make_tensor_value_info(
+                "merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]
+            )
+        )
+        outputs.append(helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, []))
+        outputs.append(helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []))
+    else:
+        outputs.append(
+            helper.make_tensor_value_info("merged_weight", TensorProto.FLOAT, ["out_features", "in_features"])
+        )
+
+    if quant_in:
+        nodes.append(
+            helper.make_node(
+                "DequantizeLinear",
+                inputs=["weight_quantized", "x_scale", "x_zero_point"],
+                outputs=["base_weight_fp32"],
+                name="dequantize_base_weights",
+            )
+        )
+        base_input = "base_weight_fp32"
+    else:
+        base_input = "weight"
+
+    nodes.append(
+        helper.make_node(
+            "MatMul", inputs=["adapter_B", "adapter_A"], outputs=["lora_delta"], name="compute_lora_delta"
+        )
+    )
+    nodes.append(
+        helper.make_node(
+            "Mul", inputs=["lora_delta", "alpha"], outputs=["scaled_lora_delta"], name="scale_lora_delta"
+        )
+    )
+    nodes.append(
+        helper.make_node(
+            "Add",
+            inputs=[base_input, "scaled_lora_delta"],
+            outputs=["merged_weight_fp32"],
+            name="add_lora_delta",
+        )
+    )
+
+    if quant_out:
+        nodes.append(
+            helper.make_node(
+                "DynamicQuantizeLinear",
+                inputs=["merged_weight_fp32"],
+                outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
+                name="quantize_merged",
+            )
+        )
+    else:
+        nodes.append(
+            helper.make_node(
+                "Identity", inputs=["merged_weight_fp32"], outputs=["merged_weight"], name="identity_output"
+            )
+        )
+
+    graph = helper.make_graph(
+        nodes=nodes,
+        name="LoRAMergerModel",
+        inputs=inputs,
+        outputs=outputs,
+        doc_string=(
+            f"LoRA merger model for merging adapters "
+            f"(inputs: {'quantized' if quant_in else 'float'}, "
+            f"outputs: {'quantized' if quant_out else 'float'})."
+        ),
+    )
+    model = helper.make_model(
+        graph,
+        producer_name="LoRAMerger_v1.0",
+        producer_version="1.0.0",
+        doc_string=(
+            f"LoRA (Low-Rank Adaptation) weight merger for PEFT models. "
+            f"Input quantization: {quant_in}, Output quantization: {quant_out}."
+        ),
+        model_version=1,
+        opset_imports=[helper.make_opsetid("", 11)],
+    )
+    _append_quant_metadata(model, quant_in, quant_out)
+    return model
+
+
+def _build_mars_merger(quant_in: bool, quant_out: bool) -> onnx.ModelProto:
+    """MARS merger graph: ``merged = base + alpha * (adapter_B @ intermediate_chunk @ shared_A)``.
+
+    Reproduces ``artifact/merger.py::create_mars_merger_model_2`` (incl. the ``adapter_index``/``rank``
+    slice-chunk selection and the ``com.martinkorelic.mars`` model domain).
+    """
+    from onnx import TensorProto, helper
+
+    if quant_in:
+        inputs = [
+            helper.make_tensor_value_info(
+                "weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]
+            ),
+            helper.make_tensor_value_info("x_zero_point", TensorProto.UINT8, []),
+            helper.make_tensor_value_info("x_scale", TensorProto.FLOAT, []),
+        ]
+    else:
+        inputs = [
+            helper.make_tensor_value_info("weight", TensorProto.FLOAT, ["out_features", "in_features"]),
+        ]
+
+    if quant_out:
+        outputs = [
+            helper.make_tensor_value_info(
+                "merged_weight_quantized", TensorProto.UINT8, ["out_features", "in_features"]
+            ),
+            helper.make_tensor_value_info("merged_zero_point", TensorProto.UINT8, []),
+            helper.make_tensor_value_info("merged_scale", TensorProto.FLOAT, []),
+        ]
+    else:
+        outputs = [
+            helper.make_tensor_value_info(
+                "merged_weight", TensorProto.FLOAT, ["out_features", "in_features"]
+            ),
+        ]
+
+    inputs.extend(
+        [
+            helper.make_tensor_value_info("shared_A", TensorProto.FLOAT, ["shared_rank", "in_features"]),
+            helper.make_tensor_value_info("intermediate", TensorProto.FLOAT, ["n_times_rank", "shared_rank"]),
+            helper.make_tensor_value_info("adapter_B", TensorProto.FLOAT, ["out_features", "rank"]),
+            helper.make_tensor_value_info("adapter_index", TensorProto.INT64, []),
+            helper.make_tensor_value_info("rank", TensorProto.INT64, []),
+            helper.make_tensor_value_info("alpha", TensorProto.FLOAT, []),
+        ]
+    )
+
+    nodes = []
+    if quant_in:
+        nodes.append(
+            helper.make_node(
+                "DequantizeLinear",
+                inputs=["weight_quantized", "x_scale", "x_zero_point"],
+                outputs=["base_weight_fp32"],
+                name="dequantize_base_weights",
+            )
+        )
+    else:
+        nodes.append(
+            helper.make_node(
+                "Identity", inputs=["weight"], outputs=["base_weight_fp32"], name="pass_through_base_weight"
+            )
+        )
+
+    nodes.append(
+        helper.make_node("Mul", ["adapter_index", "rank"], ["slice_start"], name="compute_slice_start")
+    )
+    nodes.append(helper.make_node("Add", ["slice_start", "rank"], ["slice_end"], name="compute_slice_end"))
+    nodes.append(
+        helper.make_node(
+            "Unsqueeze", ["slice_start"], ["slice_start_1d"], axes=[0], name="unsqueeze_slice_start"
+        )
+    )
+    nodes.append(
+        helper.make_node("Unsqueeze", ["slice_end"], ["slice_end_1d"], axes=[0], name="unsqueeze_slice_end")
+    )
+    nodes.append(
+        helper.make_node(
+            "Constant", [], ["axes_0"], value=helper.make_tensor("axes_0_tensor", TensorProto.INT64, [1], [0])
+        )
+    )
+    nodes.append(
+        helper.make_node(
+            "Slice",
+            ["intermediate", "slice_start_1d", "slice_end_1d", "axes_0"],
+            ["chunked_intermediate"],
+            name="slice_intermediate",
+        )
+    )
+    nodes.append(
+        helper.make_node(
+            "MatMul",
+            ["adapter_B", "chunked_intermediate"],
+            ["adapter_times_chunk"],
+            name="adapter_chunk_matmul",
+        )
+    )
+    nodes.append(
+        helper.make_node(
+            "MatMul", ["adapter_times_chunk", "shared_A"], ["lora_delta_prealpha"], name="final_matmul"
+        )
+    )
+    nodes.append(
+        helper.make_node("Mul", ["lora_delta_prealpha", "alpha"], ["lora_delta"], name="scale_alpha")
+    )
+    nodes.append(
+        helper.make_node("Add", ["base_weight_fp32", "lora_delta"], ["merged_weight_fp32"], name="add_delta")
+    )
+
+    if quant_out:
+        nodes.append(
+            helper.make_node(
+                "DynamicQuantizeLinear",
+                inputs=["merged_weight_fp32"],
+                outputs=["merged_weight_quantized", "merged_scale", "merged_zero_point"],
+                name="quantize_merged",
+            )
+        )
+    else:
+        nodes.append(
+            helper.make_node(
+                "Identity", inputs=["merged_weight_fp32"], outputs=["merged_weight"], name="identity_output"
+            )
+        )
+
+    graph = helper.make_graph(
+        nodes=nodes,
+        name="MARS Merger",
+        inputs=inputs,
+        outputs=outputs,
+        doc_string=(
+            f"MARS merger model for merging adapters "
+            f"(inputs: {'quantized' if quant_in else 'float'}, "
+            f"outputs: {'quantized' if quant_out else 'float'})."
+        ),
+    )
+    model = helper.make_model(
+        graph,
+        producer_name="MARS_Merger_v1.0",
+        producer_version="1.0.0",
+        doc_string=(
+            f"MARS (Multi-Adapter Rank Sharing) weight merger for PEFT models. "
+            f"Input quantization: {quant_in}, Output quantization: {quant_out}."
+        ),
+        model_version=1,
+        domain="com.martinkorelic.mars",
+        opset_imports=[helper.make_opsetid("", 11)],
+    )
+    _append_quant_metadata(model, quant_in, quant_out)
+    return model
+
+
+def emit_merger_models(
+    output_dir: str,
+    peft_method: PEFTMethod,
+    quant_out: bool,
+    quant_ins: Iterable[bool] = (True, False),
+    extra_methods: Iterable[PEFTMethod] = (),
+) -> dict[str, str]:
+    """Emit the merger ONNX graph(s) a package needs, via the registry (no hand-picked factories).
+
+    Returns ``{MergerVariant.value: output_filename}`` for the handoff map's ``mergerModels``. Filenames
+    are descriptive (``merger_<variant>_<qin|fpin>_<qout|fpout>.onnx``). ``extra_methods`` lets a MARS
+    package also carry the LoRA mergers used for its non-MARS layers (device mixes per-layer).
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    emitted: dict[str, str] = {}
+    for method in (peft_method, *extra_methods):
+        for quant_in in quant_ins:
+            spec = resolve_merger(method, quant_in=quant_in, quant_out=quant_out)
+            build_merger_model(spec, os.path.join(output_dir, spec.output_filename))
+            emitted[spec.variant.value] = spec.output_filename
+    return emitted
+
+
+# `emit_merger_models` was defined here and imported by artifacts/builder.py, but omitted from
+# __all__ — so the module's declared public surface disagreed with its actual one. Surfaced by
+# the S9 symbol golden, which reads __all__ when a module declares one.
+__all__ = ["MergerSpec", "resolve_merger", "build_merger_model", "emit_merger_models"]
diff --git a/src/mobiletransformers/config/registry/peft.py b/src/mobiletransformers/config/registry/peft.py
new file mode 100644
index 0000000..51a0fef
--- /dev/null
+++ b/src/mobiletransformers/config/registry/peft.py
@@ -0,0 +1,149 @@
+"""PEFT method registry — single source of truth for PEFT config setup + adapter mapping + merger tag.
+
+Replaces the train_method-keyed if/elif config-setup and adapter-mapping dispatch
+(``trainer/builder.py``) and the bespoke ``create_mars_adapter_mapping`` / ``create_lora_mapping``
+key hardcoding (``trainer/utils.py``). Adding a method is a registry row + a ``PEFTMethod`` enum member.
+
+The ``component_schema`` order is the source of truth the tensor codec (#8,
+``TrainableTensorCodec.from_peft_mapping``) consumes for deterministic tensor naming. ``config_class``
+is a lazy dotted path (resolved only when a real PEFT wrap runs, in the training-export migration).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from mobiletransformers.config.constants import MergerVariant, PEFTMethod
+from mobiletransformers.config.registry.architecture import import_from_path
+from mobiletransformers.exceptions import UnsupportedModelError
+
+
+@dataclass(frozen=True)
+class AdapterComponent:
+    role: str  # "shared_A" | "intermediate" | "adapter_A" | "adapter_B" | ...
+    search_pattern: str  # how to locate the tensor in the PEFT-wrapped module
+
+
+@dataclass(frozen=True)
+class PEFTMethodSpec:
+    method: PEFTMethod
+    config_class: str | None  # dotted path to LoraConfig | MarsConfig | ...; None for all/nolora
+    component_schema: tuple[AdapterComponent, ...]  # ORDER is the codec's source of truth
+    merger_variant_fp: MergerVariant | None  # merger variant when output is not quantized
+    merger_variant_q: MergerVariant | None  # merger variant when output is quantized
+    builds_mapping: bool = True
+    #: Lazy dotted path to this method's adapter-mapping builder (same lazy-import convention as
+    #: ``config_class``). ``None`` when ``builds_mapping`` is False. The builders differ in substance
+    #: — MARS tracks shared-module identity and qkv/mlp adapter indices, LoRA is a flat module scan —
+    #: so this dispatches to them rather than pretending one generic walk covers both.
+    mapping_builder: str | None = None
+
+
+#: PEFT target modules keyed by HF ``config.model_type`` — the SINGLE source for what MARS/ablation
+#: wrap when the user names no explicit ``target_modules``. Previously duplicated byte-for-byte across
+#: ``peft/mars/utils.py`` and ``peft/ablation/utils.py`` under two different dict names,
+#: which is exactly the drift #6 exists to remove; both now re-export this table.
+#:
+#: NOTE this is keyed by ``model_type`` (``llama``, ``t5``, ...) and deliberately NOT collapsed onto
+#: :attr:`ArchitectureSpec.target_modules`, which is keyed by ``config.architectures[0]``
+#: (``LlamaForCausalLM``, ...) and covers only the 8 architectures the ONNX export path supports.
+#: The two key spaces are different and this one is far wider — folding them would silently drop
+#: PEFT support for t5/mt5/bart/gpt2/bloom/gptj/gpt_neo(x)/bert/roberta/deberta(-v2)/gpt_bigcode.
+PEFT_TARGET_MODULES_BY_MODEL_TYPE: dict[str, list[str]] = {
+    "t5": ["q", "k", "v", "o", "wi", "wo"],
+    "mt5": ["q", "k", "v", "o", "wi_0", "wi_1", "wo"],
+    "bart": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gpt2": ["c_attn"],
+    "bloom": ["query_key_value"],
+    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "llama": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "value"],
+    "deberta-v2": ["query_proj", "key_proj", "value_proj", "dense"],
+    "gpt_bigcode": ["c_attn"],
+    "deberta": ["in_proj"],
+    "qwen2": ["q_proj", "v_proj"],
+}
+
+
+_LORA_COMPONENTS = (
+    AdapterComponent("adapter_A", "lora_A"),
+    AdapterComponent("adapter_B", "lora_B"),
+)
+_MARS_COMPONENTS = (
+    AdapterComponent("shared_A", "mars_shared_A"),
+    AdapterComponent("adapter_B", "mars_B"),
+)
+
+PEFT_REGISTRY: dict[PEFTMethod, PEFTMethodSpec] = {
+    PEFTMethod.LORA: PEFTMethodSpec(
+        PEFTMethod.LORA,
+        "peft.LoraConfig",
+        _LORA_COMPONENTS,
+        MergerVariant.LORA,
+        MergerVariant.LORA_Q,
+        mapping_builder="mobiletransformers.peft.mapping.create_lora_mapping",
+    ),
+    PEFTMethod.LORA_XS: PEFTMethodSpec(
+        PEFTMethod.LORA_XS,
+        "peft.LoraConfig",
+        _LORA_COMPONENTS,
+        MergerVariant.LORA,
+        MergerVariant.LORA_Q,
+        # LoRA-XS reparameterizes an existing LoRA wrap, so it shares LoRA's module layout.
+        mapping_builder="mobiletransformers.peft.mapping.create_lora_mapping",
+    ),
+    PEFTMethod.MARS: PEFTMethodSpec(
+        PEFTMethod.MARS,
+        "mobiletransformers.peft.mars.config.MarsConfig",
+        _MARS_COMPONENTS,
+        MergerVariant.MARS_Q,
+        MergerVariant.MARS_Q,
+        mapping_builder="mobiletransformers.peft.mapping.create_mars_adapter_mapping",
+    ),
+    # "all" (all linear layers trainable) and "nolora" produce no adapter mapping and no merger.
+    PEFTMethod.ALL: PEFTMethodSpec(PEFTMethod.ALL, None, (), None, None, builds_mapping=False),
+    PEFTMethod.NOLORA: PEFTMethodSpec(PEFTMethod.NOLORA, None, (), None, None, builds_mapping=False),
+}
+
+
+def get_peft_spec(method: PEFTMethod) -> PEFTMethodSpec:
+    """Look up the spec for a PEFT method. Fail closed on unknown."""
+    spec = PEFT_REGISTRY.get(method)
+    if spec is None:
+        raise UnsupportedModelError(f"unsupported PEFT method: {method}")
+    return spec
+
+
+def build_adapter_mapping(method: PEFTMethod, model: Any, **kwargs: Any) -> dict[str, Any]:
+    """Build the base-layer -> adapter-tensor mapping for ``method`` (#6 A3).
+
+    The ONE entry point for adapter mapping: callers pass the resolved :class:`PEFTMethod` and never
+    branch on a method string themselves. It returns ``{}`` for methods that produce no adapters
+    (``all`` / ``nolora``) and fails closed on a method whose spec claims to build a mapping but
+    registers no builder.
+
+    ``**kwargs`` are forwarded to the resolved builder (e.g. MARS's ``shared_qkv`` /
+    ``shared_mlp_enabled``); a builder that does not accept them will say so.
+    """
+    spec = get_peft_spec(method)
+    if not spec.builds_mapping:
+        return {}
+    if spec.mapping_builder is None:
+        raise UnsupportedModelError(
+            f"PEFT method {method.value!r} declares builds_mapping but registers no mapping_builder"
+        )
+    return dict(import_from_path(spec.mapping_builder)(model, **kwargs))
+
+
+__all__ = [
+    "AdapterComponent",
+    "PEFTMethodSpec",
+    "PEFT_REGISTRY",
+    "get_peft_spec",
+    "build_adapter_mapping",
+]
diff --git a/src/mobiletransformers/config/registry/task.py b/src/mobiletransformers/config/registry/task.py
new file mode 100644
index 0000000..96476d3
--- /dev/null
+++ b/src/mobiletransformers/config/registry/task.py
@@ -0,0 +1,251 @@
+"""Task registry — single source of truth for what a task type implies at export time.
+
+Replaces the task-keyed branches that survived #6's registry pass in ``export/training_export.py``:
+
+* ``if task_type == "text-generation": AutoModelForCausalLM else AutoModel`` — the auto-model class;
+* ``if spec.task == TaskType.FEATURE_EXTRACTION: cls(config, task=…) else cls(…, use_past=…)`` — the
+  KV-cache kwargs;
+* ``LoraConfig(…, task_type="CAUSAL_LM")``, **hardcoded at both call sites**.
+
+The third was not a style problem. `"CAUSAL_LM"` is wrong for an encoder: PEFT uses the task type to
+decide which modules to wrap and which head to keep trainable, so an encoder wrapped as `CAUSAL_LM`
+is mis-configured from the first step. It was invisible while only decoders were trained, and it is
+exactly the kind of latent branch #33 (encoder support) walks into — which is why the registry lands
+before the encoder work rather than after it.
+
+Adding a task is a row here plus a ``TaskType`` member, not a new ``elif``. Class bindings are lazy
+dotted paths (the same convention as ``architecture.py``/``peft.py``) so the core profile imports this
+without pulling transformers or torch.
+
+## Adding a training objective
+
+A ``TaskSpec`` is the whole description of an objective. To add one (masked-LM and contrastive
+embedding are the obvious next two):
+
+1. Add a ``TaskType`` member and mirror it in ``constants/TaskType.kt``, then regenerate with
+   ``python -m mobiletransformers.codegen.enums`` — ``make parity`` fails until both sides agree.
+2. Add a row here. The fields that actually differ between objectives are:
+   ``auto_model_class`` (which head), ``peft_task_type`` (how PEFT wraps it), ``label_shape``
+   (per-token vs per-sequence — the big one), ``model_init_kwargs`` (e.g. ``num_labels``),
+   ``uses_kv_cache``, and ``trainable``.
+3. Reuse a wrapper if the input set matches; add one only if the **forward signature** differs, since
+   those parameter names become the exported ONNX input names.
+4. Add architecture rows for the concrete `<Arch>For<Head>` classes the objective loads.
+
+Worked example — masked-LM would be `auto_model_class="transformers.AutoModelForMaskedLM"`,
+`peft_task_type=None` (PEFT has no MLM task type; it infers), `label_shape=("batch_size",
+"sequence_length")` (per token, like the decoder), the existing encoder wrapper, and no
+`model_init_kwargs`. No new branches anywhere.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from mobiletransformers.config.constants import TaskType
+from mobiletransformers.exceptions import UnsupportedModelError
+
+
+@dataclass(frozen=True)
+class TaskSpec:
+    """What a task type implies for the export path."""
+
+    task: TaskType
+
+    #: Dotted path to the transformers auto-model class the export loads the source model with.
+    auto_model_class: str
+
+    #: Whether this task's ONNX config takes the KV-cache kwargs (``use_past``/``use_past_in_inputs``).
+    #:
+    #: Decoders cache past keys/values across steps; encoders do a single forward pass and their
+    #: ``OnnxConfig`` does not accept the kwargs at all — passing them raises. This is the data behind
+    #: the `spec.task == FEATURE_EXTRACTION` branch, and it is also the reason encoder support gets to
+    #: **delete** the autoregressive path rather than special-case it.
+    uses_kv_cache: bool
+
+    #: PEFT's own task-type string (``peft.TaskType``), or ``None`` when PEFT should infer it.
+    #:
+    #: Feature-extraction models have no LM head, so ``FEATURE_EXTRACTION`` is what keeps PEFT from
+    #: looking for one. Passing ``CAUSAL_LM`` here — as both LoRA call sites used to, unconditionally —
+    #: mis-wraps an encoder.
+    peft_task_type: str | None
+
+    #: Dotted path to the ``torch.nn.Module`` that wraps the model for the training-graph export.
+    #:
+    #: A class rather than a list of input names because ``torch.onnx`` derives the exported ONNX input
+    #: names from the wrapper's **forward signature** — they are part of the on-device contract, so they
+    #: have to be written out literally, not assembled. Decoders take ``position_ids``, BERT-family
+    #: encoders take ``token_type_ids``; a decoder-shaped wrapper fails an encoder export inside optimum
+    #: at ``check_dummy_inputs_are_allowed``.
+    trainer_wrapper_class: str = "mobiletransformers.export.training_export.OnnxTrainerWrapper"
+
+    #: Whether this task can produce a **training** graph at all.
+    #:
+    #: ``feature-extraction`` cannot: ``AutoModel`` has no head, so its forward takes no ``labels`` and
+    #: returns no loss, and the export dies deep inside torch with an unexplained
+    #: ``unexpected keyword argument 'labels'``. Declaring it here turns that into one clear message
+    #: naming the task and the alternative.
+    trainable: bool = True
+
+    #: Shape of the label tensor this objective supervises, as a symbolic-dim tuple.
+    #:
+    #: The axis on which objectives differ most. Token-level objectives (causal LM, and MLM when it
+    #: lands) supervise one label per position; sequence-level ones supervise one per example. It
+    #: propagates: ``OnnxConfigWithLoss``'s dummy label generator, the on-device data curator, and how
+    #: a reported loss should be read all key off this.
+    label_shape: tuple[str, ...] = ("batch_size", "sequence_length")
+
+    #: Node-name substrings kept OUT of dynamic quantization, beyond the trainable modules.
+    #:
+    #: The backward pass has to traverse the task head to reach the adapters, and ORT registers **no
+    #: gradient builder for ``DynamicQuantizeLinear``** — so quantizing anything on the gradient path
+    #: makes ``generate_artifacts`` fail with "The gradient builder has not been registered". Decoders
+    #: get away with ``embed_head`` alone; BERT-family classification also routes through ``pooler``
+    #: and ``classifier``, and omitting them fails exactly there.
+    quantization_exclude_layers: tuple[str, ...] = ("embed_head",)
+
+    #: Extra kwargs for ``from_pretrained``, e.g. ``num_labels`` for a classification head.
+    #:
+    #: Values here are *defaults*; a caller-supplied value wins. Keeping them as data is what lets a
+    #: new objective (masked-LM, contrastive) arrive as a row instead of another branch at the load
+    #: site.
+    model_init_kwargs: dict[str, object] = field(default_factory=dict)
+
+    # -- package shape ------------------------------------------------------
+    #
+    # Everything below describes what a task's PACKAGE looks like, not how its graph is built. Before
+    # this, `export/pipeline.py` read no `TaskSpec` at all: it emitted a GenAI decoder config, stamped
+    # KV-cache geometry, and ran a causal-LM parity check for every model, because a decoder was the
+    # only thing that had ever been packaged. An encoder came out with a `model.decoder` block
+    # describing a cache it does not have.
+
+    #: Whether the inference graph carries a `model.decoder` GenAI config (`past_key_names`, etc.).
+    #:
+    #: Separate from :attr:`uses_kv_cache` on purpose: that one governs how the ONNX config is
+    #: CONSTRUCTED, this one governs what the packager WRITES. They coincide today, and collapsing them
+    #: would be a guess about a future task rather than a fact about the current ones.
+    emits_genai_config: bool = True
+
+    #: Whether `head_dim`/`num_kv_heads`/`num_layers` are stamped into the graph's ``metadata_props``.
+    #:
+    #: The Native engine sizes its KV cache from these and fails closed when they are absent
+    #: (``session_cache.h::initializeKVCache``). For a task with no cache they are meaningless, and
+    #: stamping a decoder's geometry onto an encoder is worse than omitting it.
+    stamps_kv_metadata: bool = True
+
+    #: Dotted path to the train-vs-inference numerical gate, or ``None`` when the task has none yet.
+    #:
+    #: ``artifacts/train_inference_parity.py`` is hard causal-LM: it shifts ``logits[:, :-1]`` against
+    #: ``input_ids[:, 1:]`` and requires rank-3 logits. A classification graph emits ``[batch, labels]``
+    #: and is supervised per sequence, so running it there raises rather than measures. Naming the
+    #: checker as data keeps the gate a task property instead of an ``if`` in the pipeline.
+    parity_check: str | None = (
+        "mobiletransformers.artifacts.train_inference_parity.verify_train_inference_parity"
+    )
+
+    @property
+    def stages(self) -> tuple[str, ...]:
+        """Package stages this task can produce, in deterministic order.
+
+        Derived rather than declared: a task always ships an inference graph, and ships a training
+        stage exactly when it is :attr:`trainable`. ``embedding`` is a RAG opt-in rather than a task
+        property, so the pipeline adds it from the requested features.
+        """
+        return ("inference", "train") if self.trainable else ("inference",)
+
+    @property
+    def is_token_level(self) -> bool:
+        """True when the objective supervises one label per token rather than per sequence."""
+        return "sequence_length" in self.label_shape
+
+    def onnx_config_kwargs(self, *, training_mode: bool) -> dict[str, bool]:
+        """The KV-cache kwargs this task's ``*OnnxConfig`` should be constructed with.
+
+        Training graphs never use a cache (the backward pass needs the full sequence), so the kwargs
+        are ``not training_mode`` for cached tasks and absent entirely for uncached ones.
+        """
+        if not self.uses_kv_cache:
+            return {}
+        return {"use_past": not training_mode, "use_past_in_inputs": not training_mode}
+
+
+#: The closed set of export task types. Keyed by :class:`TaskType`, which is mirrored to Kotlin and
+#: parity-checked, so a task cannot exist here without existing on both sides of the boundary.
+TASK_REGISTRY: dict[TaskType, TaskSpec] = {
+    TaskType.TEXT_GENERATION: TaskSpec(
+        task=TaskType.TEXT_GENERATION,
+        auto_model_class="transformers.AutoModelForCausalLM",
+        uses_kv_cache=True,
+        peft_task_type="CAUSAL_LM",
+        label_shape=("batch_size", "sequence_length"),
+    ),
+    TaskType.FEATURE_EXTRACTION: TaskSpec(
+        task=TaskType.FEATURE_EXTRACTION,
+        auto_model_class="transformers.AutoModel",
+        uses_kv_cache=False,
+        peft_task_type="FEATURE_EXTRACTION",
+        # BERT-family: token_type_ids in, no position_ids. Matches `BertOnnxConfig`'s dummy inputs.
+        trainer_wrapper_class="mobiletransformers.export.training_export.OnnxEncoderTrainerWrapper",
+        # Export/inference only — no head, therefore no loss. This is the RAG embedder's task.
+        trainable=False,
+        label_shape=(),
+        # No cache, so no decoder block and no cache geometry. Writing them produced a genai_config
+        # advertising `past_key_values.N` inputs this graph does not have.
+        emits_genai_config=False,
+        stamps_kv_metadata=False,
+        # No head, no loss: there is nothing to compare against the training graph.
+        parity_check=None,
+    ),
+    TaskType.SEQUENCE_CLASSIFICATION: TaskSpec(
+        task=TaskType.SEQUENCE_CLASSIFICATION,
+        auto_model_class="transformers.AutoModelForSequenceClassification",
+        uses_kv_cache=False,
+        peft_task_type="SEQ_CLS",
+        trainer_wrapper_class=(
+            "mobiletransformers.export.training_export.OnnxSequenceClassificationTrainerWrapper"
+        ),
+        # One label per SEQUENCE, not per token — the axis that separates this from every decoder task.
+        label_shape=("batch_size",),
+        # The classification head sits on the gradient path between the loss and the adapters, and
+        # DynamicQuantizeLinear has no gradient. Quantizing it breaks generate_artifacts outright.
+        quantization_exclude_layers=("embed_head", "pooler", "classifier"),
+        # Binary by default; a caller passing num_labels wins. The head is randomly initialised by
+        # construction (it does not exist in the checkpoint), which is correct and expected — it is the
+        # part fine-tuning is supposed to learn.
+        model_init_kwargs={"num_labels": 2},
+        # A classifier is not a generator: no cache, no decoder block, no cache geometry.
+        emits_genai_config=False,
+        stamps_kv_metadata=False,
+        # No causal-LM parity gate exists for a per-sequence objective yet. `None` records the absence
+        # honestly instead of running the causal checker, which raises on rank-2 logits and would read
+        # as "the package is broken" rather than "this gate does not apply".
+        parity_check=None,
+    ),
+}
+
+
+def get_task_spec(task: TaskType | str) -> TaskSpec:
+    """Resolve a task type (enum or wire string) to its spec, failing closed on an unknown one.
+
+    Accepts the wire string because the export entry points take ``task_type`` as text from the CLI,
+    and a single parse at the boundary is the #6 convention — the alternative is every caller doing
+    its own ``TaskType(...)`` and each getting the error message slightly wrong.
+    """
+    if not isinstance(task, TaskType):
+        # `text-generation-with-past` and friends are KV-cache variants of the same task; the suffix
+        # selects graph shape, not task identity, and TasksManager owns that selection.
+        base = str(task).replace("-with-past", "")
+        try:
+            task = TaskType(base)
+        except ValueError as exc:
+            raise UnsupportedModelError(
+                f"unknown task type {task!r} (expected one of {sorted(t.value for t in TASK_REGISTRY)})"
+            ) from exc
+
+    try:
+        return TASK_REGISTRY[task]
+    except KeyError as exc:  # pragma: no cover - unreachable while TaskType and the registry agree
+        raise UnsupportedModelError(
+            f"task {task.value!r} has no registry row; add one to TASK_REGISTRY rather than "
+            "branching on the task at the call site"
+        ) from exc
diff --git a/src/mobiletransformers/config/settings.py b/src/mobiletransformers/config/settings.py
new file mode 100644
index 0000000..936f522
--- /dev/null
+++ b/src/mobiletransformers/config/settings.py
@@ -0,0 +1,86 @@
+"""Typed, env-driven runtime settings — the single owner of secrets and machine paths.
+
+Decision (final): stdlib ``dataclass`` loader; do NOT add ``pydantic-settings``. ``pydantic>=2``
+is a core dependency for the typed *tunable* config models, but secrets stay
+dependency-light and env-only.
+
+``get_settings()`` is the ONLY place the environment is read for secrets. Business logic calls
+``get_settings().hf_token`` / ``.require_hf_token()`` and never reads secret env vars directly.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+@dataclass(frozen=True)
+class Settings:
+    """Immutable snapshot of secrets + machine-specific paths, read from the environment."""
+
+    hf_token: str | None
+    #: Token for writing to the **organisation**, when it differs from the personal one.
+    #:
+    #: These are genuinely two credentials, and conflating them fails in a way that looks like
+    #: success: the personal ``HF_TOKEN`` here is fine-grained and scoped to a single repo, so an
+    #: org upload authenticated with it either 401s or lands in the wrong namespace. Held as its
+    #: own field rather than by overwriting ``HF_TOKEN`` in a subprocess env, which is what the
+    #: shell publishers do and what makes "which identity actually pushed this" unanswerable.
+    hf_token_org: str | None
+    hf_cache: Path | None
+    # Azure OpenAI (evaluation only)
+    azure_openai_endpoint: str | None
+    azure_openai_api_key: str | None
+    azure_deployment_name: str | None
+    azure_model_name: str | None
+    azure_api_version: str | None
+    # Gemini (openehr evaluation)
+    gemini_api_key: str | None
+
+    def require_hf_token(self) -> str:
+        if not self.hf_token:
+            raise RuntimeError(
+                "HF_TOKEN is not set (mobiletransformers.config.settings). "
+                "Export it or add it to your .env file."
+            )
+        return self.hf_token
+
+    def require_org_token(self) -> str:
+        """The token to push to the organisation with — ``HF_TOKEN_ORG``, else ``HF_TOKEN``.
+
+        The fallback is deliberate but narrow: a contributor who only has one token should still be
+        able to run a publisher, while a machine that has both never silently picks the weaker one.
+        """
+        token = self.hf_token_org or self.hf_token
+        if not token:
+            raise RuntimeError(
+                "neither HF_TOKEN_ORG nor HF_TOKEN is set (mobiletransformers.config.settings). "
+                "Publishing to the organisation needs a token with write access to it — see "
+                ".env.example."
+            )
+        return token
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    """Return the process-wide :class:`Settings` singleton (env is read once, then cached)."""
+    load_dotenv()  # preserves the legacy config.py load_dotenv() behavior
+
+    def _path(value: str | None) -> Path | None:
+        return Path(value) if value else None
+
+    return Settings(
+        hf_token=os.environ.get("HF_TOKEN"),
+        hf_token_org=os.environ.get("HF_TOKEN_ORG"),
+        hf_cache=_path(os.environ.get("HF_CACHE")),
+        azure_openai_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
+        azure_openai_api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
+        azure_deployment_name=os.environ.get("AZURE_DEPLOYMENT_NAME"),
+        azure_model_name=os.environ.get("AZURE_MODEL_NAME"),
+        azure_api_version=os.environ.get("AZURE_API_VERSION"),
+        gemini_api_key=os.environ.get("GEMINI_API_KEY"),
+    )
diff --git a/src/mobiletransformers/evaluation/__init__.py b/src/mobiletransformers/evaluation/__init__.py
new file mode 100644
index 0000000..56193b6
--- /dev/null
+++ b/src/mobiletransformers/evaluation/__init__.py
@@ -0,0 +1,23 @@
+"""Reusable evaluators (Migration Map S8, formerly the ``evaluation/`` root).
+
+What landed here is the code with an **importable API** — evaluator classes and functions a caller can
+drive. The former `evaluation/benchmark/` and `evaluation/test/` trees did **not**: they carry no
+classes or functions at all, run their work in top-level statements at import time, and hardcode
+`experiment_results/...` paths. Packaging those would put side-effecting scripts inside an installable
+wheel, so they moved to `research/evaluation/` instead, following the same call S5 made for
+`artifact/tflite_builder.py`. (Despite its name, `evaluation/test/` contained no tests.)
+
+Modules:
+
+* :mod:`~mobiletransformers.evaluation.eval_adapter_models` — `CustomPeftModel`, the PEFT-adapter
+  wrapper the deepeval benchmarks drive.
+* :mod:`~mobiletransformers.evaluation.eval_adapter_onnx_model` — the ONNX counterpart.
+* :mod:`~mobiletransformers.evaluation.mobile_evaluator` — `MobileEvaluator`.
+* :mod:`~mobiletransformers.evaluation.mobile` — on-device recommendation / personal-QA evaluators.
+* :mod:`~mobiletransformers.evaluation.openehr` — the openEHR case study and its plots.
+
+Nothing is re-exported at package level: these need the ``eval`` extra (deepeval, matplotlib) and in
+places torch/transformers, none of which the core profile installs. Import the submodule you need.
+
+``evaluation/`` still holds deprecation shims re-exporting these names; they are removed in S9.
+"""
diff --git a/evaluation/eval_adapter_models.py b/src/mobiletransformers/evaluation/eval_adapter_models.py
similarity index 73%
rename from evaluation/eval_adapter_models.py
rename to src/mobiletransformers/evaluation/eval_adapter_models.py
index 30b60ff..c0d6d89 100644
--- a/evaluation/eval_adapter_models.py
+++ b/src/mobiletransformers/evaluation/eval_adapter_models.py
@@ -3,26 +3,31 @@
 """
 
 from __future__ import annotations
-from safetensors import safe_open
-import torch, os, json
-from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig, AutoConfig
-from peft_models.ablation.config import AblationConfig
-from peft_models.ablation.model import AblationModel
-from peft_models.lora_xs.initialization_utils import find_and_initialize
-from peft_models.mars.config import MarsConfig
-from peft_models.mars.model import MarsModel
-
-from peft import PeftModel, PeftConfig, get_peft_model
+
+import json
+import os
+
+import torch
+from peft import PeftConfig, PeftModel, PeftType, get_peft_model
 from peft.peft_model import PEFT_TYPE_TO_MODEL_MAPPING
-from peft import PeftType
 from peft.tuners.lora import LoraConfig
-from research.utils import load_mars_adapters
+from safetensors import safe_open
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+from mobiletransformers.peft.ablation.config import AblationConfig
+from mobiletransformers.peft.ablation.model import AblationModel
+from mobiletransformers.peft.adapters import load_mars_adapters
+from mobiletransformers.peft.lora_xs.initialization_utils import find_and_initialize
+from mobiletransformers.peft.mars.config import MarsConfig
+from mobiletransformers.peft.mars.model import MarsModel
+
 
 def add_peft_type(name, value):
     """Dynamically add a new value to the PeftType enum."""
     setattr(PeftType, name, value)
     PeftType._value2member_map_[value] = name
 
+
 # Add custom PEFT type dynamically
 add_peft_type("MARS", "MARS")
 add_peft_type("ABLATION", "ABLATION")
@@ -34,11 +39,20 @@ def add_peft_type(name, value):
 from deepeval.models import DeepEvalBaseLLM
 from safetensors.torch import load_file
 
+
 class CustomPeftModel(DeepEvalBaseLLM):
-    def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", base_model=None, empty_init = False, device="cuda"):
+    def __init__(
+        self,
+        adapter_path,
+        model_name="PEFT model",
+        adapter_name="lora",
+        base_model=None,
+        empty_init=False,
+        device="cuda",
+    ):
         """
         Custom LLM class that loads a base model and applies a PEFT adapter if available.
-        
+
         Parameters:
             base_model_path (str): Path to the base model (Hugging Face model ID or local directory).
             adapter_path (str, optional): Path to PEFT adapter folder (contains `adapter_model.safetensors`).
@@ -56,23 +70,22 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
 
         # Check if base model exists
         if os.path.exists(base_tensors):
-            
             model_path = base_tensors
         elif os.path.exists(adapter_tensors):
-
             is_adapter_model = True
-            
+
             model_path = adapter_tensors
         else:
             if adapter_name == "base":
                 print("No corresponding adapter weights found, using only base model")
             else:
-                raise FileNotFoundError("No 'adapter_config.json' or 'config.json' and their corresponding weights found!")
+                raise FileNotFoundError(
+                    "No 'adapter_config.json' or 'config.json' and their corresponding weights found!"
+                )
 
         if os.path.exists(base_config_path):
-
             config_path = base_config_path
-            with open(base_config_path, "r", encoding="utf-8") as f:
+            with open(base_config_path, encoding="utf-8") as f:
                 base_model_name = json.load(f)["_name_or_path"]
             config = AutoConfig.from_pretrained(config_path)
 
@@ -83,16 +96,16 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                 config = PeftConfig.from_pretrained(adapter_path)
             elif adapter_name in ["mars", "qmars"]:
                 mars_config = {}
-                with open(adapter_config_path, "r", encoding="utf-8") as f:
+                with open(adapter_config_path, encoding="utf-8") as f:
                     mars_config = json.load(f)
                 config = MarsConfig(**mars_config)
             elif adapter_name == "ablation":
                 ablation_config = {}
-                with open(adapter_config_path, "r", encoding="utf-8") as f:
+                with open(adapter_config_path, encoding="utf-8") as f:
                     ablation_config = json.load(f)
                 config = AblationConfig(**ablation_config)
             elif adapter_name == "lora_xs":
-                with open(adapter_config_path, "r", encoding="utf-8") as f:
+                with open(adapter_config_path, encoding="utf-8") as f:
                     lora_xs_config = json.load(f)
                 config = LoraConfig(**lora_xs_config)
 
@@ -105,7 +118,7 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
             if adapter_name in ["qlora", "qmars", "loraq4", "loraq8"]:
                 try:
                     from transformers import BitsAndBytesConfig
-                    
+
                     if adapter_name in ["qlora", "qmars"]:
                         # Original 4-bit quantization for QLoRA/QMARS
                         quantization_config = BitsAndBytesConfig(
@@ -116,10 +129,10 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                             # Use 4-bit Normal Float for storing the base model weights in GPU memory
                             bnb_4bit_quant_type="nf4",
                             # De-quantize the weights to 32-bit float before the forward/backward pass
-                            bnb_4bit_compute_dtype=torch.float32
+                            bnb_4bit_compute_dtype=torch.float32,
                         )
                         print("Using 4-bit quantization for QLoRA/QMARS")
-                        
+
                     elif adapter_name == "loraq4":
                         # 4-bit quantization with int4 for LoRA
                         quantization_config = BitsAndBytesConfig(
@@ -129,7 +142,7 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                             bnb_4bit_compute_dtype=torch.float32,
                         )
                         print("Using 4-bit int4 quantization for LoRAQ4")
-                        
+
                     elif adapter_name == "loraq8":
                         # 8-bit quantization for LoRA with optimized settings
                         quantization_config = BitsAndBytesConfig(
@@ -139,15 +152,14 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                             # llm_int8_skip_modules can be added if certain modules need to be skipped
                         )
                         print("Using 8-bit int8 quantization for LoRAQ8")
-                        
+
                 except ImportError as e:
                     print(f"Warning: BitsAndBytesConfig not available for quantization: {e}")
                     print("Loading model without quantization")
                     quantization_config = None
-                    
+
                 base_model = AutoModelForCausalLM.from_pretrained(
-                    base_model_name, 
-                    quantization_config=quantization_config
+                    base_model_name, quantization_config=quantization_config
                 )
             else:
                 base_model = AutoModelForCausalLM.from_pretrained(base_model_name)
@@ -158,7 +170,6 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                 else:
                     self.model = PeftModel.from_pretrained(base_model, adapter_path, config=config)
             elif adapter_name == "mars" or adapter_name == "qmars":
-                
                 # Create PeftModel
                 model = get_peft_model(base_model, config, adapter_name="mars", autocast_adapter_dtype=False)
 
@@ -169,9 +180,10 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
 
                 print(f"Loaded MARS adapters from {adapter_tensors}.")
             elif adapter_name == "ablation":
-                
                 # Create PeftModel
-                model = get_peft_model(base_model, config, adapter_name="ablation", autocast_adapter_dtype=False)
+                model = get_peft_model(
+                    base_model, config, adapter_name="ablation", autocast_adapter_dtype=False
+                )
 
                 # Load adapters
                 if not empty_init:
@@ -180,45 +192,45 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
                     self.model = model
 
                 print(f"Loaded Ablation adapters from {adapter_tensors}.")
-            elif adapter_name == "lora_xs":            
-
+            elif adapter_name == "lora_xs":
                 self.model = get_peft_model(base_model, config)
 
                 adapter_name = "default"
                 peft_config_dict = {adapter_name: config}
 
                 reconstr_config = {
-                    'reconstruction_type': "svd",
-                    'reconstr_mode': "separated",
-                    'half_init_dec': False,
-                    'replacement_module_random_init': False,
-                    'r_squared': True,
-                    'svd': {
-                        'rank': config.r,
-                        'n_iter': 10,
-                        'random_state': 42
-                    }
+                    "reconstruction_type": "svd",
+                    "reconstr_mode": "separated",
+                    "half_init_dec": False,
+                    "replacement_module_random_init": False,
+                    "r_squared": True,
+                    "svd": {"rank": config.r, "n_iter": 10, "random_state": 42},
                 }
 
-                reconstr_type = reconstr_config['reconstruction_type']
+                reconstr_type = reconstr_config["reconstruction_type"]
 
                 # in order to accelerate model preparation, svd iterations will be set to 1.
-                reconstr_config['svd']['n_iter'] = 1
-
-                find_and_initialize(self.model, peft_config_dict, adapter_name=adapter_name, reconstr_type=reconstr_type, writer=None, reconstruct_config=reconstr_config)
+                reconstr_config["svd"]["n_iter"] = 1
+
+                find_and_initialize(
+                    self.model,
+                    peft_config_dict,
+                    adapter_name=adapter_name,
+                    reconstr_type=reconstr_type,
+                    writer=None,
+                    reconstruct_config=reconstr_config,
+                )
 
                 peft_model_weights = {}
                 with safe_open(adapter_tensors, framework="pt", device="cpu") as f:
                     for key in f.keys():
                         peft_model_weights[key] = f.get_tensor(key)
                 renamed_state_dict = {
-                    k.replace(
-                        "lora_A", "lora_A.default"
-                    ).replace(
-                        "lora_B", "lora_B.default"
-                    ).replace(
-                        "_lora_latent", ".default_lora_latent"): v
-                    for (k, v) in peft_model_weights.items() if "classifier.out_proj" not in k
+                    k.replace("lora_A", "lora_A.default")
+                    .replace("lora_B", "lora_B.default")
+                    .replace("_lora_latent", ".default_lora_latent"): v
+                    for (k, v) in peft_model_weights.items()
+                    if "classifier.out_proj" not in k
                 }
                 self.model.load_state_dict(renamed_state_dict, strict=False)
         elif adapter_name == "base":
@@ -226,10 +238,10 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
         else:
             self.model = AutoModelForCausalLM.from_config(config)
             state_dict = load_file(model_path)
-            #for param_name in state_dict.keys():
+            # for param_name in state_dict.keys():
             #    print(param_name)
             self.model.load_state_dict(state_dict, strict=False)
-        
+
         # Set tokenizer
         self.tokenizer = AutoTokenizer.from_pretrained(base_model_name)
 
@@ -243,17 +255,17 @@ def __init__(self, adapter_path, model_name="PEFT model", adapter_name="lora", b
 
             # Custom generation config
             self.generation_config.early_stopping = True
-            
+
             self.generation_config.max_new_tokens = 3
 
-        except Exception as e:
+        except Exception:
             print("No generation config found. Using default settings.")
             self.generation_config = self.model.generation_config
 
         # Move to device
         self.model.to(device)
         self.device = device
-    
+
     def set_generation_config(self, early_stopping=True, max_new_tokens=20):
         self.generation_config.early_stopping = early_stopping
         self.generation_config.max_new_tokens = max_new_tokens
@@ -271,13 +283,13 @@ def generate(self, prompt: str) -> str:
 
         with torch.no_grad():
             # Use autocast for QMARS to handle dtype mismatches
-            if hasattr(self, 'adapter_name') and self.adapter_name == "qmars":
+            if hasattr(self, "adapter_name") and self.adapter_name == "qmars":
                 with torch.cuda.amp.autocast():
                     outputs = self.model.generate(**inputs, generation_config=self.generation_config)
             else:
                 outputs = self.model.generate(**inputs, generation_config=self.generation_config)
 
-        generated_tokens = outputs[0][input_length:] 
+        generated_tokens = outputs[0][input_length:]
         return self.tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
 
     async def a_generate(self, prompt: str) -> str:
@@ -285,13 +297,13 @@ async def a_generate(self, prompt: str) -> str:
 
     def get_model_name(self):
         return self.name
-    
-    def setup_attention_viz(self, max_new_tokens: int = 1, 
-                           do_sample: bool = False, 
-                           early_stopping: bool = True):
+
+    def setup_attention_viz(
+        self, max_new_tokens: int = 1, do_sample: bool = False, early_stopping: bool = True
+    ):
         """
         Configure generation settings optimized for attention visualization.
-        
+
         Args:
             max_new_tokens: Number of tokens to generate (keep small for viz)
             do_sample: Use sampling (False for deterministic results)
@@ -302,23 +314,29 @@ def setup_attention_viz(self, max_new_tokens: int = 1,
         self.generation_config.early_stopping = early_stopping
         self.generation_config.output_attentions = True  # Enable attention output
         self.generation_config.return_dict_in_generate = True  # Get structured output
-        
+
         # Set pad token if not already set
         if self.generation_config.pad_token_id is None:
             self.generation_config.pad_token_id = self.tokenizer.eos_token_id
-        
-        print(f"✓ Attention visualization setup complete:")
+
+        print("✓ Attention visualization setup complete:")
         print(f"  - max_new_tokens: {max_new_tokens}")
         print(f"  - do_sample: {do_sample}")
-        print(f"  - output_attentions: True")
-        print(f"  - return_dict_in_generate: True")
-    
-    def simple_attention_viz(self, prompt: str, layer: int = -1, head: int = 0, 
-                            save_path: str = "attention_plot.png", show_plot: bool = False,
-                            average_heads: bool = False) -> tuple:
+        print("  - output_attentions: True")
+        print("  - return_dict_in_generate: True")
+
+    def simple_attention_viz(
+        self,
+        prompt: str,
+        layer: int = -1,
+        head: int = 0,
+        save_path: str = "attention_plot.png",
+        show_plot: bool = False,
+        average_heads: bool = False,
+    ) -> tuple:
         """
         Simple, reliable attention visualization that works in any Python environment.
-        
+
         Args:
             prompt: Input text prompt
             layer: Which layer to visualize (-1 for last layer)
@@ -326,183 +344,193 @@ def simple_attention_viz(self, prompt: str, layer: int = -1, head: int = 0,
             save_path: Where to save the plot image
             show_plot: Whether to try displaying plot (only works in GUI environments)
             average_heads: If True, average across all heads and normalize
-        
+
         Returns:
             tuple: (generated_text, attention_matrix)
         """
         # Check if attention viz is properly configured
-        if not (hasattr(self.generation_config, 'output_attentions') and 
-                self.generation_config.output_attentions):
+        if not (
+            hasattr(self.generation_config, "output_attentions") and self.generation_config.output_attentions
+        ):
             print("⚠️  Warning: Run setup_attention_viz() first!")
             return self.generate(prompt), None
-        
+
         # Generate with attention
         inputs = self.tokenizer(prompt, return_tensors="pt", padding=False, truncation=False).to(self.device)
         input_length = inputs["input_ids"].shape[1]
-        
+
         with torch.no_grad():
-            if hasattr(self, 'adapter_name') and self.adapter_name == "qmars":
+            if hasattr(self, "adapter_name") and self.adapter_name == "qmars":
                 with torch.cuda.amp.autocast():
                     outputs = self.model.generate(**inputs, generation_config=self.generation_config)
             else:
                 outputs = self.model.generate(**inputs, generation_config=self.generation_config)
-        
+
         # Extract results
         generated_tokens = outputs.sequences[0][input_length:]
         generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
         attentions = outputs.attentions[-1] if outputs.attentions else None
-        
+
         if attentions is None:
             print("⚠️  No attention data available")
             return generated_text, None
-        
+
         # Get tokens and handle dimension mismatch
         all_tokens = self.tokenizer.convert_ids_to_tokens(outputs.sequences[0])
         attention_seq_len = attentions[0].shape[-1]
-        
+
         if len(all_tokens) > attention_seq_len:
             all_tokens = all_tokens[:attention_seq_len]
             print(f"✓ Adjusted tokens to match attention dimensions ({attention_seq_len})")
-        
+
         # Extract specific layer
         if layer < 0:
             layer = len(attentions) + layer  # Convert negative indexing
-        
+
         # Get attention matrix - either single head or averaged across all heads
         if average_heads:
             # Average across all heads: shape [batch, heads, seq_len, seq_len] -> [seq_len, seq_len]
             attention_matrix = attentions[layer][0].mean(dim=0).cpu().numpy()  # Average over head dimension
             print(f"✓ Averaged across {attentions[layer][0].shape[0]} attention heads")
-            
+
             # Normalize the averaged attention matrix
             attention_matrix = attention_matrix / attention_matrix.sum(axis=1, keepdims=True)
-            print(f"✓ Normalized attention weights (each row sums to 1)")
+            print("✓ Normalized attention weights (each row sums to 1)")
         else:
             # Single head
             attention_matrix = attentions[layer][0][head].cpu().numpy()  # [seq_len, seq_len]
-        
+
         # Create visualization
         import matplotlib
-        matplotlib.use('Agg')  # Use non-GUI backend
+
+        matplotlib.use("Agg")  # Use non-GUI backend
         import matplotlib.pyplot as plt
-        import numpy as np
-        
+
         # For long sequences, focus on the end where the decision happens
 
         display_tokens = all_tokens
-        
+
         # Clean tokens for display
         clean_tokens = []
         for token in display_tokens:
             # Clean up token representation
-            clean_token = token.replace('▁', '').replace('<0x0A>', '\\n').replace('<s>', '[START]')
+            clean_token = token.replace("▁", "").replace("<0x0A>", "\\n").replace("<s>", "[START]")
             if len(clean_token) == 0:
-                clean_token = '_'
+                clean_token = "_"
             elif len(clean_token) > 6:
-                clean_token = clean_token[:6] + '...'
+                clean_token = clean_token[:6] + "..."
             clean_tokens.append(clean_token)
-        
+
         # Create the plot
         plt.figure(figsize=(14, 10))
-        
+
         # Main attention heatmap with viridis colormap
-        im = plt.imshow(attention_matrix, cmap='viridis', interpolation='nearest')
-        plt.colorbar(im, label='Attention Weight')
-        
+        im = plt.imshow(attention_matrix, cmap="viridis", interpolation="nearest")
+        plt.colorbar(im, label="Attention Weight")
+
         # Labels and ticks
-        plt.xticks(range(len(clean_tokens)), clean_tokens, rotation=45, ha='right', fontsize=8)
+        plt.xticks(range(len(clean_tokens)), clean_tokens, rotation=45, ha="right", fontsize=8)
         plt.yticks(range(len(clean_tokens)), clean_tokens, fontsize=8)
-        
+
         # Title with results
-        head_info = f"Averaged across all heads" if average_heads else f"Head {head}"
+        head_info = "Averaged across all heads" if average_heads else f"Head {head}"
         normalization_info = " (Normalized)" if average_heads else ""
-        plt.title(f'Attention Pattern (Layer {layer}, {head_info}){normalization_info}\n'
-                 f'Generated: "{generated_text}"\n'
-                 f'Last {len(clean_tokens)} tokens', fontsize=12, pad=20)
-        
+        plt.title(
+            f"Attention Pattern (Layer {layer}, {head_info}){normalization_info}\n"
+            f'Generated: "{generated_text}"\n'
+            f"Last {len(clean_tokens)} tokens",
+            fontsize=12,
+            pad=20,
+        )
+
         # Labels
-        plt.xlabel('Attended To (Keys)', fontsize=10)
-        plt.ylabel('Attending From (Queries)', fontsize=10)
-        
+        plt.xlabel("Attended To (Keys)", fontsize=10)
+        plt.ylabel("Attending From (Queries)", fontsize=10)
+
         plt.tight_layout()
-        
+
         # Save the plot
-        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
         print(f"✅ Attention plot saved to: {save_path}")
-        
+
         # Try to show if requested (only works in GUI environments)
         if show_plot:
             try:
                 plt.show()
             except:
                 print("⚠️  Cannot display plot in this environment, but image saved successfully")
-        
+
         plt.close()  # Close figure to free memory
-        
-        print(f"✓ Attention visualization complete!")
+
+        print("✓ Attention visualization complete!")
         print(f"📊 Generated answer: '{generated_text}'")
         if average_heads:
-            print(f"📈 Averaged and normalized across all attention heads")
+            print("📈 Averaged and normalized across all attention heads")
         else:
             print(f"🎯 Showing attention head {head}")
         print(f"📁 Open {save_path} to view the attention heatmap")
-        
+
         return generated_text, attention_matrix
- 
-    def analyze_final_decision(self, prompt: str, layer: int = -1, 
-                              save_path: str = "decision_analysis.png", 
-                              average_heads: bool = True) -> tuple:
+
+    def analyze_final_decision(
+        self,
+        prompt: str,
+        layer: int = -1,
+        save_path: str = "decision_analysis.png",
+        average_heads: bool = True,
+    ) -> tuple:
         """
         Focus ONLY on what influenced the final token generation decision.
         Shows which tokens the model paid attention to when making its final choice.
-        
+
         Args:
             prompt: Input text prompt
             layer: Which layer to analyze (-1 for last layer)
             save_path: Where to save the plot
             average_heads: If True, average across all heads
-        
+
         Returns:
             tuple: (generated_text, final_attention_weights, top_influences)
         """
         # Check setup
-        if not (hasattr(self.generation_config, 'output_attentions') and 
-                self.generation_config.output_attentions):
+        if not (
+            hasattr(self.generation_config, "output_attentions") and self.generation_config.output_attentions
+        ):
             print("⚠️  Warning: Run setup_attention_viz() first!")
             return self.generate(prompt), None, None
-        
+
         # Generate with attention
         inputs = self.tokenizer(prompt, return_tensors="pt", padding=False, truncation=False).to(self.device)
         input_length = inputs["input_ids"].shape[1]
-        
+
         with torch.no_grad():
-            if hasattr(self, 'adapter_name') and self.adapter_name == "qmars":
+            if hasattr(self, "adapter_name") and self.adapter_name == "qmars":
                 with torch.cuda.amp.autocast():
                     outputs = self.model.generate(**inputs, generation_config=self.generation_config)
             else:
                 outputs = self.model.generate(**inputs, generation_config=self.generation_config)
-        
+
         # Extract results
         generated_tokens = outputs.sequences[0][input_length:]
         generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
         attentions = outputs.attentions[-1] if outputs.attentions else None
-        
+
         if attentions is None:
             print("⚠️  No attention data available")
             return generated_text, None, None
-        
+
         # Get tokens and handle dimension mismatch
         all_tokens = self.tokenizer.convert_ids_to_tokens(outputs.sequences[0])
         attention_seq_len = attentions[0].shape[-1]
-        
+
         if len(all_tokens) > attention_seq_len:
             all_tokens = all_tokens[:attention_seq_len]
             print(f"✓ Adjusted tokens to match attention dimensions ({attention_seq_len})")
-        
+
         # Extract specific layer
         if layer < 0:
             layer = len(attentions) + layer
-        
+
         # Get attention matrix and focus ONLY on the last row (final decision)
         if average_heads:
             # Average across all heads: [heads, seq_len, seq_len] -> [seq_len, seq_len]
@@ -510,224 +538,251 @@ def analyze_final_decision(self, prompt: str, layer: int = -1,
             print(f"✓ Averaged across {attentions[layer][0].shape[0]} attention heads")
         else:
             attention_matrix = attentions[layer][0][0].cpu().numpy()  # Just first head
-        
+
         # Extract ONLY the last row - this shows what influenced the final decision
         final_attention = attention_matrix[-1, :]  # Shape: [seq_len]
-        
+
         # Clean tokens for display
         clean_tokens = []
         for token in all_tokens:
-            clean_token = token.replace('▁', '').replace('<0x0A>', '\\n').replace('<s>', '[START]')
+            clean_token = token.replace("▁", "").replace("<0x0A>", "\\n").replace("<s>", "[START]")
             if len(clean_token) == 0:
-                clean_token = '_'
+                clean_token = "_"
             clean_tokens.append(clean_token)
-        
+
         # Find top influences
         top_indices = final_attention.argsort()[-10:][::-1]  # Top 10 most attended tokens
         top_influences = [(clean_tokens[i], final_attention[i]) for i in top_indices if i < len(clean_tokens)]
-        
+
         # Create visualization
         import matplotlib
-        matplotlib.use('Agg')
+
+        matplotlib.use("Agg")
         import matplotlib.pyplot as plt
         import numpy as np
-        
+
         # Create bar chart showing what influenced the final decision
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 10))
-        
+
         # Top plot: Bar chart of attention weights
         tokens_display = [t[:12] for t, w in top_influences]  # Truncate long tokens
         weights = [w for t, w in top_influences]
-        
+
         # Create color gradient using viridis colormap
         colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(weights)))
         bars = ax1.bar(range(len(tokens_display)), weights, color=colors)
-        ax1.set_xlabel('Tokens', fontsize=12)
-        ax1.set_ylabel('Attention Weight', fontsize=12)
-        ax1.set_title(f'What Influenced the Final Decision: "{generated_text}"\n'
-                     f'Top {len(top_influences)} Most Attended Tokens (Layer {layer})', fontsize=14, pad=20)
+        ax1.set_xlabel("Tokens", fontsize=12)
+        ax1.set_ylabel("Attention Weight", fontsize=12)
+        ax1.set_title(
+            f'What Influenced the Final Decision: "{generated_text}"\n'
+            f"Top {len(top_influences)} Most Attended Tokens (Layer {layer})",
+            fontsize=14,
+            pad=20,
+        )
         ax1.set_xticks(range(len(tokens_display)))
-        ax1.set_xticklabels(tokens_display, rotation=45, ha='right')
-        
+        ax1.set_xticklabels(tokens_display, rotation=45, ha="right")
+
         # Add value labels on bars
         for i, (bar, weight) in enumerate(zip(bars, weights)):
-            ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.001,
-                    f'{weight:.3f}', ha='center', va='bottom', fontsize=10)
-        
+            ax1.text(
+                bar.get_x() + bar.get_width() / 2,
+                bar.get_height() + 0.001,
+                f"{weight:.3f}",
+                ha="center",
+                va="bottom",
+                fontsize=10,
+            )
+
         # Bottom plot: Full attention sequence as line plot
-        ax2.plot(range(len(final_attention)), final_attention, color='darkgreen', linewidth=2)
-        ax2.fill_between(range(len(final_attention)), final_attention, alpha=0.3, color='lightgreen')
-        ax2.set_xlabel('Token Position', fontsize=12)
-        ax2.set_ylabel('Attention Weight', fontsize=12)
-        ax2.set_title('Full Attention Pattern for Final Token Generation', fontsize=12)
+        ax2.plot(range(len(final_attention)), final_attention, color="darkgreen", linewidth=2)
+        ax2.fill_between(range(len(final_attention)), final_attention, alpha=0.3, color="lightgreen")
+        ax2.set_xlabel("Token Position", fontsize=12)
+        ax2.set_ylabel("Attention Weight", fontsize=12)
+        ax2.set_title("Full Attention Pattern for Final Token Generation", fontsize=12)
         ax2.grid(True, alpha=0.3)
-        
+
         # Highlight top attention positions
         for i in top_indices[:5]:  # Highlight top 5
             if i < len(final_attention):
-                ax2.scatter(i, final_attention[i], color='red', s=50, zorder=5)
-        
+                ax2.scatter(i, final_attention[i], color="red", s=50, zorder=5)
+
         plt.tight_layout()
-        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
         plt.close()
-        
+
         # Print analysis
-        print(f"\n🎯 FINAL DECISION ANALYSIS")
+        print("\n🎯 FINAL DECISION ANALYSIS")
         print(f"Generated Token: '{generated_text}'")
-        print(f"{'='*50}")
-        print(f"📊 TOP INFLUENCES (what the model focused on):")
-        
+        print(f"{'=' * 50}")
+        print("📊 TOP INFLUENCES (what the model focused on):")
+
         for i, (token, weight) in enumerate(top_influences[:5], 1):
             percentage = weight * 100
             print(f"  {i}. '{token}' → {weight:.4f} ({percentage:.1f}%)")
-        
-        print(f"\n💡 INTERPRETATION:")
-        question_tokens = [t for t, w in top_influences[:5] if any(keyword in t.lower() 
-                          for keyword in ['france', 'capital', 'paris', 'london', 'berlin', 'rome'])]
+
+        print("\n💡 INTERPRETATION:")
+        question_tokens = [
+            t
+            for t, w in top_influences[:5]
+            if any(
+                keyword in t.lower() for keyword in ["france", "capital", "paris", "london", "berlin", "rome"]
+            )
+        ]
         if question_tokens:
             print(f"  ✓ Model focused on relevant tokens: {question_tokens}")
         else:
-            print(f"  ⚠️  Model attention might be on structural tokens")
-        
+            print("  ⚠️  Model attention might be on structural tokens")
+
         print(f"📁 Detailed visualization saved to: {save_path}")
-        
+
         return generated_text, final_attention, top_influences
-    
-    def analyze_prediction_probabilities(self, prompt: str, top_k: int = 20, 
-                                       save_path: str = "prediction_probs.png") -> dict:
+
+    def analyze_prediction_probabilities(
+        self, prompt: str, top_k: int = 20, save_path: str = "prediction_probs.png"
+    ) -> dict:
         """
         Analyze the language model head predictions - what tokens were most likely to be generated.
         Shows the final softmax probabilities for top-k tokens.
-        
+
         Args:
             prompt: Input text prompt
             top_k: Number of top predictions to show
             save_path: Where to save the probability plot
-        
+
         Returns:
             dict: Prediction analysis with probabilities and tokens
         """
         print(f"🔍 Analyzing LM head predictions for top-{top_k} tokens...")
-        
+
         # Prepare inputs
         inputs = self.tokenizer(prompt, return_tensors="pt", padding=False, truncation=False).to(self.device)
         input_length = inputs["input_ids"].shape[1]
-        
+
         with torch.no_grad():
             # Get model outputs with logits
-            if hasattr(self, 'adapter_name') and self.adapter_name == "qmars":
+            if hasattr(self, "adapter_name") and self.adapter_name == "qmars":
                 with torch.cuda.amp.autocast():
                     outputs = self.model(**inputs)
             else:
                 outputs = self.model(**inputs)
-        
+
         # Get logits for the last token (next token prediction)
         logits = outputs.logits[0, -1, :]  # Shape: [vocab_size]
-        
+
         # Apply softmax to get probabilities
         probabilities = torch.softmax(logits, dim=-1)
-        
+
         # Get top-k predictions
         top_probs, top_indices = torch.topk(probabilities, top_k)
-        
+
         # Convert to tokens
         top_tokens = [self.tokenizer.decode(idx.item()) for idx in top_indices]
         top_probs_list = top_probs.cpu().numpy()
-        
+
         # Also generate the actual prediction for comparison
         with torch.no_grad():
-            if hasattr(self, 'adapter_name') and self.adapter_name == "qmars":
+            if hasattr(self, "adapter_name") and self.adapter_name == "qmars":
                 with torch.cuda.amp.autocast():
                     generated = self.model.generate(**inputs, generation_config=self.generation_config)
             else:
                 generated = self.model.generate(**inputs, generation_config=self.generation_config)
-        
+
         # Extract the newly generated token (not the whole sequence)
         actual_token_id = generated[0][input_length].item()  # First new token after input
         actual_text = self.tokenizer.decode(actual_token_id)
         actual_prob = probabilities[actual_token_id].item()
-        
+
         # Create visualization
         import matplotlib
-        matplotlib.use('Agg')
+
+        matplotlib.use("Agg")
         import matplotlib.pyplot as plt
         import numpy as np
-        
+
         # Clean tokens for display
         clean_tokens = []
         for token in top_tokens:
-            clean_token = token.replace('▁', '').replace('<0x0A>', '\\n').replace(' ', '_')
+            clean_token = token.replace("▁", "").replace("<0x0A>", "\\n").replace(" ", "_")
             if len(clean_token) == 0:
-                clean_token = '[SPACE]'
+                clean_token = "[SPACE]"
             elif len(clean_token) > 10:
-                clean_token = clean_token[:10] + '...'
+                clean_token = clean_token[:10] + "..."
             clean_tokens.append(clean_token)
-        
+
         # Create the plot
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 12))
-        
+
         # Top plot: Bar chart of top predictions
         colors = plt.cm.viridis(np.linspace(0.2, 0.9, len(clean_tokens)))
         bars = ax1.barh(range(len(clean_tokens)), top_probs_list, color=colors)
-        
+
         # Highlight the actual prediction if it's in top-k
         actual_in_topk = actual_text in top_tokens
         if actual_in_topk:
             actual_idx = top_tokens.index(actual_text)
-            bars[actual_idx].set_color('red')
+            bars[actual_idx].set_color("red")
             bars[actual_idx].set_alpha(0.8)
-        
+
         ax1.set_yticks(range(len(clean_tokens)))
         ax1.set_yticklabels(clean_tokens)
-        ax1.set_xlabel('Probability', fontsize=12)
-        ax1.set_title(f'Top {top_k} Token Predictions from Language Model Head\n'
-                     f'Actual Generated: "{actual_text}" (prob: {actual_prob:.4f})', 
-                     fontsize=14, pad=20)
-        
+        ax1.set_xlabel("Probability", fontsize=12)
+        ax1.set_title(
+            f"Top {top_k} Token Predictions from Language Model Head\n"
+            f'Actual Generated: "{actual_text}" (prob: {actual_prob:.4f})',
+            fontsize=14,
+            pad=20,
+        )
+
         # Add probability labels on bars
         for i, (bar, prob) in enumerate(zip(bars, top_probs_list)):
-            ax1.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2,
-                    f'{prob:.4f}', ha='left', va='center', fontsize=9)
-        
-        ax1.grid(True, alpha=0.3, axis='x')
+            ax1.text(
+                bar.get_width() + 0.001,
+                bar.get_y() + bar.get_height() / 2,
+                f"{prob:.4f}",
+                ha="left",
+                va="center",
+                fontsize=9,
+            )
+
+        ax1.grid(True, alpha=0.3, axis="x")
         ax1.set_xlim(0, max(top_probs_list) * 1.15)
-        
+
         # Bottom plot: Probability distribution (log scale for better visualization)
         log_probs = np.log10(top_probs_list + 1e-10)  # Add small value to avoid log(0)
         ax2.bar(range(len(clean_tokens)), log_probs, color=colors, alpha=0.7)
         ax2.set_xticks(range(len(clean_tokens)))
-        ax2.set_xticklabels(clean_tokens, rotation=45, ha='right')
-        ax2.set_ylabel('Log₁₀(Probability)', fontsize=12)
-        ax2.set_title('Log Scale View (better for low probabilities)', fontsize=12)
+        ax2.set_xticklabels(clean_tokens, rotation=45, ha="right")
+        ax2.set_ylabel("Log₁₀(Probability)", fontsize=12)
+        ax2.set_title("Log Scale View (better for low probabilities)", fontsize=12)
         ax2.grid(True, alpha=0.3)
-        
+
         plt.tight_layout()
-        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
         plt.close()
-        
+
         # Print detailed analysis
-        print(f"\n🎯 LANGUAGE MODEL HEAD ANALYSIS")
+        print("\n🎯 LANGUAGE MODEL HEAD ANALYSIS")
         print(f"Prompt: '{prompt}'")
-        print(f"{'='*60}")
+        print(f"{'=' * 60}")
         print(f"📊 TOP {min(10, top_k)} PREDICTIONS:")
-        
+
         for i, (token, prob) in enumerate(zip(top_tokens[:10], top_probs_list[:10]), 1):
             percentage = prob * 100
             indicator = " ← GENERATED" if token == actual_text else ""
             print(f"  {i:2d}. '{token}' → {prob:.6f} ({percentage:.2f}%){indicator}")
-        
-        print(f"\n💡 ANALYSIS:")
-        print(f"  ✓ Model confidence: {top_probs_list[0]*100:.2f}% for top choice")
+
+        print("\n💡 ANALYSIS:")
+        print(f"  ✓ Model confidence: {top_probs_list[0] * 100:.2f}% for top choice")
         print(f"  ✓ Entropy: {-np.sum(top_probs_list * np.log2(top_probs_list + 1e-10)):.3f} bits")
-        
+
         if actual_in_topk:
             actual_rank = top_tokens.index(actual_text) + 1
             print(f"  ✓ Generated token rank: #{actual_rank} of {top_k}")
         else:
             print(f"  ⚠️  Generated token not in top-{top_k} predictions!")
-        
+
         print(f"📁 Detailed visualization saved to: {save_path}")
-        
+
         # Return comprehensive results
         results = {
             "prompt": prompt,
@@ -735,12 +790,12 @@ def analyze_prediction_probabilities(self, prompt: str, top_k: int = 20,
             "actual_probability": actual_prob,
             "actual_rank": top_tokens.index(actual_text) + 1 if actual_in_topk else None,
             "top_predictions": [
-                {"token": token, "probability": float(prob), "rank": i+1}
+                {"token": token, "probability": float(prob), "rank": i + 1}
                 for i, (token, prob) in enumerate(zip(top_tokens, top_probs_list))
             ],
             "model_confidence": float(top_probs_list[0]),
             "entropy": float(-np.sum(top_probs_list * np.log2(top_probs_list + 1e-10))),
-            "top_k": top_k
+            "top_k": top_k,
         }
-        
-        return results
\ No newline at end of file
+
+        return results
diff --git a/evaluation/eval_adapter_onnx_model.py b/src/mobiletransformers/evaluation/eval_adapter_onnx_model.py
similarity index 84%
rename from evaluation/eval_adapter_onnx_model.py
rename to src/mobiletransformers/evaluation/eval_adapter_onnx_model.py
index 48518b7..76646a8 100644
--- a/evaluation/eval_adapter_onnx_model.py
+++ b/src/mobiletransformers/evaluation/eval_adapter_onnx_model.py
@@ -2,19 +2,21 @@
 DEEPEVAL Adapter for loading PEFT ONNX models and performing inference for evaluation.
 """
 
-from transformers import AutoTokenizer
 from deepeval.models import DeepEvalBaseLLM
-from inference.validator import ORTransformerGenerator
+from transformers import AutoTokenizer
+
+from mobiletransformers.artifacts.validation import MobileTransformerGenerator
+
 
 class CustomPeftONNXModel(DeepEvalBaseLLM):
     def __init__(self, model_id, model_name, model_dir, load_merged_weights=False, merged_weights_dir=None):
 
-        self.model = ORTransformerGenerator(
+        self.model = MobileTransformerGenerator(
             model_id=model_id,
-            model_name=model_name, 
+            model_name=model_name,
             model_dir=model_dir,
             load_merged_weights=load_merged_weights,
-            merged_weights_dir=merged_weights_dir
+            merged_weights_dir=merged_weights_dir,
         )
 
         # Set tokenizer
@@ -27,11 +29,11 @@ def __init__(self, model_id, model_name, model_dir, load_merged_weights=False, m
     def set_generation_config(self, early_stopping=True, max_new_tokens=20):
         """Set generation configuration parameters."""
         self.max_new_tokens = max_new_tokens
-    
+
     def load_model(self):
         """Return the loaded model."""
         return self.model
-    
+
     def generate(self, prompt: str) -> str:
         """
         Generates a response from the model using text-generation pipeline.
@@ -40,11 +42,11 @@ def generate(self, prompt: str) -> str:
         output = self.model.generate(prompt, self.max_new_tokens)
 
         return output.strip()
-    
+
     async def a_generate(self, prompt: str) -> str:
         """Async version of generate."""
         return self.generate(prompt)
-    
+
     def get_model_name(self):
         """Return the model name."""
-        return self.name
\ No newline at end of file
+        return self.name
diff --git a/src/mobiletransformers/evaluation/mobile/__init__.py b/src/mobiletransformers/evaluation/mobile/__init__.py
new file mode 100644
index 0000000..488d70b
--- /dev/null
+++ b/src/mobiletransformers/evaluation/mobile/__init__.py
@@ -0,0 +1 @@
+"""On-device evaluators (S8). See the package docstring in the parent module."""
diff --git a/src/mobiletransformers/evaluation/mobile/base_mobile_eval.py b/src/mobiletransformers/evaluation/mobile/base_mobile_eval.py
new file mode 100644
index 0000000..6e2e449
--- /dev/null
+++ b/src/mobiletransformers/evaluation/mobile/base_mobile_eval.py
@@ -0,0 +1,96 @@
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.mobile_evaluator import MobileEvaluator
+
+MINI_PERSONAL_QA_EXAMPLES = [
+    {
+        "type": "train",
+        "category": "App Usage",
+        "question": "What specific method is used by news apps to send me updates?",
+        "choices": {
+            "A": "Push notifications",
+            "B": "Sending a letter",
+            "C": "A town crier",
+            "D": "Email newsletters",
+        },
+        "correct_answer": "A",
+    },
+    {
+        "type": "train",
+        "category": "Communication & Social",
+        "question": "The text thread with my old college buddies is always buzzing with new messages. Which of my social circles has a particularly lively group chat?",
+        "choices": {
+            "A": "My coworkers",
+            "B": "My college friends",
+            "C": "My high school acquaintances",
+            "D": "My family",
+        },
+        "correct_answer": "B",
+    },
+    {
+        "type": "train",
+        "category": "Location & Travel",
+        "question": "What type of route do I use for my daily commute to my job?",
+        "choices": {
+            "A": "A scenic bike path",
+            "B": "A local side street",
+            "C": "The highway",
+            "D": "A pedestrian walkway",
+        },
+        "correct_answer": "C",
+    },
+]
+
+MINI_RECOMMENDATION_EXAMPLES = [
+    {
+        "type": "train",
+        "category": "Energy Management",
+        "prompt": "I feel really tired this evening",
+        "recommendation": "Recommend early sleep, lower lighting",
+    },
+]
+
+
+def evaluate_base_mini_personalqa():
+    EVAL_DATASET = "data/MiniPersonalQA_eval.jsonl"
+    BASE_MODEL = "Qwen/Qwen2-0.5B-Instruct"
+
+    model = CustomPeftModel("", adapter_name="base", base_model=BASE_MODEL)
+
+    model.set_generation_config(max_new_tokens=10)
+
+    # Create evaluator - tokenizer is optional now
+    evaluator = MobileEvaluator(model)
+
+    # Run evaluation on JSONL file
+    results = evaluator.evaluate(
+        EVAL_DATASET,
+        verbose=True,
+        few_shot_examples=MINI_PERSONAL_QA_EXAMPLES,
+        save_results_dir=".",
+        save_outputs=True,
+    )
+
+    # Print results
+    evaluator.print_results(results)
+
+
+def evaluate_base_mini_recommendation():
+    SLM_MODEL_ID = "Qwen/Qwen2-0.5B-Instruct"
+    EVAL_DATASET = "data/MiniRecommendation_eval.jsonl"
+    TASK = "mini_recommendation"
+
+    model = CustomPeftModel("", adapter_name="base", base_model=SLM_MODEL_ID)
+
+    model.set_generation_config(max_new_tokens=128)
+
+    # Create evaluator - tokenizer is optional now
+    evaluator = MobileEvaluator(model, task=TASK)
+
+    # Run evaluation on JSONL file
+    results = evaluator.evaluate(EVAL_DATASET, verbose=True, save_outputs=True, few_shot_examples=[])
+
+    # Print results
+    evaluator.print_results(results)
+
+
+evaluate_base_mini_recommendation()
diff --git a/evaluation/mobile/mobile_eval.py b/src/mobiletransformers/evaluation/mobile/mobile_eval.py
similarity index 62%
rename from evaluation/mobile/mobile_eval.py
rename to src/mobiletransformers/evaluation/mobile/mobile_eval.py
index 2e6d86b..247277e 100644
--- a/evaluation/mobile/mobile_eval.py
+++ b/src/mobiletransformers/evaluation/mobile/mobile_eval.py
@@ -1,11 +1,13 @@
-from evaluation.mobile_evaluator import MobileEvaluator
+from mobiletransformers.evaluation.eval_adapter_models import CustomPeftModel
+from mobiletransformers.evaluation.eval_adapter_onnx_model import CustomPeftONNXModel
+from mobiletransformers.evaluation.mobile_evaluator import MobileEvaluator
 
-from evaluation.eval_adapter_models import CustomPeftModel
-from evaluation.eval_adapter_onnx_model import CustomPeftONNXModel
 
 def evaluate_finetuned():
 
-    ADAPTER_DIR = "experiment_results/TinyLlama_v1.1-mars-minipersonalqa/Qwen2-0.5B-mars-mini_personalqa-r8-a2"
+    ADAPTER_DIR = (
+        "experiment_results/TinyLlama_v1.1-mars-minipersonalqa/Qwen2-0.5B-mars-mini_personalqa-r8-a2"
+    )
     ADAPTER_NAME = "mars"
     EVAL_DATASET = "data/MiniPersonalQA_eval.jsonl"
 
@@ -22,6 +24,7 @@ def evaluate_finetuned():
     # Print results
     evaluator.print_results(results)
 
+
 def evaluate_onnx_mini_personalqa():
 
     SLM_MODEL_ID = "Qwen/Qwen2-0.5B"
@@ -33,7 +36,13 @@ def evaluate_onnx_mini_personalqa():
 
     EVAL_DATASET = "data/MiniPersonalQA_eval.jsonl"
 
-    model = CustomPeftONNXModel(SLM_MODEL_ID, SLM_MODEL_NAME, SLM_MODEL_DIR, load_merged_weights=True, merged_weights_dir=MERGED_WEIGHTS_DIR)
+    model = CustomPeftONNXModel(
+        SLM_MODEL_ID,
+        SLM_MODEL_NAME,
+        SLM_MODEL_DIR,
+        load_merged_weights=True,
+        merged_weights_dir=MERGED_WEIGHTS_DIR,
+    )
 
     model.set_generation_config(max_new_tokens=1)
 
@@ -41,11 +50,14 @@ def evaluate_onnx_mini_personalqa():
     evaluator = MobileEvaluator(model)
 
     # Run evaluation on JSONL file
-    results = evaluator.evaluate(EVAL_DATASET, verbose=True, save_results_dir=BASE_MODEL_DIR, save_outputs=True)
+    results = evaluator.evaluate(
+        EVAL_DATASET, verbose=True, save_results_dir=BASE_MODEL_DIR, save_outputs=True
+    )
 
     # Print results
     evaluator.print_results(results)
 
+
 def evaluate_onnx_mini_recommendation():
 
     SLM_MODEL_ID = "Qwen/Qwen2-0.5B"
@@ -58,7 +70,13 @@ def evaluate_onnx_mini_recommendation():
 
     BASE_MODEL_DIR = "experiment_results/train-qwen2-recommendation-mobile"
 
-    model = CustomPeftONNXModel(SLM_MODEL_ID, SLM_MODEL_NAME, SLM_MODEL_DIR, load_merged_weights=True, merged_weights_dir=MERGED_WEIGHTS_DIR)
+    model = CustomPeftONNXModel(
+        SLM_MODEL_ID,
+        SLM_MODEL_NAME,
+        SLM_MODEL_DIR,
+        load_merged_weights=True,
+        merged_weights_dir=MERGED_WEIGHTS_DIR,
+    )
 
     model.set_generation_config(max_new_tokens=128)
 
@@ -66,12 +84,13 @@ def evaluate_onnx_mini_recommendation():
     evaluator = MobileEvaluator(model, task=TASK)
 
     # Run evaluation on JSONL file
-    results = evaluator.evaluate(EVAL_DATASET, verbose=True, save_results_dir=BASE_MODEL_DIR, save_outputs=True)
+    results = evaluator.evaluate(
+        EVAL_DATASET, verbose=True, save_results_dir=BASE_MODEL_DIR, save_outputs=True
+    )
 
     # Print results
     evaluator.print_results(results)
 
 
-
-#evaluate_onnx_mini_personalqa()
-#evaluate_onnx_mini_recommendation()
\ No newline at end of file
+# evaluate_onnx_mini_personalqa()
+# evaluate_onnx_mini_recommendation()
diff --git a/evaluation/mobile/recommendation_eval.py b/src/mobiletransformers/evaluation/mobile/recommendation_eval.py
similarity index 66%
rename from evaluation/mobile/recommendation_eval.py
rename to src/mobiletransformers/evaluation/mobile/recommendation_eval.py
index f8e47f6..5d61634 100644
--- a/evaluation/mobile/recommendation_eval.py
+++ b/src/mobiletransformers/evaluation/mobile/recommendation_eval.py
@@ -1,17 +1,15 @@
 import json
 import time
-import pandas as pd
-from typing import List, Dict, Any, Tuple
 from datetime import datetime
-import statistics
+from typing import Any
+
 from deepeval import evaluate
-from deepeval.metrics import GEval, ArenaGEval
-from deepeval.test_case import LLMTestCase, LLMTestCaseParams, ArenaTestCase
+from deepeval.metrics import ArenaGEval, GEval
 from deepeval.models.base_model import DeepEvalBaseLLM
+from deepeval.test_case import ArenaTestCase, LLMTestCase, LLMTestCaseParams
 from langchain_openai import AzureChatOpenAI
 
-# Import configuration from config module
-from config import AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, AZURE_DEPLOYMENT_NAME, AZURE_MODEL_NAME, AZURE_API_VERSION
+from mobiletransformers.config.settings import get_settings
 
 
 class AzureOpenAIModel(DeepEvalBaseLLM):
@@ -19,18 +17,16 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
     Custom Azure OpenAI model implementation for DeepEval using LangChain.
     This follows the DeepEval documentation pattern for custom LLM integration.
     """
-    def __init__(self, 
-                 azure_endpoint: str,
-                 api_key: str,
-                 deployment_name: str,
-                 model_name: str,
-                 api_version: str):
+
+    def __init__(
+        self, azure_endpoint: str, api_key: str, deployment_name: str, model_name: str, api_version: str
+    ):
         self.azure_endpoint = azure_endpoint
         self.api_key = api_key
         self.deployment_name = deployment_name
         self.model_name = model_name
         self.api_version = api_version
-        
+
         # Initialize the LangChain Azure OpenAI model
         self.model = AzureChatOpenAI(
             openai_api_version=api_version,
@@ -39,21 +35,21 @@ def __init__(self,
             openai_api_key=api_key,
             temperature=0,  # Set to 0 for consistent evaluation
             max_retries=3,  # Enable retries for rate limit errors
-            request_timeout=60  # Increase timeout
+            request_timeout=60,  # Increase timeout
         )
-    
+
     def load_model(self):
         return self.model
-    
+
     def generate(self, prompt: str) -> str:
         chat_model = self.load_model()
         return chat_model.invoke(prompt).content
-    
+
     async def a_generate(self, prompt: str) -> str:
         chat_model = self.load_model()
         res = await chat_model.ainvoke(prompt)
         return res.content
-    
+
     def get_model_name(self):
         return f"Azure OpenAI {self.model_name}"
 
@@ -62,60 +58,70 @@ class RecommendationEvaluator:
     """
     A class to evaluate and compare recommendation models using DeepEval with Azure OpenAI.
     Supports comparing base and finetuned models with custom recommendation metrics.
-    
+
     The class uses Azure OpenAI for LLM-as-a-judge evaluation with custom G-Eval metrics
     specifically designed for recommendation tasks. Metrics use 0-10 scoring internally
     but normalize to 0-1 scale for final results.
     """
-    
-    def __init__(self, 
-                 azure_endpoint: str = AZURE_OPENAI_ENDPOINT,
-                 api_key: str = AZURE_OPENAI_API_KEY,
-                 deployment_name: str = AZURE_DEPLOYMENT_NAME,
-                 model_name: str = AZURE_MODEL_NAME,
-                 api_version: str = AZURE_API_VERSION):
+
+    def __init__(
+        self,
+        azure_endpoint: str | None = None,
+        api_key: str | None = None,
+        deployment_name: str | None = None,
+        model_name: str | None = None,
+        api_version: str | None = None,
+    ):
         """
-        Initialize the evaluator with Azure OpenAI configuration from config module.
-        
+        Initialize the evaluator with Azure OpenAI configuration.
+
+        Any argument left ``None`` is resolved at call time from ``Settings`` — the single owner of
+        secrets. These used to default to module-level constants imported from
+        the repo-root ``config.py`` shim, which is not part of the wheel: importing this module from
+        an installed ``mobiletransformers`` raised ``ModuleNotFoundError: config``. Resolving lazily
+        also keeps the env read out of import time.
+
         Args:
-            azure_endpoint: Azure OpenAI endpoint URL (from config)
-            api_key: Azure OpenAI API key (from config)
-            deployment_name: Azure deployment name (from config)
-            model_name: Model name (from config)
-            api_version: API version (from config)
+            azure_endpoint: Azure OpenAI endpoint URL (default: ``AZURE_OPENAI_ENDPOINT``)
+            api_key: Azure OpenAI API key (default: ``AZURE_OPENAI_API_KEY``)
+            deployment_name: Azure deployment name (default: ``AZURE_DEPLOYMENT_NAME``)
+            model_name: Model name (default: ``AZURE_MODEL_NAME``)
+            api_version: API version (default: ``AZURE_API_VERSION``)
         """
-        self.azure_endpoint = azure_endpoint
-        self.api_key = api_key
-        self.deployment_name = deployment_name
-        self.model_name = model_name
-        self.api_version = api_version
-        
-        # Initialize Azure OpenAI model for evaluation
+        settings = get_settings()
+        self.azure_endpoint = azure_endpoint or settings.azure_openai_endpoint
+        self.api_key = api_key or settings.azure_openai_api_key
+        self.deployment_name = deployment_name or settings.azure_deployment_name
+        self.model_name = model_name or settings.azure_model_name
+        self.api_version = api_version or settings.azure_api_version
+
+        # Initialize Azure OpenAI model for evaluation (resolved values, never the raw arguments —
+        # those may be None and are filled in from Settings above).
         self.evaluation_model = AzureOpenAIModel(
-            azure_endpoint=azure_endpoint,
-            api_key=api_key,
-            deployment_name=deployment_name,
-            model_name=model_name,
-            api_version=api_version
+            azure_endpoint=self.azure_endpoint,
+            api_key=self.api_key,
+            deployment_name=self.deployment_name,
+            model_name=self.model_name,
+            api_version=self.api_version,
         )
-        
+
         # Create evaluation metrics
         self.metrics = self._create_metrics()
-        
-        print(f"RecommendationEvaluator initialized with Azure OpenAI:")
+
+        print("RecommendationEvaluator initialized with Azure OpenAI:")
         print(f"  Endpoint: {azure_endpoint}")
         print(f"  Model: {model_name}")
         print(f"  Deployment: {deployment_name}")
-        
-    def _create_metrics(self) -> List[GEval]:
+
+    def _create_metrics(self) -> list[GEval]:
         """
         Create custom G-Eval metrics for recommendation evaluation.
         Uses 0-10 scoring scale which gets normalized to 0-1 later.
-        
+
         Returns:
             List of configured G-Eval metrics
         """
-        
+
         recommendation_accuracy = GEval(
             name="Recommendation_Accuracy",
             criteria="""
@@ -141,18 +147,18 @@ def _create_metrics(self) -> List[GEval]:
                 "Evaluate if the predicted answer covers the same key points as correct answer",
                 "Consider that different wording with same meaning should not be penalized",
                 "Apply penalties for unrelated content or missing major elements",
-                "Assign final score 0-10 based on accuracy, completeness, and relevance"
+                "Assign final score 0-10 based on accuracy, completeness, and relevance",
             ],
             evaluation_params=[
                 LLMTestCaseParams.INPUT,
                 LLMTestCaseParams.ACTUAL_OUTPUT,
-                LLMTestCaseParams.EXPECTED_OUTPUT
+                LLMTestCaseParams.EXPECTED_OUTPUT,
             ],
             threshold=0.7,  # Will be converted from 7/10 to 0.7/1.0
             model=self.evaluation_model,
-            async_mode=False
+            async_mode=False,
         )
-        
+
         recommendation_completeness = GEval(
             name="Recommendation_Completeness",
             criteria="""
@@ -177,18 +183,18 @@ def _create_metrics(self) -> List[GEval]:
                 "Identify any missing key recommendations or important details",
                 "Calculate coverage percentage of important elements",
                 "Consider if omissions would significantly impact user value",
-                "Score based on coverage completeness and thoroughness"
+                "Score based on coverage completeness and thoroughness",
             ],
             evaluation_params=[
                 LLMTestCaseParams.INPUT,
                 LLMTestCaseParams.ACTUAL_OUTPUT,
-                LLMTestCaseParams.EXPECTED_OUTPUT
+                LLMTestCaseParams.EXPECTED_OUTPUT,
             ],
             threshold=0.6,  # Will be converted from 6/10 to 0.6/1.0
             model=self.evaluation_model,
-            async_mode=False
+            async_mode=False,
         )
-        
+
         recommendation_relevance = GEval(
             name="Recommendation_Relevance",
             criteria="""
@@ -213,24 +219,24 @@ def _create_metrics(self) -> List[GEval]:
                 "Assess if the model understood the specific recommendation scenario",
                 "Verify recommendations are actionable and useful for the user",
                 "Consider if recommendations show good understanding of user intent",
-                "Score based on relevance, appropriateness, and contextual fit"
+                "Score based on relevance, appropriateness, and contextual fit",
             ],
             evaluation_params=[
                 LLMTestCaseParams.INPUT,
                 LLMTestCaseParams.ACTUAL_OUTPUT,
-                LLMTestCaseParams.EXPECTED_OUTPUT
+                LLMTestCaseParams.EXPECTED_OUTPUT,
             ],
             threshold=0.7,  # Will be converted from 7/10 to 0.7/1.0
             model=self.evaluation_model,
-            async_mode=False
+            async_mode=False,
         )
-        
+
         return [recommendation_accuracy, recommendation_completeness, recommendation_relevance]
-    
-    def load_data(self, base_json_path: str, finetuned_json_path: str) -> Tuple[List[Dict], List[Dict]]:
+
+    def load_data(self, base_json_path: str, finetuned_json_path: str) -> tuple[list[dict], list[dict]]:
         """
         Load data from both JSON files and ensure they match.
-        
+
         Expected JSON structure:
         [
             {
@@ -241,75 +247,75 @@ def load_data(self, base_json_path: str, finetuned_json_path: str) -> Tuple[List
             },
             ...
         ]
-        
+
         Args:
             base_json_path: Path to base model responses JSON
             finetuned_json_path: Path to finetuned model responses JSON
-            
+
         Returns:
             Tuple of (base_data, finetuned_data) lists with matching sample_ids
         """
-        print(f"Loading data from:")
+        print("Loading data from:")
         print(f"  Base model: {base_json_path}")
         print(f"  Finetuned model: {finetuned_json_path}")
-        
-        with open(base_json_path, 'r', encoding='utf-8') as f:
+
+        with open(base_json_path, encoding="utf-8") as f:
             base_data = json.load(f)
-        
-        with open(finetuned_json_path, 'r', encoding='utf-8') as f:
+
+        with open(finetuned_json_path, encoding="utf-8") as f:
             finetuned_data = json.load(f)
-            
+
         print(f"Loaded {len(base_data)} base samples and {len(finetuned_data)} finetuned samples")
-        
+
         # Ensure both datasets have the same sample_ids
-        base_ids = {item['sample_id'] for item in base_data}
-        finetuned_ids = {item['sample_id'] for item in finetuned_data}
-        
+        base_ids = {item["sample_id"] for item in base_data}
+        finetuned_ids = {item["sample_id"] for item in finetuned_data}
+
         if base_ids != finetuned_ids:
-            print(f"Warning: Sample ID mismatch detected!")
+            print("Warning: Sample ID mismatch detected!")
             print(f"  Base model samples: {len(base_ids)}")
             print(f"  Finetuned model samples: {len(finetuned_ids)}")
-            
+
             common_ids = base_ids.intersection(finetuned_ids)
             missing_in_base = finetuned_ids - base_ids
             missing_in_finetuned = base_ids - finetuned_ids
-            
+
             if missing_in_base:
                 print(f"  Missing in base: {sorted(list(missing_in_base))}")
             if missing_in_finetuned:
                 print(f"  Missing in finetuned: {sorted(list(missing_in_finetuned))}")
-            
+
             print(f"  Using {len(common_ids)} common samples for evaluation")
-            
-            base_data = [item for item in base_data if item['sample_id'] in common_ids]
-            finetuned_data = [item for item in finetuned_data if item['sample_id'] in common_ids]
-        
+
+            base_data = [item for item in base_data if item["sample_id"] in common_ids]
+            finetuned_data = [item for item in finetuned_data if item["sample_id"] in common_ids]
+
         # Sort by sample_id to ensure matching order
-        base_data.sort(key=lambda x: x['sample_id'])
-        finetuned_data.sort(key=lambda x: x['sample_id'])
-        
+        base_data.sort(key=lambda x: x["sample_id"])
+        finetuned_data.sort(key=lambda x: x["sample_id"])
+
         print(f"Final dataset: {len(base_data)} matched samples")
         return base_data, finetuned_data
-    
-    def _normalize_scores(self, evaluation_results) -> List[Dict]:
+
+    def _normalize_scores(self, evaluation_results) -> list[dict]:
         """
         Normalize scores from 0-10 scale to 0-1 scale and extract results.
-        
+
         Args:
             evaluation_results: DeepEval evaluation results
-            
+
         Returns:
             List of normalized result dictionaries
         """
         normalized_results = []
-        
+
         for result in evaluation_results.test_results:
             normalized_metrics = {}
-            
+
             # Use metrics_data instead of metrics_metadata
             for metric_data in result.metrics_data:
                 metric_name = metric_data.name
-                
+
                 # Normalize score from 0-10 to 0-1, but handle cases where score might already be 0-1
                 if metric_data.score <= 1.0:
                     # Score is already normalized (0-1)
@@ -317,213 +323,222 @@ def _normalize_scores(self, evaluation_results) -> List[Dict]:
                 else:
                     # Score is on 0-10 scale, normalize to 0-1
                     normalized_score = metric_data.score / 10.0
-                
+
                 # Determine threshold for this metric
                 metric_threshold = 0.7  # default
                 for metric in self.metrics:
                     if metric.name == metric_name:
                         metric_threshold = metric.threshold
                         break
-                
+
                 normalized_metrics[metric_name] = {
-                    'score': round(normalized_score, 3),
-                    'raw_score': metric_data.score,
-                    'reason': metric_data.reason,
-                    'success': normalized_score >= metric_threshold
+                    "score": round(normalized_score, 3),
+                    "raw_score": metric_data.score,
+                    "reason": metric_data.reason,
+                    "success": normalized_score >= metric_threshold,
                 }
-            
-            normalized_results.append({
-                'input': result.input,
-                'actual_output': result.actual_output,
-                'expected_output': result.expected_output,
-                'metrics': normalized_metrics
-            })
-        
+
+            normalized_results.append(
+                {
+                    "input": result.input,
+                    "actual_output": result.actual_output,
+                    "expected_output": result.expected_output,
+                    "metrics": normalized_metrics,
+                }
+            )
+
         return normalized_results
-    
-    def evaluate_model(self, data: List[Dict], model_name: str) -> List[Dict]:
+
+    def evaluate_model(self, data: list[dict], model_name: str) -> list[dict]:
         """
         Evaluate a single model's responses using all metrics.
-        
+
         Args:
             data: List of evaluation samples with required fields
             model_name: Name of the model being evaluated (for logging)
-            
+
         Returns:
             List of normalized evaluation results
         """
         print(f"\nEvaluating {model_name} model...")
         print(f"  Samples: {len(data)}")
         print(f"  Metrics: {len(self.metrics)}")
-        
+
         # Create test cases
         test_cases = []
         for item in data:
             test_case = LLMTestCase(
-                input=item['input_question'],
-                actual_output=item['predicted_answer'],
-                expected_output=item['correct_answer']
+                input=item["input_question"],
+                actual_output=item["predicted_answer"],
+                expected_output=item["correct_answer"],
             )
             test_cases.append(test_case)
-        
-        print(f"  Running evaluation with Azure OpenAI...")
-        
+
+        print("  Running evaluation with Azure OpenAI...")
+
         # Run evaluation
         evaluation_results = evaluate(
             test_cases=test_cases,
             metrics=self.metrics,
             print_results=False,  # We'll handle our own reporting
             run_async=False,
-            max_concurrent=2
+            max_concurrent=2,
         )
-        
+
         # Normalize scores from 0-10 to 0-1
         normalized_results = self._normalize_scores(evaluation_results)
-        
+
         # Add sample_id back to results for tracking
         for i, result in enumerate(normalized_results):
-            result['sample_id'] = data[i]['sample_id']
-        
+            result["sample_id"] = data[i]["sample_id"]
+
         print(f"  ✓ Evaluation complete for {model_name} model")
         return normalized_results
-    
-    def compare_models(self, base_json_path: str, finetuned_json_path: str) -> Dict[str, Any]:
+
+    def compare_models(self, base_json_path: str, finetuned_json_path: str) -> dict[str, Any]:
         """
         Compare base and finetuned models and return comprehensive results.
-        
+
         Args:
             base_json_path: Path to base model responses JSON
             finetuned_json_path: Path to finetuned model responses JSON
-            
+
         Returns:
             Dictionary containing all evaluation results and detailed comparisons
         """
-        print("="*80)
+        print("=" * 80)
         print("STARTING MODEL COMPARISON EVALUATION")
-        print("="*80)
-        
+        print("=" * 80)
+
         # Load and validate data
         base_data, finetuned_data = self.load_data(base_json_path, finetuned_json_path)
-        
+
         if len(base_data) == 0:
             raise ValueError("No matching samples found between base and finetuned datasets")
-        
+
         # Evaluate both models
         base_results = self.evaluate_model(base_data, "Base")
         finetuned_results = self.evaluate_model(finetuned_data, "Finetuned")
-        
+
         # Calculate detailed comparison statistics
         print("\nCalculating comparison statistics...")
         comparison_stats = self._calculate_comparison_stats(base_results, finetuned_results)
-        
+
         # Prepare comprehensive final results
         final_results = {
-            'evaluation_metadata': {
-                'timestamp': datetime.now().isoformat(),
-                'total_samples': len(base_data),
-                'metrics_used': [metric.name for metric in self.metrics],
-                'evaluation_model': self.evaluation_model.get_model_name(),
-                'azure_endpoint': self.azure_endpoint,
-                'deployment_name': self.deployment_name,
-                'thresholds': {metric.name: metric.threshold for metric in self.metrics}
+            "evaluation_metadata": {
+                "timestamp": datetime.now().isoformat(),
+                "total_samples": len(base_data),
+                "metrics_used": [metric.name for metric in self.metrics],
+                "evaluation_model": self.evaluation_model.get_model_name(),
+                "azure_endpoint": self.azure_endpoint,
+                "deployment_name": self.deployment_name,
+                "thresholds": {metric.name: metric.threshold for metric in self.metrics},
             },
-            'base_model_results': base_results,
-            'finetuned_model_results': finetuned_results,
-            'comparison_statistics': comparison_stats
+            "base_model_results": base_results,
+            "finetuned_model_results": finetuned_results,
+            "comparison_statistics": comparison_stats,
         }
-        
+
         print("✓ Evaluation complete!")
         return final_results
-    
-    def _calculate_comparison_stats(self, base_results: List[Dict], finetuned_results: List[Dict]) -> Dict[str, Any]:
+
+    def _calculate_comparison_stats(
+        self, base_results: list[dict], finetuned_results: list[dict]
+    ) -> dict[str, Any]:
         """
         Calculate simple comparison statistics between models - focusing on accuracy only.
-        
+
         Args:
             base_results: Evaluation results for base model
             finetuned_results: Evaluation results for finetuned model
-            
+
         Returns:
             Dictionary with simplified comparison statistics
         """
         stats = {}
-        
+
         # Get available metric names from the actual results
         if not base_results or not finetuned_results:
-            return {'error': 'No results to compare'}
-        
-        available_metrics = list(base_results[0]['metrics'].keys())
+            return {"error": "No results to compare"}
+
+        available_metrics = list(base_results[0]["metrics"].keys())
         print(f"Available metrics: {available_metrics}")
-        
+
         # Calculate stats for each available metric
         for metric_name in available_metrics:
             try:
                 # Extract scores for this metric
-                base_scores = [result['metrics'][metric_name]['score'] for result in base_results]
-                finetuned_scores = [result['metrics'][metric_name]['score'] for result in finetuned_results]
-                
+                base_scores = [result["metrics"][metric_name]["score"] for result in base_results]
+                finetuned_scores = [result["metrics"][metric_name]["score"] for result in finetuned_results]
+
                 # Simple averages
                 base_avg = sum(base_scores) / len(base_scores)
                 finetuned_avg = sum(finetuned_scores) / len(finetuned_scores)
                 improvement = finetuned_avg - base_avg
-                
+
                 # Count successes (pass rates)
-                base_passed = sum(1 for result in base_results if result['metrics'][metric_name]['success'])
-                finetuned_passed = sum(1 for result in finetuned_results if result['metrics'][metric_name]['success'])
-                
+                base_passed = sum(1 for result in base_results if result["metrics"][metric_name]["success"])
+                finetuned_passed = sum(
+                    1 for result in finetuned_results if result["metrics"][metric_name]["success"]
+                )
+
                 # Clean up metric name for display (remove "(GEval)" suffix)
-                display_name = metric_name.replace(' (GEval)', '').replace('_', ' ')
-                
+                display_name = metric_name.replace(" (GEval)", "").replace("_", " ")
+
                 stats[display_name] = {
-                    'base_average': round(base_avg, 3),
-                    'finetuned_average': round(finetuned_avg, 3),
-                    'improvement': round(improvement, 3),
-                    'base_passed': f"{base_passed}/{len(base_results)}",
-                    'finetuned_passed': f"{finetuned_passed}/{len(finetuned_results)}",
-                    'pass_rate_improvement': finetuned_passed - base_passed
+                    "base_average": round(base_avg, 3),
+                    "finetuned_average": round(finetuned_avg, 3),
+                    "improvement": round(improvement, 3),
+                    "base_passed": f"{base_passed}/{len(base_results)}",
+                    "finetuned_passed": f"{finetuned_passed}/{len(finetuned_results)}",
+                    "pass_rate_improvement": finetuned_passed - base_passed,
                 }
-                
+
             except KeyError as e:
                 print(f"Warning: Could not process metric {metric_name}: {e}")
                 continue
-        
+
         # Overall summary - simple average across all metrics
-        metric_keys = [k for k in stats.keys() if k != 'overall_summary']
+        metric_keys = [k for k in stats.keys() if k != "overall_summary"]
         if metric_keys:
-            overall_base = sum(stats[m]['base_average'] for m in metric_keys) / len(metric_keys)
-            overall_finetuned = sum(stats[m]['finetuned_average'] for m in metric_keys) / len(metric_keys)
-            
-            stats['overall_summary'] = {
-                'base_model_average': round(overall_base, 3),
-                'finetuned_model_average': round(overall_finetuned, 3),
-                'overall_improvement': round(overall_finetuned - overall_base, 3),
-                'winner': 'Finetuned' if overall_finetuned > overall_base else 'Base' if overall_base > overall_finetuned else 'Tie'
+            overall_base = sum(stats[m]["base_average"] for m in metric_keys) / len(metric_keys)
+            overall_finetuned = sum(stats[m]["finetuned_average"] for m in metric_keys) / len(metric_keys)
+
+            stats["overall_summary"] = {
+                "base_model_average": round(overall_base, 3),
+                "finetuned_model_average": round(overall_finetuned, 3),
+                "overall_improvement": round(overall_finetuned - overall_base, 3),
+                "winner": "Finetuned"
+                if overall_finetuned > overall_base
+                else "Base"
+                if overall_base > overall_finetuned
+                else "Tie",
             }
-        
+
         return stats
-    
-    def arena_comparison(self, base_json_path: str, finetuned_json_path: str) -> Dict[str, Any]:
+
+    def arena_comparison(self, base_json_path: str, finetuned_json_path: str) -> dict[str, Any]:
         """
         Run head-to-head arena comparison between base and finetuned models.
-        
+
         Args:
             base_json_path: Path to base model responses JSON
             finetuned_json_path: Path to finetuned model responses JSON
-            
+
         Returns:
             Dictionary containing arena comparison results
         """
-        print("\n" + "="*60)
+        print("\n" + "=" * 60)
         print("RUNNING ARENA COMPARISON")
-        print("="*60)
-        
+        print("=" * 60)
+
         # Load and validate data
         base_data, finetuned_data = self.load_data(base_json_path, finetuned_json_path)
-        
+
         if len(base_data) == 0:
-            return {'error': 'No matching samples found for arena comparison'}
-        
-        
+            return {"error": "No matching samples found for arena comparison"}
+
         arena_metric = ArenaGEval(
             name="Closest_to_Ground_Truth",
             criteria="""
@@ -537,213 +552,231 @@ def arena_comparison(self, base_json_path: str, finetuned_json_path: str) -> Dic
             evaluation_params=[
                 LLMTestCaseParams.INPUT,
                 LLMTestCaseParams.ACTUAL_OUTPUT,
-                LLMTestCaseParams.EXPECTED_OUTPUT
+                LLMTestCaseParams.EXPECTED_OUTPUT,
             ],
-            model=self.evaluation_model
+            model=self.evaluation_model,
         )
-        
+
         arena_results = []
         finetuned_wins = 0
         base_wins = 0
-        
+
         # Process each matched sample
         for i, (base_item, finetuned_item) in enumerate(zip(base_data, finetuned_data)):
             # Verify sample IDs match
-            if base_item['sample_id'] != finetuned_item['sample_id']:
-                print(f"Warning: Sample ID mismatch at index {i}: {base_item['sample_id']} vs {finetuned_item['sample_id']}")
+            if base_item["sample_id"] != finetuned_item["sample_id"]:
+                print(
+                    f"Warning: Sample ID mismatch at index {i}: {base_item['sample_id']} vs {finetuned_item['sample_id']}"
+                )
                 continue
-            
-            sample_id = base_item['sample_id']
-            print(f"  Arena comparison for sample {i+1}/{len(base_data)} (ID: {sample_id})...")
-            
+
+            sample_id = base_item["sample_id"]
+            print(f"  Arena comparison for sample {i + 1}/{len(base_data)} (ID: {sample_id})...")
+
             # Create arena test case
             arena_test_case = ArenaTestCase(
                 contestants={
                     "Base_Model": LLMTestCase(
                         name="base_model",
-                        input=finetuned_item['input_question'],
-                        actual_output=base_item['predicted_answer'],
-                        expected_output=base_item['correct_answer']
+                        input=finetuned_item["input_question"],
+                        actual_output=base_item["predicted_answer"],
+                        expected_output=base_item["correct_answer"],
                     ),
                     "Finetuned_Model": LLMTestCase(
                         name="finetuned_model",
-                        input=finetuned_item['input_question'],
-                        actual_output=finetuned_item['predicted_answer'],
-                        expected_output=finetuned_item['correct_answer']
-                    )
+                        input=finetuned_item["input_question"],
+                        actual_output=finetuned_item["predicted_answer"],
+                        expected_output=finetuned_item["correct_answer"],
+                    ),
                 }
             )
-            
+
             try:
                 # Run arena comparison
                 arena_metric.measure(arena_test_case)
-                
+
                 winner = arena_metric.winner
                 reason = arena_metric.reason
-                
+
                 # Count wins
                 if winner == "Finetuned_Model":
                     finetuned_wins += 1
                 elif winner == "Base_Model":
                     base_wins += 1
-                
-                arena_results.append({
-                    'sample_id': sample_id,
-                    'winner': winner,
-                    'reason': reason,
-                    'input_question': finetuned_item['input_question']
-                })
-                
+
+                arena_results.append(
+                    {
+                        "sample_id": sample_id,
+                        "winner": winner,
+                        "reason": reason,
+                        "input_question": finetuned_item["input_question"],
+                    }
+                )
+
                 print(f"    Winner: {winner}")
-                
+
                 time.sleep(1)
                 # Add delay between samples
-                #if i < len(base_data) - 1:
+                # if i < len(base_data) - 1:
                 #    print(f"    Waiting {self.batch_delay}s before next comparison...")
                 #    time.sleep(self.batch_delay)
-                    
+
             except Exception as e:
                 import traceback
 
                 print(traceback.format_exc())
                 print(f"    ❌ Error in arena comparison for sample {sample_id}: {e}")
-                arena_results.append({
-                    'sample_id': sample_id,
-                    'winner': 'Error',
-                    'reason': str(e),
-                    'input_question': base_item['input_question']
-                })
+                arena_results.append(
+                    {
+                        "sample_id": sample_id,
+                        "winner": "Error",
+                        "reason": str(e),
+                        "input_question": base_item["input_question"],
+                    }
+                )
                 continue
-        
+
         # Calculate final statistics
-        total_comparisons = len([r for r in arena_results if r['winner'] != 'Error'])
-        
+        total_comparisons = len([r for r in arena_results if r["winner"] != "Error"])
+
         arena_summary = {
-            'total_comparisons': total_comparisons,
-            'finetuned_wins': finetuned_wins,
-            'base_wins': base_wins,
-            'finetuned_win_rate': round(finetuned_wins / total_comparisons, 3) if total_comparisons > 0 else 0,
-            'base_win_rate': round(base_wins / total_comparisons, 3) if total_comparisons > 0 else 0,
-            'overall_winner': 'Finetuned' if finetuned_wins > base_wins else 'Base' if base_wins > finetuned_wins else 'Tie'
+            "total_comparisons": total_comparisons,
+            "finetuned_wins": finetuned_wins,
+            "base_wins": base_wins,
+            "finetuned_win_rate": round(finetuned_wins / total_comparisons, 3)
+            if total_comparisons > 0
+            else 0,
+            "base_win_rate": round(base_wins / total_comparisons, 3) if total_comparisons > 0 else 0,
+            "overall_winner": "Finetuned"
+            if finetuned_wins > base_wins
+            else "Base"
+            if base_wins > finetuned_wins
+            else "Tie",
         }
-        
-        print(f"\n✓ Arena comparison complete!")
-        print(f"  Finetuned wins: {finetuned_wins}/{total_comparisons} ({arena_summary['finetuned_win_rate']:.1%})")
+
+        print("\n✓ Arena comparison complete!")
+        print(
+            f"  Finetuned wins: {finetuned_wins}/{total_comparisons} ({arena_summary['finetuned_win_rate']:.1%})"
+        )
         print(f"  Base wins: {base_wins}/{total_comparisons} ({arena_summary['base_win_rate']:.1%})")
         print(f"  Overall winner: {arena_summary['overall_winner']}")
-        
-        return {
-            'arena_summary': arena_summary,
-            'detailed_results': arena_results
-        }
 
-    def print_arena_summary(self, arena_results: Dict[str, Any]):
+        return {"arena_summary": arena_summary, "detailed_results": arena_results}
+
+    def print_arena_summary(self, arena_results: dict[str, Any]):
         """
         Print a summary of arena comparison results.
-        
+
         Args:
             arena_results: Results from arena_comparison method
         """
-        if 'error' in arena_results:
+        if "error" in arena_results:
             print(f"Arena Error: {arena_results['error']}")
             return
-        
-        summary = arena_results['arena_summary']
-        detailed = arena_results['detailed_results']
-        
-        print("\n" + "="*60)
+
+        summary = arena_results["arena_summary"]
+        detailed = arena_results["detailed_results"]
+
+        print("\n" + "=" * 60)
         print("ARENA COMPARISON SUMMARY")
-        print("="*60)
-        
+        print("=" * 60)
+
         print(f"Total head-to-head comparisons: {summary['total_comparisons']}")
-        print(f"")
-        print(f"Results:")
+        print("")
+        print("Results:")
         print(f"  Finetuned Model wins: {summary['finetuned_wins']} ({summary['finetuned_win_rate']:.1%})")
         print(f"  Base Model wins: {summary['base_wins']} ({summary['base_win_rate']:.1%})")
-        print(f"")
+        print("")
         print(f"🏆 Overall Winner: {summary['overall_winner']} Model")
-        
+
         # Show some example wins for finetuned model
-        finetuned_examples = [r for r in detailed if r['winner'] == 'Finetuned_Model'][:3]
+        finetuned_examples = [r for r in detailed if r["winner"] == "Finetuned_Model"][:3]
         if finetuned_examples:
-            print(f"\nExample Finetuned Model wins:")
+            print("\nExample Finetuned Model wins:")
             for i, example in enumerate(finetuned_examples, 1):
                 print(f"  {i}. Sample {example['sample_id']}: {example['reason'][:100]}...")
-        
+
         # Show some example wins for base model
-        base_examples = [r for r in detailed if r['winner'] == 'Base_Model'][:3]
+        base_examples = [r for r in detailed if r["winner"] == "Base_Model"][:3]
         if base_examples:
-            print(f"\nExample Base Model wins:")
+            print("\nExample Base Model wins:")
             for i, example in enumerate(base_examples, 1):
                 print(f"  {i}. Sample {example['sample_id']}: {example['reason'][:100]}...")
-        
-        print("\n" + "="*60)
-    
-    def save_results(self, results: Dict[str, Any], output_path: str):
+
+        print("\n" + "=" * 60)
+
+    def save_results(self, results: dict[str, Any], output_path: str):
         """
         Save evaluation results to JSON file with proper formatting.
-        
+
         Args:
             results: Results dictionary from compare_models
             output_path: Path to save the JSON file
         """
         try:
-            with open(output_path, 'w', encoding='utf-8') as f:
+            with open(output_path, "w", encoding="utf-8") as f:
                 json.dump(results, f, indent=2, ensure_ascii=False)
-            
+
             print(f"\n✓ Results saved to: {output_path}")
-            
+
             # Print file size info
             import os
+
             file_size = os.path.getsize(output_path)
             print(f"  File size: {file_size / 1024:.1f} KB")
-            
+
         except Exception as e:
             print(f"✗ Error saving results: {e}")
             raise
-    
-    def print_summary(self, results: Dict[str, Any]):
+
+    def print_summary(self, results: dict[str, Any]):
         """
         Print a simple summary of the evaluation results focused on accuracy.
-        
+
         Args:
             results: Results dictionary from compare_models
         """
-        stats = results['comparison_statistics']
-        metadata = results['evaluation_metadata']
-        
-        print("\n" + "="*60)
+        stats = results["comparison_statistics"]
+        metadata = results["evaluation_metadata"]
+
+        print("\n" + "=" * 60)
         print("MODEL COMPARISON SUMMARY")
-        print("="*60)
-        
+        print("=" * 60)
+
         print(f"Total samples: {metadata['total_samples']}")
         print(f"Evaluation model: {metadata['evaluation_model']}")
-        
+
         # Skip if there's an error
-        if 'error' in stats:
+        if "error" in stats:
             print(f"Error: {stats['error']}")
             return
-        
+
         # Print results for each metric
         for metric_name, metric_stats in stats.items():
-            if metric_name == 'overall_summary':
+            if metric_name == "overall_summary":
                 continue
-                
+
             print(f"\n{metric_name}:")
-            print(f"  Base Model      - Average: {metric_stats['base_average']:.3f}, Passed: {metric_stats['base_passed']}")
-            print(f"  Finetuned Model - Average: {metric_stats['finetuned_average']:.3f}, Passed: {metric_stats['finetuned_passed']}")
-            print(f"  Improvement     - {metric_stats['improvement']:+.3f} (Pass rate: {metric_stats['pass_rate_improvement']:+d})")
-        
+            print(
+                f"  Base Model      - Average: {metric_stats['base_average']:.3f}, Passed: {metric_stats['base_passed']}"
+            )
+            print(
+                f"  Finetuned Model - Average: {metric_stats['finetuned_average']:.3f}, Passed: {metric_stats['finetuned_passed']}"
+            )
+            print(
+                f"  Improvement     - {metric_stats['improvement']:+.3f} (Pass rate: {metric_stats['pass_rate_improvement']:+d})"
+            )
+
         # Overall summary
-        if 'overall_summary' in stats:
-            overall = stats['overall_summary']
+        if "overall_summary" in stats:
+            overall = stats["overall_summary"]
             print(f"\n{'OVERALL RESULTS'.center(30, '-')}")
             print(f"Winner: {overall['winner']} Model")
             print(f"Base Model Average: {overall['base_model_average']:.3f}")
             print(f"Finetuned Model Average: {overall['finetuned_model_average']:.3f}")
             print(f"Overall Improvement: {overall['overall_improvement']:+.3f}")
-        
-        print("\n" + "="*60)
+
+        print("\n" + "=" * 60)
 
 
 # Example usage and main execution
@@ -754,26 +787,28 @@ def main():
     try:
         # Initialize evaluator with config from imported module
         evaluator = RecommendationEvaluator()
-        
+
         # Define file paths
         base_json_path = "experiment_results/train-qwen2-recommendation-mobile/base_evaluation_outputs.json"
-        finetuned_json_path = "experiment_results/train-qwen2-recommendation-mobile/finetuned_evaluation_outputs.json"
-        output_path = f"comparison_evaluation_results.json"
-        
+        finetuned_json_path = (
+            "experiment_results/train-qwen2-recommendation-mobile/finetuned_evaluation_outputs.json"
+        )
+        output_path = "comparison_evaluation_results.json"
+
         # Run arena comparison
 
         arena_results = evaluator.arena_comparison(base_json_path, finetuned_json_path)
 
         evaluator.print_arena_summary(arena_results)
         evaluator.save_results(arena_results, output_path)
-        
-        print(f"\n✓ Evaluation completed successfully!")
+
+        print("\n✓ Evaluation completed successfully!")
         print(f"Check '{output_path}' for detailed results.")
-        
+
     except Exception as e:
         print(f"✗ Error during evaluation: {e}")
         raise
 
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/evaluation/mobile_evaluator.py b/src/mobiletransformers/evaluation/mobile_evaluator.py
similarity index 71%
rename from evaluation/mobile_evaluator.py
rename to src/mobiletransformers/evaluation/mobile_evaluator.py
index 3a2e9c6..3948462 100644
--- a/evaluation/mobile_evaluator.py
+++ b/src/mobiletransformers/evaluation/mobile_evaluator.py
@@ -5,16 +5,18 @@
 import json
 import os
 import re
+from typing import Any
+
+from datasets import Dataset as HFDataset
+from datasets import load_dataset
 from tqdm import tqdm
-from typing import List, Dict, Any, Union
-from datasets import load_dataset, Dataset as HFDataset
 
 
 class MobileEvaluator:
     def __init__(self, model, task="mini_personalqa"):
         """
         Initialize evaluator with pre-loaded model
-        
+
         Args:
             model: Pre-loaded language model with .generate(prompt) method
             tokenizer: Optional tokenizer (not needed if model has .generate(prompt))
@@ -22,54 +24,58 @@ def __init__(self, model, task="mini_personalqa"):
         """
         self.model = model
         self.task = task
-    
-    def format_question_mini_personalqa(self, data_point: Dict[str, Any], few_shot_examples: List[Dict[str, Any]] = None) -> str:
+
+    def format_question_mini_personalqa(
+        self, data_point: dict[str, Any], few_shot_examples: list[dict[str, Any]] = None
+    ) -> str:
         """Format question for model input with optional few-shot examples"""
         formatted = ""
-        
+
         # Add few-shot examples if provided
         if few_shot_examples is not None:
             formatted = "Answer the multiple choice question by selecting exactly one letter: A, B, C, or D. Try to guess the correct answer.\n\n"
             for example in few_shot_examples:
                 formatted += f"Question: {example['question']}\n\n"
-                for choice_key, choice_value in example['choices'].items():
+                for choice_key, choice_value in example["choices"].items():
                     formatted += f"{choice_key}: {choice_value}\n"
                 formatted += f"\n\nAnswer: {example['correct_answer']}\n\n"
         # Add the actual question
         question_text = data_point["question"]
         choices = data_point["choices"]
-        
+
         formatted += f"Question: {question_text}\n\n"
         for choice_key, choice_value in choices.items():
             formatted += f"{choice_key}: {choice_value}\n"
         formatted += "\n\nAnswer: "
-        
+
         return formatted
-    
-    def format_question_mini_recommendation(self, data_point: Dict[str, Any], few_shot_examples: List[Dict[str, Any]] = None) -> str:
+
+    def format_question_mini_recommendation(
+        self, data_point: dict[str, Any], few_shot_examples: list[dict[str, Any]] = None
+    ) -> str:
         """Format recommendation question for model input with optional few-shot examples"""
         formatted = ""
-        
+
         # Add few-shot examples if provided
         if few_shot_examples is not None:
             formatted = "Recommend best actions based on user queries.\n"
             for example in few_shot_examples:
-                user_query = example['prompt']
-                recommendation = example['recommendation']
-                
+                user_query = example["prompt"]
+                recommendation = example["recommendation"]
+
                 formatted += f"Recommend best actions based on this user query: {user_query}\n\n"
                 formatted += f"Answer: {recommendation}\n\n"
-        
+
             formatted += "Output only a single sentence answer of your recommendation.\n"
-        
+
         # Add the actual question (without answer for inference)
         user_query = data_point["prompt"]
-        
+
         formatted += f"Recommend best actions based on this user query: {user_query}\n\n"
         formatted += "Answer: "
-        
+
         return formatted
-    
+
     def predict_multichoice_answer(self, question: str) -> str:
         """Generate prediction for a single question using model's .generate() method"""
         # Use the model's built-in generate method
@@ -77,44 +83,51 @@ def predict_multichoice_answer(self, question: str) -> str:
 
         # Extract just the letter (A, B, C, D)
         prediction = str(prediction).upper().strip()
-        for choice in ['A', 'B', 'C', 'D']:
+        for choice in ["A", "B", "C", "D"]:
             if choice in prediction:
                 return choice
-        
+
         return prediction  # Return full prediction if no clear choice found
-    
+
     def predict_short_answer(self, question):
         full_response = self.model.generate(question)
-        
+
         full_response = full_response.replace("1.", "")
 
         # Split by sentence endings and return first sentence
-        sentences = re.split(r'[.!?]+', full_response.strip())
-        
+        sentences = re.split(r"[.!?]+", full_response.strip())
+
         # Return first non-empty sentence
         for sentence in sentences:
             sentence = sentence.strip()
             if sentence:
                 return sentence
-        
+
         # Fallback: return full response if no sentence endings found
         return full_response.strip()
-    
-    def evaluate(self, data_path: Union[str, List[Dict]], verbose=False, few_shot_examples: List[Dict[str, Any]] = None, save_outputs=False, save_results_dir=None) -> Dict[str, float]:
+
+    def evaluate(
+        self,
+        data_path: str | list[dict],
+        verbose=False,
+        few_shot_examples: list[dict[str, Any]] = None,
+        save_outputs=False,
+        save_results_dir=None,
+    ) -> dict[str, float]:
         """
         Evaluate model on the dataset
-        
+
         Args:
             data_path: Path to JSONL file or list of data samples
             batch_size: Batch size for processing (currently supports 1)
-            
+
         Returns:
             Dictionary with accuracy metrics
         """
         # Load dataset using HuggingFace datasets
         if isinstance(data_path, str):
             # Load from local JSONL file
-            dataset = load_dataset('json', data_files=data_path, split='train')
+            dataset = load_dataset("json", data_files=data_path, split="train")
         else:
             # Create from list of dictionaries
             dataset = HFDataset.from_list(data_path)
@@ -124,10 +137,10 @@ def evaluate(self, data_path: Union[str, List[Dict]], verbose=False, few_shot_ex
         predictions = []
         ground_truths = []
         detailed_outputs = []
-        
+
         # Progress bar
         pbar = tqdm(dataset, desc="Evaluating", total=len(dataset))
-        
+
         for sample in pbar:
             # Format question
             if self.task == "mini_personalqa":
@@ -140,127 +153,131 @@ def evaluate(self, data_path: Union[str, List[Dict]], verbose=False, few_shot_ex
                 correct_answer = sample["recommendation"]
             else:
                 raise ValueError("Task not recognized.")
-            
+
             if save_outputs:
                 output_entry = {
                     "input_question": formatted_question,
                     "predicted_answer": predicted_answer,
                     "correct_answer": correct_answer,
-                    "sample_id": total_predictions
+                    "sample_id": total_predictions,
                 }
                 detailed_outputs.append(output_entry)
-            
+
             # Print prompt and answers if verbose
             if verbose:
-                print(f"\n{'='*80}")
+                print(f"\n{'=' * 80}")
                 print("PROMPT:")
                 print(formatted_question)
                 print(f"\nPREDICTED: {predicted_answer}")
                 print(f"CORRECT: {correct_answer}")
                 print(f"RESULT: {'✓ CORRECT' if predicted_answer == correct_answer else '✗ INCORRECT'}")
-                print('='*80)
-            
+                print("=" * 80)
+
             # Track results
             predictions.append(predicted_answer)
             ground_truths.append(correct_answer)
-            
+
             # Check if correct
             is_correct = predicted_answer == correct_answer
             if is_correct:
                 correct_predictions += 1
             total_predictions += 1
-            
+
             # Update progress bar
             current_accuracy = correct_predictions / total_predictions * 100
-            pbar.set_postfix({
-                'Accuracy': f'{current_accuracy:.2f}%',
-                'Correct': f'{correct_predictions}/{total_predictions}'
-            })
-        
+            pbar.set_postfix(
+                {
+                    "Accuracy": f"{current_accuracy:.2f}%",
+                    "Correct": f"{correct_predictions}/{total_predictions}",
+                }
+            )
+
         # Calculate final metrics
         accuracy = correct_predictions / total_predictions
-        
+
         # Category-wise accuracy (if available)
         category_stats = {}
-        if len(dataset) > 0 and 'category' in dataset[0]:
-            categories = set(sample['category'] for sample in dataset)
-            
+        if len(dataset) > 0 and "category" in dataset[0]:
+            categories = set(sample["category"] for sample in dataset)
+
             for category in categories:
                 cat_correct = 0
                 cat_total = 0
                 for i, sample in enumerate(dataset):
-                    if sample['category'] == category:
+                    if sample["category"] == category:
                         if predictions[i] == ground_truths[i]:
                             cat_correct += 1
                         cat_total += 1
-                
+
                 if cat_total > 0:
                     category_stats[category] = {
-                        'accuracy': cat_correct / cat_total,
-                        'correct': cat_correct,
-                        'total': cat_total
+                        "accuracy": cat_correct / cat_total,
+                        "correct": cat_correct,
+                        "total": cat_total,
                     }
-        
+
         if save_outputs:
             # Save to JSON file
             save_output_dir = "evaluation_outputs.json"
             if save_results_dir:
                 save_output_dir = os.path.join(save_results_dir, save_output_dir)
-                
-            with open(save_output_dir, 'w', encoding='utf-8') as f:
+
+            with open(save_output_dir, "w", encoding="utf-8") as f:
                 json.dump(detailed_outputs, f, indent=2, ensure_ascii=False)
 
         results = {
-            'overall_accuracy': accuracy,
-            'correct_predictions': correct_predictions,
-            'total_predictions': total_predictions,
-            'category_stats': category_stats,
-            'predictions': predictions,
-            'ground_truths': ground_truths
+            "overall_accuracy": accuracy,
+            "correct_predictions": correct_predictions,
+            "total_predictions": total_predictions,
+            "category_stats": category_stats,
+            "predictions": predictions,
+            "ground_truths": ground_truths,
         }
 
         if save_results_dir:
             self.save_results(save_results_dir, results)
 
         return results
-    
-    def print_results(self, results: Dict[str, Any]):
+
+    def print_results(self, results: dict[str, Any]):
         """Print formatted evaluation results"""
-        print(f"\n{'='*50}")
+        print(f"\n{'=' * 50}")
         print("EVALUATION RESULTS")
-        print(f"{'='*50}")
-        
-        print(f"Overall Accuracy: {results['overall_accuracy']:.4f} ({results['overall_accuracy']*100:.2f}%)")
+        print(f"{'=' * 50}")
+
+        print(
+            f"Overall Accuracy: {results['overall_accuracy']:.4f} ({results['overall_accuracy'] * 100:.2f}%)"
+        )
         print(f"Correct: {results['correct_predictions']}/{results['total_predictions']}")
-        
-        if results['category_stats']:
+
+        if results["category_stats"]:
             print(f"\n{'Category Breakdown:':<20}")
             print(f"{'Category':<20} {'Accuracy':<10} {'Correct/Total':<15}")
             print("-" * 45)
-            for category, stats in results['category_stats'].items():
-                acc_pct = stats['accuracy'] * 100
+            for category, stats in results["category_stats"].items():
+                acc_pct = stats["accuracy"] * 100
                 print(f"{category:<20} {acc_pct:>7.2f}% {stats['correct']:>6}/{stats['total']:<6}")
-    
-    def save_results(self, save_results_dir, results: Dict[str, Any]):
+
+    def save_results(self, save_results_dir, results: dict[str, Any]):
         """Save evaluation results to eval_results.json"""
 
         # Prepare per-category accuracy dictionary
         per_category_accuracy = {}
-        if results['category_stats']:
-            for category, stats in results['category_stats'].items():
-                per_category_accuracy[category] = stats['accuracy']
-        
+        if results["category_stats"]:
+            for category, stats in results["category_stats"].items():
+                per_category_accuracy[category] = stats["accuracy"]
+
         # Prepare data to save
         save_data = {
             "task": self.task,
-            "results": results['overall_accuracy'],
-            "per_category_accuracy": per_category_accuracy
+            "results": results["overall_accuracy"],
+            "per_category_accuracy": per_category_accuracy,
         }
-        
-        save_path = os.path.join(save_results_dir, 'eval_results.json')
+
+        save_path = os.path.join(save_results_dir, "eval_results.json")
 
         # Save to JSON file
-        with open(save_path, 'w', encoding='utf-8') as f:
+        with open(save_path, "w", encoding="utf-8") as f:
             json.dump(save_data, f, indent=2, ensure_ascii=False)
-        
+
         print(f"Results saved to {save_path}")
diff --git a/src/mobiletransformers/evaluation/openehr/__init__.py b/src/mobiletransformers/evaluation/openehr/__init__.py
new file mode 100644
index 0000000..0bc4b8a
--- /dev/null
+++ b/src/mobiletransformers/evaluation/openehr/__init__.py
@@ -0,0 +1 @@
+"""openEHR case-study evaluation (S8). See the package docstring in the parent module."""
diff --git a/evaluation/openehr/openehr_eval.py b/src/mobiletransformers/evaluation/openehr/openehr_eval.py
similarity index 70%
rename from evaluation/openehr/openehr_eval.py
rename to src/mobiletransformers/evaluation/openehr/openehr_eval.py
index 88f6920..84f8091 100644
--- a/evaluation/openehr/openehr_eval.py
+++ b/src/mobiletransformers/evaluation/openehr/openehr_eval.py
@@ -5,16 +5,18 @@
 import datetime
 import gc
 import json
-import os
 import time
-from inference.validator import ORTransformerGenerator
+
 from deepeval import evaluate
 from deepeval.metrics import FaithfulnessMetric, GEval
-from deepeval.test_case import LLMTestCase, LLMTestCaseParams
+from deepeval.metrics.g_eval import Rubric
 from deepeval.models.llms import GeminiModel
-from database.query import ObjectBoxQueryEngine
+from deepeval.test_case import LLMTestCase, LLMTestCaseParams
 from dotenv import load_dotenv
-from deepeval.metrics.g_eval import Rubric
+
+from mobiletransformers.artifacts.validation import MobileTransformerGenerator
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.rag.query import ObjectBoxQueryEngine
 
 load_dotenv()
 
@@ -25,7 +27,7 @@
 CHUNK_DATABASE_DIR = "build/ehr_chunk_db"
 DOCUMENT_DATABASE_DIR = "build/ehr_document_db"
 EMBEDDING_MODEL_ID = "sentence-transformers/all-MiniLM-L6-v2"
-GEMINI_API_KEY=os.environ["GEMINI_API_KEY"]
+GEMINI_API_KEY = get_settings().gemini_api_key
 
 
 if SLM_TO_TEST == "tinyllama":
@@ -42,114 +44,113 @@
 # Test questions
 
 if TEST_DATA_TYPE == "simple":
-
     test_data = [
         {
             "query": "What medications is this patient currently taking and for what conditions?",
-            "relevant_docs": ["medications.txt"]
+            "relevant_docs": ["medications.txt"],
         },
         {
             "query": "What are this patient's known allergies and how severe are they?",
-            "relevant_docs": ["allergies.txt"]
+            "relevant_docs": ["allergies.txt"],
         },
         {
             "query": "How has this patient's HbA1c improved over the past 3 months?",
-            "relevant_docs": ["hba1c.txt"]
+            "relevant_docs": ["hba1c.txt"],
         },
         {
             "query": "What is this patient's current blood pressure and has it improved this week?",
-            "relevant_docs": ["vitals.txt"]
+            "relevant_docs": ["vitals.txt"],
         },
         {
             "query": "Does this patient have any allergies to common pain medications?",
-            "relevant_docs": ["allergies.txt"]
+            "relevant_docs": ["allergies.txt"],
         },
         {
             "query": "What does this patient's recent lab results show for cholesterol levels?",
-            "relevant_docs": ["labs.txt"]
+            "relevant_docs": ["labs.txt"],
         },
         {
             "query": "What cardiovascular conditions run in this patient's family?",
-            "relevant_docs": ["family_history.txt"]
+            "relevant_docs": ["family_history.txt"],
         },
         {
             "query": "What is this patient's most recent HbA1c and how close are they to target?",
-            "relevant_docs": ["hba1c.txt"]
+            "relevant_docs": ["hba1c.txt"],
         },
         {
             "query": "What active medical conditions does this patient currently have?",
-            "relevant_docs": ["conditions.txt"]
+            "relevant_docs": ["conditions.txt"],
         },
         {
             "query": "What foods should this patient avoid based on their allergies?",
-            "relevant_docs": ["allergies.txt"]
-        }
+            "relevant_docs": ["allergies.txt"],
+        },
     ]
 elif TEST_DATA_TYPE == "complex":
     test_data = [
         {
             "query": "Given this patient's current medication regimen and allergies, what should be avoided if they need emergency surgery?",
-            "relevant_docs": ["allergies.txt"]
+            "relevant_docs": ["allergies.txt"],
         },
         {
             "query": "Based on the HbA1c trend, predict whether this patient will reach their target by the next scheduled test?",
-            "relevant_docs": ["hba1c.txt"]
+            "relevant_docs": ["hba1c.txt"],
         },
         {
             "query": "What does the blood pressure progression pattern suggest about medication efficacy and lifestyle compliance?",
-            "relevant_docs": ["vitals.txt"]
+            "relevant_docs": ["vitals.txt"],
         },
         {
             "query": "Considering the family history, what additional screening tests should this patient prioritize?",
-            "relevant_docs": ["family_history.txt"]
+            "relevant_docs": ["family_history.txt"],
         },
         {
             "query": "How do the lipid improvements correlate with the patient's overall cardiovascular risk reduction strategy?",
-            "relevant_docs": ["labs.txt"]
+            "relevant_docs": ["labs.txt"],
         },
         {
             "query": "What medication interaction risks exist with this patient's current drug regimen?",
-            "relevant_docs": ["medications.txt"]
+            "relevant_docs": ["medications.txt"],
         },
         {
             "query": "Based on disease progression timing, which condition likely triggered the cascade of other diagnoses?",
-            "relevant_docs": ["conditions.txt"]
+            "relevant_docs": ["conditions.txt"],
         },
         {
             "query": "What lifestyle modifications can be inferred from the HbA1c improvement pattern?",
-            "relevant_docs": ["hba1c.txt"]
+            "relevant_docs": ["hba1c.txt"],
         },
         {
             "query": "How does this patient's weight loss trajectory correlate with their blood pressure control?",
-            "relevant_docs": ["vitals.txt"]
+            "relevant_docs": ["vitals.txt"],
         },
         {
             "query": "What emergency preparedness considerations are needed given this patient's allergy profile?",
-            "relevant_docs": ["allergies.txt"]
+            "relevant_docs": ["allergies.txt"],
         },
         {
             "query": "Based on the timing of medication starts, what treatment prioritization strategy was likely used?",
-            "relevant_docs": ["medications.txt"]
+            "relevant_docs": ["medications.txt"],
         },
         {
             "query": "What does the lab trend pattern suggest about treatment adherence and metabolic response?",
-            "relevant_docs": ["labs.txt"]
+            "relevant_docs": ["labs.txt"],
         },
         {
             "query": "How does this patient's genetic predisposition influence their current treatment outcomes?",
-            "relevant_docs": ["family_history.txt"]
+            "relevant_docs": ["family_history.txt"],
         },
         {
             "query": "What early warning signs of treatment resistance can be identified from the condition management data?",
-            "relevant_docs": ["conditions.txt"]
+            "relevant_docs": ["conditions.txt"],
         },
         {
             "query": "Based on the diabetes progression timeline, what complications should be monitored most closely?",
-            "relevant_docs": ["hba1c.txt"]
-        }
+            "relevant_docs": ["hba1c.txt"],
+        },
     ]
 
-#test_data = test_data[:1]
+# test_data = test_data[:1]
 
 
 MEDICAL_ASSISTANT_TEMPLATE = """You are a health assistant. Analyze the patient openEHR data and answer the question concisely and briefly in 1-2 sentences.
@@ -160,11 +161,10 @@
 
 Answer:"""
 
+
 def format_medical_prompt(context, question):
-    return MEDICAL_ASSISTANT_TEMPLATE.format(
-        context=context,
-        question=question
-    )
+    return MEDICAL_ASSISTANT_TEMPLATE.format(context=context, question=question)
+
 
 # Initialize query database
 document_db = ObjectBoxQueryEngine(DOCUMENT_DATABASE_DIR, EMBEDDING_MODEL_ID)
@@ -188,46 +188,35 @@ def format_medical_prompt(context, question):
 
 
 # Initialize models
-slm_generator = ORTransformerGenerator(
-    model_id=SLM_MODEL_ID,
-    model_name=SLM_MODEL_NAME, 
-    model_dir=SLM_MODEL_DIR
+slm_generator = MobileTransformerGenerator(
+    model_id=SLM_MODEL_ID, model_name=SLM_MODEL_NAME, model_dir=SLM_MODEL_DIR
 )
 
-llm_generator = GeminiModel(
-    model_name="gemini-2.0-flash",
-    api_key=GEMINI_API_KEY
-)
+llm_generator = GeminiModel(model_name="gemini-2.0-flash", api_key=GEMINI_API_KEY)
 
-llm_evaluator = GeminiModel(
-    model_name="gemini-2.5-pro",
-    api_key=GEMINI_API_KEY
-)   
+llm_evaluator = GeminiModel(model_name="gemini-2.5-pro", api_key=GEMINI_API_KEY)
 
 # Initialize metrics
-faithfulness_metric = FaithfulnessMetric(
-    threshold=0.9,
-    model=llm_evaluator
-)
+faithfulness_metric = FaithfulnessMetric(threshold=0.9, model=llm_evaluator)
 
 clinical_quality_metric = GEval(
     name="Clinical Quality",
     criteria="Compare the clinical accuracy and completeness of the actual output to the expected output.",
     evaluation_steps=[
         "Check if key medical information from openEHR data is preserved",
-        "Compare clinical reasoning and interpretation quality", 
+        "Compare clinical reasoning and interpretation quality",
         "Assess appropriateness of recommendations or conclusions",
-        "Rate overall clinical quality on scale 1-10"
+        "Rate overall clinical quality on scale 1-10",
     ],
     threshold=0.7,
     model=llm_evaluator,
     evaluation_params=[LLMTestCaseParams.ACTUAL_OUTPUT, LLMTestCaseParams.EXPECTED_OUTPUT],
     rubric=[
-        Rubric(score_range=(0,2), expected_outcome="Factually incorrect."),
-        Rubric(score_range=(3,6), expected_outcome="Mostly correct."),
-        Rubric(score_range=(7,9), expected_outcome="Correct but missing minor details."),
-        Rubric(score_range=(10,10), expected_outcome=f"100% correct."),
-    ]
+        Rubric(score_range=(0, 2), expected_outcome="Factually incorrect."),
+        Rubric(score_range=(3, 6), expected_outcome="Mostly correct."),
+        Rubric(score_range=(7, 9), expected_outcome="Correct but missing minor details."),
+        Rubric(score_range=(10, 10), expected_outcome="100% correct."),
+    ],
 )
 
 # Storage for all test cases and responses
@@ -235,7 +224,7 @@ def format_medical_prompt(context, question):
     "slm_vs_llm_document": [],
     "slm_vs_llm_chunked": [],
     "document_vs_chunked_slm": [],
-    "document_vs_chunked_llm": []
+    "document_vs_chunked_llm": [],
 }
 
 all_responses = []
@@ -245,21 +234,21 @@ def format_medical_prompt(context, question):
 
 # Generate responses and create test cases
 for i, test in enumerate(llm_test_data):
-    print(f"Processing test case {i+1}/{len(llm_test_data)}: {test['query'][:50]}...")
-    
+    print(f"Processing test case {i + 1}/{len(llm_test_data)}: {test['query'][:50]}...")
+
     # Format prompts
     doc_prompt = format_medical_prompt(test["document_context"], test["query"])
     chunk_prompt = format_medical_prompt(test["chunked_context"], test["query"])
-    
+
     # Generate responses
     slm_response_doc = slm_generator.generate(doc_prompt, max_length=MAX_RESPONSE_LENGTH)
     slm_response_chunk = slm_generator.generate(chunk_prompt, max_length=MAX_RESPONSE_LENGTH)
-    
+
     llm_response_doc = llm_generator.generate(doc_prompt)[0]
     time.sleep(2)
     llm_response_chunk = llm_generator.generate(chunk_prompt)[0]
     time.sleep(2)
-    
+
     # Store responses for analysis
     response_data = {
         "test_id": i + 1,
@@ -270,44 +259,44 @@ def format_medical_prompt(context, question):
             "slm_document": slm_response_doc,
             "slm_chunked": slm_response_chunk,
             "llm_document": llm_response_doc,
-            "llm_chunked": llm_response_chunk
-        }
+            "llm_chunked": llm_response_chunk,
+        },
     }
     all_responses.append(response_data)
-    
+
     # 1. SLM vs LLM (Document Context)
     test_case_1 = LLMTestCase(
         input=test["query"],
         actual_output=slm_response_doc,
         expected_output=llm_response_doc,
-        retrieval_context=[test["document_context"]]
+        retrieval_context=[test["document_context"]],
     )
     all_test_cases["slm_vs_llm_document"].append(test_case_1)
-    
-    # 2. SLM vs LLM (Chunked Context) 
+
+    # 2. SLM vs LLM (Chunked Context)
     test_case_2 = LLMTestCase(
         input=test["query"],
         actual_output=slm_response_chunk,
         expected_output=llm_response_chunk,
-        retrieval_context=[test["chunked_context"]]
+        retrieval_context=[test["chunked_context"]],
     )
     all_test_cases["slm_vs_llm_chunked"].append(test_case_2)
-    
+
     # 3. Document vs Chunked (SLM)
     test_case_3 = LLMTestCase(
         input=test["query"],
         actual_output=slm_response_chunk,
         expected_output=slm_response_doc,
-        retrieval_context=[test["chunked_context"]]
+        retrieval_context=[test["chunked_context"]],
     )
     all_test_cases["document_vs_chunked_slm"].append(test_case_3)
-    
+
     # 4. Document vs Chunked (LLM)
     test_case_4 = LLMTestCase(
         input=test["query"],
         actual_output=llm_response_chunk,
         expected_output=llm_response_doc,
-        retrieval_context=[test["chunked_context"]]
+        retrieval_context=[test["chunked_context"]],
     )
     all_test_cases["document_vs_chunked_llm"].append(test_case_4)
 
@@ -318,20 +307,17 @@ def format_medical_prompt(context, question):
 evaluation_results = {}
 
 for comparison_name, test_cases in all_test_cases.items():
-    print(f"\n{'='*20} {comparison_name.upper()} {'='*20}")
+    print(f"\n{'=' * 20} {comparison_name.upper()} {'=' * 20}")
     print(f"Evaluating {len(test_cases)} test cases...")
-    
+
     # Run evaluation
-    results = evaluate(
-        test_cases=test_cases,
-        metrics=[faithfulness_metric, clinical_quality_metric]
-    )
-    
+    results = evaluate(test_cases=test_cases, metrics=[faithfulness_metric, clinical_quality_metric])
+
     # Extract scores and detailed results - Correct DeepEval API
     faithfulness_scores = []
     clinical_quality_scores = []
     detailed_results = []
-    
+
     for i, test_result in enumerate(results.test_results):
         test_case_detail = {
             "test_case_id": i + 1,
@@ -339,18 +325,17 @@ def format_medical_prompt(context, question):
             "actual_output": test_cases[i].actual_output,
             "expected_output": test_cases[i].expected_output,
             "context": test_cases[i].retrieval_context[0] if test_cases[i].retrieval_context else "",
-            "metrics": {}
+            "metrics": {},
         }
-        
-        for metric_data in test_result.metrics_data:
 
+        for metric_data in test_result.metrics_data:
             if "Faithfulness" in metric_data.name:
                 faithfulness_scores.append(metric_data.score)
                 test_case_detail["metrics"]["faithfulness"] = {
                     "score": metric_data.score,
                     "reason": metric_data.reason,
                     "success": metric_data.success,
-                    "threshold": metric_data.threshold
+                    "threshold": metric_data.threshold,
                 }
             elif "Clinical Quality" in metric_data.name:
                 clinical_quality_scores.append(metric_data.score)
@@ -358,42 +343,56 @@ def format_medical_prompt(context, question):
                     "score": metric_data.score,
                     "reason": metric_data.reason,
                     "success": metric_data.success,
-                    "threshold": metric_data.threshold
+                    "threshold": metric_data.threshold,
                 }
-        
+
         detailed_results.append(test_case_detail)
-    
+
     # Calculate summary statistics
     summary_stats = {
         "total_cases": len(test_cases),
         "detailed_results": detailed_results,  # Add detailed results here
         "faithfulness": {
             "average": sum(faithfulness_scores) / len(faithfulness_scores) if faithfulness_scores else 0,
-            "pass_rate": sum(1 for s in faithfulness_scores if s >= 0.9) / len(faithfulness_scores) if faithfulness_scores else 0,
-            "scores": faithfulness_scores
+            "pass_rate": sum(1 for s in faithfulness_scores if s >= 0.9) / len(faithfulness_scores)
+            if faithfulness_scores
+            else 0,
+            "scores": faithfulness_scores,
         },
         "clinical_quality": {
-            "average": sum(clinical_quality_scores) / len(clinical_quality_scores) if clinical_quality_scores else 0,
-            "pass_rate": sum(1 for s in clinical_quality_scores if s >= 7.0) / len(clinical_quality_scores) if clinical_quality_scores else 0,
-            "scores": clinical_quality_scores
-        }
+            "average": sum(clinical_quality_scores) / len(clinical_quality_scores)
+            if clinical_quality_scores
+            else 0,
+            "pass_rate": sum(1 for s in clinical_quality_scores if s >= 7.0) / len(clinical_quality_scores)
+            if clinical_quality_scores
+            else 0,
+            "scores": clinical_quality_scores,
+        },
     }
-    
+
     evaluation_results[comparison_name] = summary_stats
-    
+
     # Print results
-    print(f"Faithfulness - Average: {summary_stats['faithfulness']['average']:.3f}, Pass Rate: {summary_stats['faithfulness']['pass_rate']:.1%}")
-    print(f"Clinical Quality - Average: {summary_stats['clinical_quality']['average']:.1f}, Pass Rate: {summary_stats['clinical_quality']['pass_rate']:.1%}")
+    print(
+        f"Faithfulness - Average: {summary_stats['faithfulness']['average']:.3f}, Pass Rate: {summary_stats['faithfulness']['pass_rate']:.1%}"
+    )
+    print(
+        f"Clinical Quality - Average: {summary_stats['clinical_quality']['average']:.1f}, Pass Rate: {summary_stats['clinical_quality']['pass_rate']:.1%}"
+    )
 
 # Print comprehensive results
-print("\n" + "="*60)
+print("\n" + "=" * 60)
 print("COMPREHENSIVE EVALUATION RESULTS")
-print("="*60)
+print("=" * 60)
 
 for comparison_name, stats in evaluation_results.items():
     print(f"\n{comparison_name.replace('_', ' ').title()}:")
-    print(f"  Faithfulness: {stats['faithfulness']['average']:.3f} (Pass: {stats['faithfulness']['pass_rate']:.1%})")
-    print(f"  Clinical Quality: {stats['clinical_quality']['average']:.1f} (Pass: {stats['clinical_quality']['pass_rate']:.1%})")
+    print(
+        f"  Faithfulness: {stats['faithfulness']['average']:.3f} (Pass: {stats['faithfulness']['pass_rate']:.1%})"
+    )
+    print(
+        f"  Clinical Quality: {stats['clinical_quality']['average']:.1f} (Pass: {stats['clinical_quality']['pass_rate']:.1%})"
+    )
 
 # Prepare data for JSON export
 export_data = {
@@ -401,7 +400,7 @@ def format_medical_prompt(context, question):
         "total_test_cases": len(llm_test_data),
         "max_response_length": MAX_RESPONSE_LENGTH,
         "faithfulness_threshold": 0.9,
-        "clinical_quality_threshold": 0.7
+        "clinical_quality_threshold": 0.7,
     },
     "evaluation_results": evaluation_results,
     "test_responses": all_responses,
@@ -409,37 +408,45 @@ def format_medical_prompt(context, question):
         "slm_vs_llm_document": "Small Language Model vs Large Language Model using full document context",
         "slm_vs_llm_chunked": "Small Language Model vs Large Language Model using chunked context",
         "document_vs_chunked_slm": "Full document vs chunked context for Small Language Model",
-        "document_vs_chunked_llm": "Full document vs chunked context for Large Language Model"
-    }
+        "document_vs_chunked_llm": "Full document vs chunked context for Large Language Model",
+    },
 }
 
 # Save results to JSON
 output_filename = f"medical_llm_evaluation_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
 
-with open(output_filename, 'w', encoding='utf-8') as f:
+with open(output_filename, "w", encoding="utf-8") as f:
     json.dump(export_data, f, indent=2, ensure_ascii=False)
 
 print(f"\nResults saved to: {output_filename}")
 
 # Summary insights
-print("\n" + "="*60)
+print("\n" + "=" * 60)
 print("KEY INSIGHTS")
-print("="*60)
+print("=" * 60)
 
 # Compare SLM vs LLM performance
 slm_llm_doc = evaluation_results["slm_vs_llm_document"]
 slm_llm_chunk = evaluation_results["slm_vs_llm_chunked"]
 
-print(f"1. SLM Performance vs LLM:")
-print(f"   Document Context - Faithfulness: {slm_llm_doc['faithfulness']['average']:.3f}, Quality: {slm_llm_doc['clinical_quality']['average']:.1f}")
-print(f"   Chunked Context  - Faithfulness: {slm_llm_chunk['faithfulness']['average']:.3f}, Quality: {slm_llm_chunk['clinical_quality']['average']:.1f}")
+print("1. SLM Performance vs LLM:")
+print(
+    f"   Document Context - Faithfulness: {slm_llm_doc['faithfulness']['average']:.3f}, Quality: {slm_llm_doc['clinical_quality']['average']:.1f}"
+)
+print(
+    f"   Chunked Context  - Faithfulness: {slm_llm_chunk['faithfulness']['average']:.3f}, Quality: {slm_llm_chunk['clinical_quality']['average']:.1f}"
+)
 
 # Compare context types
 doc_chunk_slm = evaluation_results["document_vs_chunked_slm"]
 doc_chunk_llm = evaluation_results["document_vs_chunked_llm"]
 
-print(f"\n2. Context Type Impact:")
-print(f"   SLM: Document vs Chunked - Faithfulness: {doc_chunk_slm['faithfulness']['average']:.3f}, Quality: {doc_chunk_slm['clinical_quality']['average']:.1f}")
-print(f"   LLM: Document vs Chunked - Faithfulness: {doc_chunk_llm['faithfulness']['average']:.3f}, Quality: {doc_chunk_llm['clinical_quality']['average']:.1f}")
+print("\n2. Context Type Impact:")
+print(
+    f"   SLM: Document vs Chunked - Faithfulness: {doc_chunk_slm['faithfulness']['average']:.3f}, Quality: {doc_chunk_slm['clinical_quality']['average']:.1f}"
+)
+print(
+    f"   LLM: Document vs Chunked - Faithfulness: {doc_chunk_llm['faithfulness']['average']:.3f}, Quality: {doc_chunk_llm['clinical_quality']['average']:.1f}"
+)
 
-print(f"\nEvaluation complete! Check {output_filename} for detailed results.")
\ No newline at end of file
+print(f"\nEvaluation complete! Check {output_filename} for detailed results.")
diff --git a/src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py b/src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py
new file mode 100644
index 0000000..7b81ab8
--- /dev/null
+++ b/src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py
@@ -0,0 +1,291 @@
+"""
+Script for generating scatter plots comparing faithfulness and clinical quality from OpenEHR evaluation JSON files.
+"""
+
+import json
+
+import matplotlib
+import matplotlib.pyplot as plt
+
+# Set font parameters for PDF export
+matplotlib.rcParams["pdf.fonttype"] = 42
+matplotlib.rcParams["ps.fonttype"] = 42
+
+# UPDATE THESE WITH YOUR ACTUAL FILES
+model_json_pairs = [
+    ("TinyLlama", "data/ehr_eval/medical_llm_evaluation_tinyllama_complex.json"),
+    ("Phi-3-Mini-4k", "data/ehr_eval/medical_llm_evaluation_phi3_complex.json"),
+]
+
+
+def load_evaluation_data(model_json_pairs):
+    """
+    Load evaluation data from JSON files.
+
+    Args:
+        model_json_pairs: List of tuples (slm_model_name, json_file_path)
+
+    Returns:
+        Dictionary with model names as keys and evaluation data as values
+    """
+    evaluation_data = {}
+
+    for model_name, json_file in model_json_pairs:
+        try:
+            with open(json_file, encoding="utf-8") as f:
+                data = json.load(f)
+                evaluation_data[model_name] = data["evaluation_results"]
+                print(f"Loaded data for {model_name} from {json_file}")
+        except FileNotFoundError:
+            print(f"Warning: File {json_file} not found for model {model_name}")
+        except KeyError:
+            print(f"Warning: Invalid JSON structure in {json_file} for model {model_name}")
+
+    return evaluation_data
+
+
+def create_scatter_plot(evaluation_data, title, filename):
+    """
+    Create a scatter plot showing faithfulness vs clinical quality for all models and contexts.
+
+    Args:
+        evaluation_data: Dictionary with evaluation results
+        title: Plot title
+        filename: Output filename
+    """
+    # Set up the plot with appropriate figure size
+    fig, ax = plt.subplots(figsize=(10, 7))
+
+    # Define colors for each model (you can expand this list as needed)
+    colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f"]
+
+    # Define markers for document vs chunked
+    document_marker = "o"  # circle
+    chunked_marker = "s"  # square
+
+    # Track data for legend
+    model_handles = []
+    context_handles = []
+
+    # Extract and plot data for each model
+    for i, model in enumerate(evaluation_data.keys()):
+        color = colors[i % len(colors)]
+
+        # Process document context data
+        if "slm_vs_llm_document" in evaluation_data[model]:
+            doc_data = evaluation_data[model]["slm_vs_llm_document"]
+            doc_faithfulness = doc_data["faithfulness"]["average"] * 10  # Scale 0-1 to 0-10
+            doc_clinical = doc_data["clinical_quality"]["average"] * 10  # Scale 0-1 to 0-10
+
+            scatter_doc = ax.scatter(
+                doc_faithfulness,
+                doc_clinical,
+                c=color,
+                marker=document_marker,
+                s=200,
+                alpha=0.8,
+                edgecolors="black",
+                linewidth=1,
+            )
+
+        # Process chunked context data
+        if "slm_vs_llm_chunked" in evaluation_data[model]:
+            chunk_data = evaluation_data[model]["slm_vs_llm_chunked"]
+            chunk_faithfulness = chunk_data["faithfulness"]["average"] * 10  # Scale 0-1 to 0-10
+            chunk_clinical = chunk_data["clinical_quality"]["average"] * 10  # Scale 0-1 to 0-10
+
+            scatter_chunk = ax.scatter(
+                chunk_faithfulness,
+                chunk_clinical,
+                c=color,
+                marker=chunked_marker,
+                s=200,
+                alpha=0.8,
+                edgecolors="black",
+                linewidth=1,
+            )
+
+    # Customize the plot with larger fonts
+    ax.set_xlabel("Faithfulness Score (0-10)", fontsize=16, fontweight="bold")
+    ax.set_ylabel("Clinical Quality Score (0-10)", fontsize=16, fontweight="bold")
+    ax.set_title(title, fontsize=18, fontweight="bold", pad=20)
+
+    # Set axis limits and ticks
+    ax.set_xlim(0, 10)
+    ax.set_ylim(0, 10)
+    ax.set_xticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    ax.set_yticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    ax.tick_params(axis="both", which="major", labelsize=16)
+
+    # Add grid for better readability
+    ax.grid(True, alpha=0.3)
+    ax.set_axisbelow(True)
+
+    # Create custom legend
+    # Legend for context types
+    from matplotlib.lines import Line2D
+
+    context_legend_elements = [
+        Line2D(
+            [0],
+            [0],
+            marker=document_marker,
+            color="gray",
+            linestyle="None",
+            markersize=12,
+            markerfacecolor="gray",
+            markeredgecolor="black",
+            label="Document Context",
+        ),
+        Line2D(
+            [0],
+            [0],
+            marker=chunked_marker,
+            color="gray",
+            linestyle="None",
+            markersize=12,
+            markerfacecolor="gray",
+            markeredgecolor="black",
+            label="Chunked Context",
+        ),
+    ]
+
+    # Legend for models
+    model_legend_elements = []
+    for i, model in enumerate(evaluation_data.keys()):
+        color = colors[i % len(colors)]
+        model_legend_elements.append(
+            Line2D(
+                [0],
+                [0],
+                marker="o",
+                color="white",
+                linestyle="None",
+                markersize=12,
+                markerfacecolor=color,
+                markeredgecolor="black",
+                label=model,
+            )
+        )
+
+    # Create two separate legends
+    context_legend = ax.legend(
+        handles=context_legend_elements,
+        title="Context Type",
+        title_fontsize=14,
+        fontsize=12,
+        loc="upper right",
+        bbox_to_anchor=(1.45, 1.0),
+    )
+    context_legend.get_title().set_fontweight("bold")
+
+    model_legend = ax.legend(
+        handles=model_legend_elements,
+        title="Models",
+        title_fontsize=14,
+        fontsize=12,
+        loc="upper right",
+        bbox_to_anchor=(1.45, 0.7),
+    )
+    model_legend.get_title().set_fontweight("bold")
+
+    # Add the first legend back (matplotlib removes it when adding the second)
+    ax.add_artist(context_legend)
+
+    # Add reference lines at common thresholds
+    ax.axhline(y=7.0, color="red", linestyle="--", alpha=0.5, linewidth=1)
+    ax.axvline(x=9.0, color="blue", linestyle="--", alpha=0.5, linewidth=1)
+
+    # Add threshold labels
+    ax.text(0.2, 7.2, "Clinical Quality Threshold", fontsize=12, color="red", alpha=0.7, fontweight="bold")
+    ax.text(
+        9.2,
+        0.5,
+        "Faithfulness Threshold",
+        fontsize=12,
+        color="blue",
+        alpha=0.7,
+        fontweight="bold",
+        rotation=90,
+    )
+
+    # Adjust layout and save
+    plt.tight_layout()
+    plt.savefig(filename, format="pdf", dpi=300, bbox_inches="tight")
+    plt.show()
+
+    # Print summary statistics
+    print(f"\n{title} - Summary Statistics:")
+    print("-" * 60)
+    for model in evaluation_data.keys():
+        print(f"{model}:")
+
+        if "slm_vs_llm_document" in evaluation_data[model]:
+            doc_data = evaluation_data[model]["slm_vs_llm_document"]
+            doc_faithfulness = doc_data["faithfulness"]["average"] * 10
+            doc_clinical = doc_data["clinical_quality"]["average"] * 10
+            print(
+                f"  Document Context - Faithfulness: {doc_faithfulness:.2f}, Clinical Quality: {doc_clinical:.2f}"
+            )
+
+        if "slm_vs_llm_chunked" in evaluation_data[model]:
+            chunk_data = evaluation_data[model]["slm_vs_llm_chunked"]
+            chunk_faithfulness = chunk_data["faithfulness"]["average"] * 10
+            chunk_clinical = chunk_data["clinical_quality"]["average"] * 10
+            print(
+                f"  Chunked Context  - Faithfulness: {chunk_faithfulness:.2f}, Clinical Quality: {chunk_clinical:.2f}"
+            )
+
+        print()
+
+
+def main():
+    """
+    Main function to generate scatter plot from evaluation JSON files.
+    """
+    print("Medical LLM Evaluation Results - Scatter Plot Generation")
+    print("=" * 60)
+
+    # Load evaluation data
+    evaluation_data = load_evaluation_data(model_json_pairs)
+
+    if not evaluation_data:
+        print("No evaluation data loaded. Please check your file paths.")
+        return
+
+    # Create scatter plot
+    print(f"\nGenerating scatter plot for {len(evaluation_data)} models...")
+
+    create_scatter_plot(
+        evaluation_data=evaluation_data,
+        title="SLM Performance: Faithfulness vs Clinical Quality Comparison",
+        filename="slm_performance_scatter_plot.pdf",
+    )
+
+    print("\nScatter plot generated successfully!")
+    print("File created: slm_performance_scatter_plot.pdf")
+
+
+def plot_evaluation_results(model_json_pairs):
+    """
+    Convenient function to plot results with custom model-json pairs.
+
+    Args:
+        model_json_pairs: List of tuples (model_name, json_file_path)
+    """
+    evaluation_data = load_evaluation_data(model_json_pairs)
+
+    if not evaluation_data:
+        print("No evaluation data loaded. Please check your file paths.")
+        return
+
+    # Create scatter plot
+    create_scatter_plot(
+        evaluation_data=evaluation_data,
+        title="SLM Performance: Faithfulness vs Clinical Quality Comparison",
+        filename="slm_performance_scatter_plot.pdf",
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mobiletransformers/exceptions.py b/src/mobiletransformers/exceptions.py
new file mode 100644
index 0000000..e0f4439
--- /dev/null
+++ b/src/mobiletransformers/exceptions.py
@@ -0,0 +1,57 @@
+"""MobileTransformers Python exception hierarchy.
+
+Deliberately parallel to the Kotlin facade's ``MobileTransformersException`` hierarchy
+so errors read the same on both sides.
+Library code raises a typed subclass — never a bare ``Exception``.
+"""
+
+from __future__ import annotations
+
+
+class MobileTransformersError(Exception):
+    """Root of every MobileTransformers error. Catch this to catch anything the library raises."""
+
+
+class ConfigValidationError(MobileTransformersError):
+    """A config object or file failed validation (bad/missing/typed-wrong fields)."""
+
+
+class ExportError(MobileTransformersError):
+    """An ONNX/GenAI/mobile export step failed."""
+
+
+class ManifestError(MobileTransformersError):
+    """A ``mobiletransformers_manifest.json`` is missing, malformed, or version-incompatible."""
+
+
+class NoCompatibleVariant(ManifestError):
+    """No package variant satisfies the requested device capabilities / features / engine."""
+
+
+class HandoffError(MobileTransformersError):
+    """A ``weight_handoff_map.json`` lookup/contract could not be satisfied."""
+
+
+class MergeError(MobileTransformersError):
+    """An adapter/weight merge (offline or on-device) failed."""
+
+
+class UnsupportedModelError(MobileTransformersError):
+    """The requested architecture/task/feature is not supported in this version."""
+
+
+class HubError(MobileTransformersError):
+    """A Hugging Face Hub download/upload/auth operation failed."""
+
+
+__all__ = [
+    "MobileTransformersError",
+    "ConfigValidationError",
+    "ExportError",
+    "ManifestError",
+    "NoCompatibleVariant",
+    "HandoffError",
+    "MergeError",
+    "UnsupportedModelError",
+    "HubError",
+]
diff --git a/peft_models/lora_xs/__init__.py b/src/mobiletransformers/export/__init__.py
similarity index 100%
rename from peft_models/lora_xs/__init__.py
rename to src/mobiletransformers/export/__init__.py
diff --git a/trainer/embedding_builder.py b/src/mobiletransformers/export/embedding_export.py
similarity index 83%
rename from trainer/embedding_builder.py
rename to src/mobiletransformers/export/embedding_export.py
index 887cd98..aed6591 100644
--- a/trainer/embedding_builder.py
+++ b/src/mobiletransformers/export/embedding_export.py
@@ -1,27 +1,31 @@
+# DECOMPOSE(#5): fold encoder/embedding export into src/mobiletransformers/export behind the
+# task/architecture registry (#6), consumed by encoder support (#33). ~27 KB.
 import json
+
 import onnx
-from onnx import helper, TensorProto
 from huggingface_hub import hf_hub_download
+from onnx import TensorProto, helper
+
 
 def add_pooling_to_onnx_model(model, model_id, output_model_path):
     """
     Add pooling operations to an ONNX model based on sentence-transformer configuration.
-    
+
     Args:
         onnx_model_path (str): Path to the original ONNX model
         model_id (str): HuggingFace model ID (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
         output_model_path (str): Path where the modified ONNX model will be saved
-    
+
     Returns:
         str: Path to the modified ONNX model
     """
-    
+
     # Load pooling configuration from HuggingFace Hub
     pooling_config = load_pooling_config_from_hub(model_id)
-    
+
     # Add pooling operations to the model
     modified_model = add_pooling_operations(model, pooling_config)
-    
+
     # Validate the modified model before saving
     try:
         onnx.checker.check_model(modified_model)
@@ -29,7 +33,7 @@ def add_pooling_to_onnx_model(model, model_id, output_model_path):
     except onnx.checker.ValidationError as e:
         print(f"✗ Model validation failed: {e}")
         raise ValueError(f"Modified ONNX model is invalid: {e}")
-    
+
     # Additional shape inference to ensure output shapes are correct
     try:
         modified_model = onnx.shape_inference.infer_shapes(modified_model)
@@ -37,7 +41,7 @@ def add_pooling_to_onnx_model(model, model_id, output_model_path):
     except Exception as e:
         print(f"⚠ Warning: Shape inference failed: {e}")
         print("Model may still work, but output shapes might not be fully inferred")
-    
+
     # Add some metadata to model
     word_embedding_dim = pooling_config.get("word_embedding_dimension", None)
 
@@ -47,7 +51,7 @@ def add_pooling_to_onnx_model(model, model_id, output_model_path):
         model_metadata_entry.key = "embedding_dim"
         model_metadata_entry.value = str(model_id)
         model.metadata_props.append(model_metadata_entry)
-        
+
         # Add metadata to graph level
         graph_metadata_entry = onnx.StringStringEntryProto()
         graph_metadata_entry.key = "embedding_dim"
@@ -57,21 +61,22 @@ def add_pooling_to_onnx_model(model, model_id, output_model_path):
     # Save the modified model
     onnx.save(modified_model, output_model_path)
     print(f"✓ Model saved successfully to: {output_model_path}")
-    
+
     # Print summary of what was added
     print_pooling_summary(pooling_config)
-    
+
     return output_model_path
 
+
 def print_pooling_summary(pooling_config):
     """Print a summary of the pooling configuration that was applied."""
-    print("\n" + "="*50)
+    print("\n" + "=" * 50)
     print("POOLING CONFIGURATION SUMMARY")
-    print("="*50)
-    
+    print("=" * 50)
+
     word_dim = pooling_config.get("word_embedding_dimension", "unknown")
     print(f"Word embedding dimension: {word_dim}")
-    
+
     active_modes = []
     if pooling_config.get("pooling_mode_cls_token", False):
         active_modes.append("CLS token")
@@ -81,33 +86,35 @@ def print_pooling_summary(pooling_config):
         active_modes.append("Max tokens")
     if pooling_config.get("pooling_mode_mean_sqrt_len_tokens", False):
         active_modes.append("Mean sqrt length")
-    
+
     print(f"Active pooling modes: {', '.join(active_modes)}")
-    
+
     if len(active_modes) > 1:
         total_dim = word_dim * len(active_modes) if isinstance(word_dim, int) else "unknown"
         print(f"Final output dimension: {total_dim} (concatenated)")
     else:
         print(f"Final output dimension: {word_dim}")
-    
+
     print(f"Input shape: [batch_size, sequence_length, {word_dim}]")
-    final_dim = word_dim * len(active_modes) if isinstance(word_dim, int) and len(active_modes) > 0 else word_dim
+    final_dim = (
+        word_dim * len(active_modes) if isinstance(word_dim, int) and len(active_modes) > 0 else word_dim
+    )
     print(f"Output shape: [batch_size, {final_dim}]")
-    print("="*50)
+    print("=" * 50)
 
 
 def load_pooling_config_from_hub(model_id):
     """
     Load pooling configuration from HuggingFace Hub without downloading the full model.
-    
+
     Args:
         model_id (str): HuggingFace model ID (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
-        
+
     Returns:
         dict: Pooling configuration
     """
     pooling_config = None
-    
+
     try:
         # First, try to download modules.json to get the exact module structure
         modules_path = hf_hub_download(
@@ -115,15 +122,15 @@ def load_pooling_config_from_hub(model_id):
             filename="modules.json",
             cache_dir=None,  # Use default cache
         )
-        
-        with open(modules_path, 'r') as f:
+
+        with open(modules_path) as f:
             modules = json.load(f)
-        
+
         # Look for pooling module in modules.json
         for module in modules:
             if module.get("type") == "sentence_transformers.models.Pooling":
                 pooling_dir = module.get("path", "")
-                
+
                 # Download the pooling config
                 try:
                     config_path = hf_hub_download(
@@ -131,25 +138,25 @@ def load_pooling_config_from_hub(model_id):
                         filename=f"{pooling_dir}/config.json",
                         cache_dir=None,
                     )
-                    
-                    with open(config_path, 'r') as f:
+
+                    with open(config_path) as f:
                         pooling_config = json.load(f)
                     break
                 except Exception:
                     continue  # Try next module if this one fails
-                    
+
     except Exception:
         # modules.json not found or failed to download
         pass
-    
+
     # Fallback: try standard locations if modules.json approach didn't work
     if pooling_config is None:
         config_files = [
             "1_Pooling/config.json",  # Standard sentence-transformers structure
             "2_Pooling/config.json",  # Alternative numbering
-            "pooling/config.json",    # Alternative naming
+            "pooling/config.json",  # Alternative naming
         ]
-        
+
         for config_file in config_files:
             try:
                 config_path = hf_hub_download(
@@ -157,16 +164,16 @@ def load_pooling_config_from_hub(model_id):
                     filename=config_file,
                     cache_dir=None,
                 )
-                
-                with open(config_path, 'r') as f:
+
+                with open(config_path) as f:
                     config = json.load(f)
                     # Check if this config contains pooling information
-                    if any(key.startswith('pooling_mode_') for key in config.keys()):
+                    if any(key.startswith("pooling_mode_") for key in config.keys()):
                         pooling_config = config
                         break
             except Exception:
                 continue  # File doesn't exist, try next
-    
+
     # If still no config, try to get from sentence_transformers_config.json
     if pooling_config is None:
         try:
@@ -175,15 +182,15 @@ def load_pooling_config_from_hub(model_id):
                 filename="sentence_transformers_config.json",
                 cache_dir=None,
             )
-            
-            with open(st_config_path, 'r') as f:
+
+            with open(st_config_path) as f:
                 st_config = json.load(f)
                 # Sometimes pooling info is embedded here
                 if "pooling" in st_config:
                     pooling_config = st_config["pooling"]
         except Exception:
             pass
-    
+
     # Last resort: try to infer from main config.json
     if pooling_config is None:
         try:
@@ -192,15 +199,15 @@ def load_pooling_config_from_hub(model_id):
                 filename="config.json",
                 cache_dir=None,
             )
-            
-            with open(main_config_path, 'r') as f:
+
+            with open(main_config_path) as f:
                 config = json.load(f)
                 # Check if this config contains pooling information
-                if any(key.startswith('pooling_mode_') for key in config.keys()):
+                if any(key.startswith("pooling_mode_") for key in config.keys()):
                     pooling_config = config
         except Exception:
             pass
-    
+
     if pooling_config is None:
         # Try to get word_embedding_dimension from transformer config as fallback
         try:
@@ -209,63 +216,65 @@ def load_pooling_config_from_hub(model_id):
                 filename="0_Transformer/config.json",
                 cache_dir=None,
             )
-            
-            with open(transformer_config_path, 'r') as f:
+
+            with open(transformer_config_path) as f:
                 transformer_config = json.load(f)
                 hidden_size = transformer_config.get("hidden_size", 384)
-                
+
                 # Create default pooling config (mean pooling)
                 pooling_config = {
                     "word_embedding_dimension": hidden_size,
                     "pooling_mode_cls_token": False,
                     "pooling_mode_mean_tokens": True,
                     "pooling_mode_max_tokens": False,
-                    "pooling_mode_mean_sqrt_len_tokens": False
+                    "pooling_mode_mean_sqrt_len_tokens": False,
                 }
-                
-                print(f"Warning: No pooling config found for {model_id}. "
-                      f"Using default mean pooling with dimension {hidden_size}")
-                
+
+                print(
+                    f"Warning: No pooling config found for {model_id}. "
+                    f"Using default mean pooling with dimension {hidden_size}"
+                )
+
         except Exception:
             raise FileNotFoundError(
                 f"Could not find pooling configuration for model '{model_id}'. "
                 f"Please check if this is a valid sentence-transformers model or "
                 f"manually provide the pooling configuration."
             )
-    
+
     return pooling_config
 
 
 def add_pooling_operations(model, pooling_config):
     """
     Add pooling operations to the ONNX model graph.
-    
+
     Args:
         model: ONNX model
         pooling_config (dict): Pooling configuration
-        
+
     Returns:
         Modified ONNX model
     """
     graph = model.graph
-    
+
     # Find the last_hidden_state output
     last_hidden_state_output = None
     for output in graph.output:
         if output.name == "last_hidden_state":
             last_hidden_state_output = output
             break
-    
+
     if last_hidden_state_output is None:
         raise ValueError("Could not find 'last_hidden_state' output in the model")
-    
+
     # Get the word embedding dimension
     word_embedding_dim = pooling_config.get("word_embedding_dimension", 384)
-    
+
     # Create pooling operations based on configuration
     pooling_outputs = []
     nodes_to_add = []
-    
+
     # We need attention_mask as input for proper pooling
     # Add attention_mask as a graph input if not already present
     attention_mask_input = None
@@ -273,36 +282,36 @@ def add_pooling_operations(model, pooling_config):
         if input_info.name == "attention_mask":
             attention_mask_input = input_info
             break
-    
+
     if attention_mask_input is None:
         # Add attention_mask as input
         attention_mask_input = helper.make_tensor_value_info(
-            "attention_mask",
-            TensorProto.INT64,
-            ["batch_size", "sequence_length"]
+            "attention_mask", TensorProto.INT64, ["batch_size", "sequence_length"]
         )
         graph.input.append(attention_mask_input)
-    
+
     # CLS token pooling
     if pooling_config.get("pooling_mode_cls_token", False):
         cls_output = add_cls_pooling(graph, "last_hidden_state", nodes_to_add)
         pooling_outputs.append(cls_output)
-    
+
     # Mean token pooling
     if pooling_config.get("pooling_mode_mean_tokens", False):
         mean_output = add_mean_pooling(graph, "last_hidden_state", "attention_mask", nodes_to_add)
         pooling_outputs.append(mean_output)
-    
+
     # Max token pooling
     if pooling_config.get("pooling_mode_max_tokens", False):
         max_output = add_max_pooling(graph, "last_hidden_state", "attention_mask", nodes_to_add)
         pooling_outputs.append(max_output)
-    
+
     # Mean sqrt length pooling
     if pooling_config.get("pooling_mode_mean_sqrt_len_tokens", False):
-        mean_sqrt_output = add_mean_sqrt_len_pooling(graph, "last_hidden_state", "attention_mask", nodes_to_add)
+        mean_sqrt_output = add_mean_sqrt_len_pooling(
+            graph, "last_hidden_state", "attention_mask", nodes_to_add
+        )
         pooling_outputs.append(mean_sqrt_output)
-    
+
     # If multiple pooling modes are enabled, concatenate them
     if len(pooling_outputs) > 1:
         final_output = add_concatenation(graph, pooling_outputs, nodes_to_add)
@@ -312,31 +321,26 @@ def add_pooling_operations(model, pooling_config):
         final_dim = word_embedding_dim
     else:
         raise ValueError("No pooling mode is enabled in the configuration")
-    
+
     # Add all nodes to the graph
     graph.node.extend(nodes_to_add)
-    
+
     # Remove the original last_hidden_state from outputs
     graph.output.remove(last_hidden_state_output)
-    
+
     # Add the new embedding output
     embedding_output = helper.make_tensor_value_info(
-        "embedding",
-        TensorProto.FLOAT,
-        ["batch_size", final_dim]
+        "embedding", TensorProto.FLOAT, ["batch_size", final_dim]
     )
     graph.output.append(embedding_output)
-    
+
     # Rename the final output to "embedding"
     if final_output != "embedding":
         rename_node = helper.make_node(
-            "Identity",
-            inputs=[final_output],
-            outputs=["embedding"],
-            name="rename_to_embedding"
+            "Identity", inputs=[final_output], outputs=["embedding"], name="rename_to_embedding"
         )
         graph.node.append(rename_node)
-    
+
     return model
 
 
@@ -345,58 +349,53 @@ def add_cls_pooling(graph, input_name, nodes_to_add):
     # Extract the first token (CLS token) from the sequence
     # Input shape: [batch_size, sequence_length, hidden_dim]
     # Output shape: [batch_size, hidden_dim]
-    
+
     # Create constant for indices [0] to select first token
-    indices_tensor = helper.make_tensor(
-        name="cls_indices",
-        data_type=TensorProto.INT64,
-        dims=[1],
-        vals=[0]
-    )
+    indices_tensor = helper.make_tensor(name="cls_indices", data_type=TensorProto.INT64, dims=[1], vals=[0])
     indices_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["cls_indices_const"],
         value=indices_tensor,
-        name="cls_indices_constant"
+        name="cls_indices_constant",
     )
     nodes_to_add.append(indices_node)
-    
+
     # Use Gather to extract first token
     gather_node = helper.make_node(
         "Gather",
         inputs=[input_name, "cls_indices_const"],
         outputs=["cls_pooled"],
         axis=1,  # Gather along sequence dimension
-        name="cls_gather"
+        name="cls_gather",
     )
     nodes_to_add.append(gather_node)
-    
+
     # Create axes tensor for squeeze operation
     squeeze_axes_tensor = helper.make_tensor(
         name="squeeze_axes",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Squeeze dimension 1
+        vals=[1],  # Squeeze dimension 1
     )
     squeeze_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["squeeze_axes_const"],
         value=squeeze_axes_tensor,
-        name="squeeze_axes_constant"
+        name="squeeze_axes_constant",
     )
     nodes_to_add.append(squeeze_axes_node)
-    
+
     # Squeeze to remove the sequence dimension
     squeeze_node = helper.make_node(
         "Squeeze",
         inputs=["cls_pooled", "squeeze_axes_const"],
         outputs=["cls_pooled_squeezed"],
-        name="cls_squeeze"
+        name="cls_squeeze",
     )
     nodes_to_add.append(squeeze_node)
-    
+
     return "cls_pooled_squeezed"
 
 
@@ -408,106 +407,106 @@ def add_mean_pooling(graph, input_name, attention_mask_name, nodes_to_add):
         inputs=[attention_mask_name],
         outputs=["attention_mask_float"],
         to=TensorProto.FLOAT,
-        name="cast_attention_mask"
+        name="cast_attention_mask",
     )
     nodes_to_add.append(cast_mask_node)
-    
+
     # Create axes tensor for unsqueeze operation
     unsqueeze_axes_tensor = helper.make_tensor(
         name="unsqueeze_axes_mean",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[2]  # Unsqueeze at dimension 2
+        vals=[2],  # Unsqueeze at dimension 2
     )
     unsqueeze_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["unsqueeze_axes_const_mean"],
         value=unsqueeze_axes_tensor,
-        name="unsqueeze_axes_constant_mean"
+        name="unsqueeze_axes_constant_mean",
     )
     nodes_to_add.append(unsqueeze_axes_node)
-    
+
     # Expand attention mask to match hidden state dimensions
     # Shape: [batch_size, sequence_length] -> [batch_size, sequence_length, 1]
     unsqueeze_node = helper.make_node(
         "Unsqueeze",
         inputs=["attention_mask_float", "unsqueeze_axes_const_mean"],
         outputs=["attention_mask_expanded"],
-        name="unsqueeze_attention_mask"
+        name="unsqueeze_attention_mask",
     )
     nodes_to_add.append(unsqueeze_node)
-    
+
     # Multiply hidden states with attention mask
     mul_node = helper.make_node(
         "Mul",
         inputs=[input_name, "attention_mask_expanded"],
         outputs=["masked_hidden_states"],
-        name="apply_attention_mask"
+        name="apply_attention_mask",
     )
     nodes_to_add.append(mul_node)
-    
+
     # Create axes tensor for ReduceSum (sequence dimension = 1)
     sum_axes_tensor = helper.make_tensor(
         name="sum_axes_mean",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Sum along sequence dimension
+        vals=[1],  # Sum along sequence dimension
     )
     sum_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["sum_axes_const_mean"],
         value=sum_axes_tensor,
-        name="sum_axes_constant_mean"
+        name="sum_axes_constant_mean",
     )
     nodes_to_add.append(sum_axes_node)
-    
+
     # Sum along sequence dimension
     sum_node = helper.make_node(
         "ReduceSum",
         inputs=["masked_hidden_states", "sum_axes_const_mean"],
         outputs=["summed_hidden_states"],
         keepdims=0,
-        name="sum_hidden_states"
+        name="sum_hidden_states",
     )
     nodes_to_add.append(sum_node)
-    
+
     # Create axes tensor for summing attention mask
     mask_sum_axes_tensor = helper.make_tensor(
         name="mask_sum_axes_mean",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Sum along sequence dimension
+        vals=[1],  # Sum along sequence dimension
     )
     mask_sum_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["mask_sum_axes_const_mean"],
         value=mask_sum_axes_tensor,
-        name="mask_sum_axes_constant_mean"
+        name="mask_sum_axes_constant_mean",
     )
     nodes_to_add.append(mask_sum_axes_node)
-    
+
     # Sum attention mask to get sequence lengths
     sum_mask_node = helper.make_node(
         "ReduceSum",
         inputs=["attention_mask_float", "mask_sum_axes_const_mean"],
         outputs=["sequence_lengths"],
         keepdims=1,
-        name="sum_attention_mask"
+        name="sum_attention_mask",
     )
     nodes_to_add.append(sum_mask_node)
-    
+
     # Divide by sequence lengths to get mean
     div_node = helper.make_node(
         "Div",
         inputs=["summed_hidden_states", "sequence_lengths"],
         outputs=["mean_pooled"],
-        name="mean_division"
+        name="mean_division",
     )
     nodes_to_add.append(div_node)
-    
+
     return "mean_pooled"
 
 
@@ -519,119 +518,105 @@ def add_max_pooling(graph, input_name, attention_mask_name, nodes_to_add):
         inputs=[attention_mask_name],
         outputs=["attention_mask_float_max"],
         to=TensorProto.FLOAT,
-        name="cast_attention_mask_max"
+        name="cast_attention_mask_max",
     )
     nodes_to_add.append(cast_mask_node)
-    
+
     # Create a large negative value for masked positions
     neg_inf_tensor = helper.make_tensor(
-        name="neg_inf_value_max",
-        data_type=TensorProto.FLOAT,
-        dims=[],
-        vals=[-1e9]
+        name="neg_inf_value_max", data_type=TensorProto.FLOAT, dims=[], vals=[-1e9]
     )
     neg_inf_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["neg_inf_const_max"],
         value=neg_inf_tensor,
-        name="negative_infinity_max"
+        name="negative_infinity_max",
     )
     nodes_to_add.append(neg_inf_node)
-    
+
     # Create axes tensor for unsqueeze operation
     unsqueeze_axes_tensor_max = helper.make_tensor(
         name="unsqueeze_axes_max",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[2]  # Unsqueeze at dimension 2
+        vals=[2],  # Unsqueeze at dimension 2
     )
     unsqueeze_axes_node_max = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["unsqueeze_axes_const_max"],
         value=unsqueeze_axes_tensor_max,
-        name="unsqueeze_axes_constant_max"
+        name="unsqueeze_axes_constant_max",
     )
     nodes_to_add.append(unsqueeze_axes_node_max)
-    
+
     # Expand attention mask
     unsqueeze_max_node = helper.make_node(
         "Unsqueeze",
         inputs=["attention_mask_float_max", "unsqueeze_axes_const_max"],
         outputs=["attention_mask_expanded_max"],
-        name="unsqueeze_attention_mask_max"
+        name="unsqueeze_attention_mask_max",
     )
     nodes_to_add.append(unsqueeze_max_node)
-    
+
     # Create mask for padding positions (1 - attention_mask)
     one_tensor_max = helper.make_tensor(
-        name="one_value_max",
-        data_type=TensorProto.FLOAT,
-        dims=[],
-        vals=[1.0]
+        name="one_value_max", data_type=TensorProto.FLOAT, dims=[], vals=[1.0]
     )
     one_node_max = helper.make_node(
-        "Constant",
-        inputs=[],
-        outputs=["one_const_max"],
-        value=one_tensor_max,
-        name="one_constant_max"
+        "Constant", inputs=[], outputs=["one_const_max"], value=one_tensor_max, name="one_constant_max"
     )
     nodes_to_add.append(one_node_max)
-    
+
     sub_node = helper.make_node(
         "Sub",
         inputs=["one_const_max", "attention_mask_expanded_max"],
         outputs=["padding_mask_max"],
-        name="create_padding_mask_max"
+        name="create_padding_mask_max",
     )
     nodes_to_add.append(sub_node)
-    
+
     # Multiply padding mask with negative infinity
     mul_neg_inf_node = helper.make_node(
         "Mul",
         inputs=["padding_mask_max", "neg_inf_const_max"],
         outputs=["neg_inf_mask_max"],
-        name="multiply_neg_inf_max"
+        name="multiply_neg_inf_max",
     )
     nodes_to_add.append(mul_neg_inf_node)
-    
+
     # Add to hidden states (this sets padding positions to -inf)
     add_mask_node = helper.make_node(
         "Add",
         inputs=[input_name, "neg_inf_mask_max"],
         outputs=["masked_hidden_states_max"],
-        name="add_neg_inf_mask_max"
+        name="add_neg_inf_mask_max",
     )
     nodes_to_add.append(add_mask_node)
-    
+
     # Create axes tensor for ReduceMax (sequence dimension = 1)
     max_axes_tensor = helper.make_tensor(
         name="max_axes",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Max along sequence dimension
+        vals=[1],  # Max along sequence dimension
     )
     max_axes_node = helper.make_node(
-        "Constant",
-        inputs=[],
-        outputs=["max_axes_const"],
-        value=max_axes_tensor,
-        name="max_axes_constant"
+        "Constant", inputs=[], outputs=["max_axes_const"], value=max_axes_tensor, name="max_axes_constant"
     )
     nodes_to_add.append(max_axes_node)
-    
+
     # Max pooling along sequence dimension
     max_node = helper.make_node(
         "ReduceMax",
         inputs=["masked_hidden_states_max", "max_axes_const"],
         outputs=["max_pooled"],
         keepdims=0,
-        name="max_pooling"
+        name="max_pooling",
     )
     nodes_to_add.append(max_node)
-    
+
     return "max_pooled"
 
 
@@ -643,45 +628,42 @@ def add_mean_sqrt_len_pooling(graph, input_name, attention_mask_name, nodes_to_a
         inputs=[attention_mask_name],
         outputs=["attention_mask_float_sqrt"],
         to=TensorProto.FLOAT,
-        name="cast_attention_mask_sqrt"
+        name="cast_attention_mask_sqrt",
     )
     nodes_to_add.append(cast_mask_sqrt_node)
-    
+
     # Create axes tensor for sum operation
     sqrt_sum_axes_tensor = helper.make_tensor(
         name="sqrt_sum_axes",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Sum along sequence dimension
+        vals=[1],  # Sum along sequence dimension
     )
     sqrt_sum_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["sqrt_sum_axes_const"],
         value=sqrt_sum_axes_tensor,
-        name="sqrt_sum_axes_constant"
+        name="sqrt_sum_axes_constant",
     )
     nodes_to_add.append(sqrt_sum_axes_node)
-    
+
     # Sum attention mask to get sequence lengths
     sum_mask_sqrt_node = helper.make_node(
         "ReduceSum",
         inputs=["attention_mask_float_sqrt", "sqrt_sum_axes_const"],
         outputs=["sequence_lengths_sqrt"],
         keepdims=1,
-        name="sum_attention_mask_sqrt"
+        name="sum_attention_mask_sqrt",
     )
     nodes_to_add.append(sum_mask_sqrt_node)
-    
+
     # Calculate sqrt of sequence lengths
     sqrt_node = helper.make_node(
-        "Sqrt",
-        inputs=["sequence_lengths_sqrt"],
-        outputs=["sqrt_sequence_lengths"],
-        name="sqrt_lengths"
+        "Sqrt", inputs=["sequence_lengths_sqrt"], outputs=["sqrt_sequence_lengths"], name="sqrt_lengths"
     )
     nodes_to_add.append(sqrt_node)
-    
+
     # First get regular mean pooled output (reuse the function logic inline)
     # Convert attention mask to float for multiplication
     cast_mask_node = helper.make_node(
@@ -689,88 +671,88 @@ def add_mean_sqrt_len_pooling(graph, input_name, attention_mask_name, nodes_to_a
         inputs=[attention_mask_name],
         outputs=["attention_mask_float_sqrt_mean"],
         to=TensorProto.FLOAT,
-        name="cast_attention_mask_sqrt_mean"
+        name="cast_attention_mask_sqrt_mean",
     )
     nodes_to_add.append(cast_mask_node)
-    
+
     # Create axes tensor for unsqueeze operation
     unsqueeze_axes_tensor = helper.make_tensor(
         name="unsqueeze_axes_sqrt_mean",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[2]  # Unsqueeze at dimension 2
+        vals=[2],  # Unsqueeze at dimension 2
     )
     unsqueeze_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["unsqueeze_axes_const_sqrt_mean"],
         value=unsqueeze_axes_tensor,
-        name="unsqueeze_axes_constant_sqrt_mean"
+        name="unsqueeze_axes_constant_sqrt_mean",
     )
     nodes_to_add.append(unsqueeze_axes_node)
-    
+
     # Expand attention mask
     unsqueeze_node = helper.make_node(
         "Unsqueeze",
         inputs=["attention_mask_float_sqrt_mean", "unsqueeze_axes_const_sqrt_mean"],
         outputs=["attention_mask_expanded_sqrt_mean"],
-        name="unsqueeze_attention_mask_sqrt_mean"
+        name="unsqueeze_attention_mask_sqrt_mean",
     )
     nodes_to_add.append(unsqueeze_node)
-    
+
     # Multiply hidden states with attention mask
     mul_node = helper.make_node(
         "Mul",
         inputs=[input_name, "attention_mask_expanded_sqrt_mean"],
         outputs=["masked_hidden_states_sqrt_mean"],
-        name="apply_attention_mask_sqrt_mean"
+        name="apply_attention_mask_sqrt_mean",
     )
     nodes_to_add.append(mul_node)
-    
+
     # Create axes tensor for ReduceSum
     sum_axes_tensor = helper.make_tensor(
         name="sum_axes_sqrt_mean",
         data_type=TensorProto.INT64,
         dims=[1],
-        vals=[1]  # Sum along sequence dimension
+        vals=[1],  # Sum along sequence dimension
     )
     sum_axes_node = helper.make_node(
         "Constant",
         inputs=[],
         outputs=["sum_axes_const_sqrt_mean"],
         value=sum_axes_tensor,
-        name="sum_axes_constant_sqrt_mean"
+        name="sum_axes_constant_sqrt_mean",
     )
     nodes_to_add.append(sum_axes_node)
-    
+
     # Sum along sequence dimension
     sum_node = helper.make_node(
         "ReduceSum",
         inputs=["masked_hidden_states_sqrt_mean", "sum_axes_const_sqrt_mean"],
         outputs=["summed_hidden_states_sqrt_mean"],
         keepdims=0,
-        name="sum_hidden_states_sqrt_mean"
+        name="sum_hidden_states_sqrt_mean",
     )
     nodes_to_add.append(sum_node)
-    
+
     # Divide summed by sequence lengths to get mean
     div_mean_node = helper.make_node(
         "Div",
         inputs=["summed_hidden_states_sqrt_mean", "sequence_lengths_sqrt"],
         outputs=["mean_pooled_sqrt"],
-        name="mean_division_sqrt"
+        name="mean_division_sqrt",
     )
     nodes_to_add.append(div_mean_node)
-    
+
     # Divide mean pooled output by sqrt of sequence length
     div_sqrt_node = helper.make_node(
         "Div",
         inputs=["mean_pooled_sqrt", "sqrt_sequence_lengths"],
         outputs=["mean_sqrt_len_pooled"],
-        name="divide_by_sqrt_length"
+        name="divide_by_sqrt_length",
     )
     nodes_to_add.append(div_sqrt_node)
-    
+
     return "mean_sqrt_len_pooled"
 
 
@@ -781,10 +763,10 @@ def add_concatenation(graph, pooling_outputs, nodes_to_add):
         inputs=pooling_outputs,
         outputs=["concatenated_pooling"],
         axis=1,  # Concatenate along feature dimension
-        name="concatenate_pooling_outputs"
+        name="concatenate_pooling_outputs",
     )
     nodes_to_add.append(concat_node)
-    
+
     return "concatenated_pooling"
 
 
@@ -794,5 +776,5 @@ def add_concatenation(graph, pooling_outputs, nodes_to_add):
     add_pooling_to_onnx_model(
         onnx_model_path="miniLM/model.onnx",
         model_id="sentence-transformers/all-MiniLM-L6-v2",
-        output_model_path="model_with_pooling.onnx"
-    )
\ No newline at end of file
+        output_model_path="model_with_pooling.onnx",
+    )
diff --git a/src/mobiletransformers/export/inference_export.py b/src/mobiletransformers/export/inference_export.py
new file mode 100644
index 0000000..1ac9033
--- /dev/null
+++ b/src/mobiletransformers/export/inference_export.py
@@ -0,0 +1,169 @@
+"""Inference export front door: HF model id -> normalized device-ready ONNX package.
+
+``export_inference`` is the single entry point. It discovers the ONNX task (``registry``), selects the
+export frontend (default ``optimum-onnx``'s ``main_export``), runs it, normalizes the output into repo
+conventions (``normalize``), and returns an :class:`ExportResult` carrying the exact toolchain versions
+(recorded in the package manifest + support matrix downstream).
+
+Optimum/torch imports are lazy so the module imports cleanly in the core env; the actual export runs
+only in the ``export`` profile (public ``onnxruntime`` + ``optimum-onnx[onnxruntime]``).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from dataclasses import dataclass, field
+from importlib import metadata
+from pathlib import Path
+
+from mobiletransformers.config.constants import ExportFrontend
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.exceptions import ExportError, UnsupportedModelError
+from mobiletransformers.export.registry import choose_task, discover_tasks, resolve_frontend
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def _pkg_version(dist: str) -> str | None:
+    try:
+        return metadata.version(dist)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def optimum_available() -> bool:
+    """Availability probe for the ``optimum-onnx`` frontend (needs optimum + torch)."""
+    return importlib.util.find_spec("optimum") is not None and importlib.util.find_spec("torch") is not None
+
+
+@dataclass
+class ExportResult:
+    """Everything a caller/manifest needs about one export."""
+
+    out_dir: Path
+    model_id: str
+    model_type: str
+    task: str
+    opset: int
+    frontend: str
+    optimum_version: str | None
+    optimum_onnx_version: str | None
+    transformers_version: str | None
+    onnx_model: Path
+    external_data: Path | None
+    io_inputs: tuple[str, ...] = ()
+    io_outputs: tuple[str, ...] = ()
+    kv_layers: int = 0
+    tokenizer_files: tuple[str, ...] = ()
+    generation_config: bool = False
+    trust_remote_code: bool = False
+    metadata: dict[str, str] = field(default_factory=dict)
+
+
+def optimum_onnx_export(
+    model_id: str,
+    out_dir: Path,
+    task: str,
+    opset: int,
+    trust_remote_code: bool,
+    token: str | None,
+) -> dict[str, str]:
+    """Run Optimum's durable ``main_export`` (CLI equivalent: ``optimum-cli export onnx``).
+
+    Returns the toolchain-version metadata to fold into the package manifest / support matrix.
+    """
+    from optimum.exporters.onnx import main_export
+
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    logger.info("optimum main_export: model=%s task=%s opset=%s", model_id, task, opset)
+    main_export(
+        model_name_or_path=model_id,
+        output=str(out_dir),
+        task=task,
+        opset=opset,
+        trust_remote_code=trust_remote_code,
+        token=token,
+    )
+    return {
+        "exporter": "optimum-onnx.main_export",
+        "optimum_version": _pkg_version("optimum") or "",
+        "optimum_onnx_version": _pkg_version("optimum-onnx") or "",
+        "transformers_version": _pkg_version("transformers") or "",
+        "opset": str(opset),
+        "task": task,
+        "trust_remote_code": str(trust_remote_code),
+    }
+
+
+def export_inference(
+    model_id: str,
+    out_dir: str | Path,
+    *,
+    task: str | None = None,
+    opset: int = 20,
+    trust_remote_code: bool = False,
+    frontend: ExportFrontend | str = ExportFrontend.OPTIMUM_ONNX,
+    token: str | None = None,
+) -> ExportResult:
+    """Export ``model_id`` to a normalized inference package under ``out_dir``.
+
+    Discovery -> task selection -> frontend export -> normalization. Fails closed (typed error, no
+    partial package left implied as valid) if the model has no ONNX exporter, the frontend is
+    unavailable, or the normalized graph is missing required outputs.
+    """
+    out_dir = Path(out_dir)
+    token = token or get_settings().hf_token
+
+    disc = discover_tasks(model_id, token=token, trust_remote_code=trust_remote_code)
+    if not disc.optimum_exportable or disc.model_type is None:
+        raise UnsupportedModelError(
+            f"{model_id!r} is not Optimum-exportable: {disc.blocker or 'no supported ONNX task'}"
+        )
+
+    chosen_task = choose_task(disc.supported_tasks, override=task)
+
+    spec = resolve_frontend(frontend)
+    if "inference" not in spec.capabilities:
+        raise ExportError(
+            f"frontend {spec.frontend.value!r} does not support inference export "
+            f"(capabilities={sorted(spec.capabilities)})"
+        )
+    if not spec.available():
+        raise ExportError(
+            f"export frontend {spec.frontend.value!r} is unavailable in this environment "
+            "(sync the `export` profile: `uv sync --extra export`)"
+        )
+
+    export_fn = spec.load_export()
+    meta = export_fn(model_id, out_dir, chosen_task, opset, trust_remote_code, token)
+
+    # Normalize the raw optimum output into repo conventions (lazy import: needs onnx).
+    from mobiletransformers.export.normalize import normalize_package
+
+    norm = normalize_package(out_dir, model_id=model_id, task=chosen_task)
+
+    return ExportResult(
+        out_dir=out_dir,
+        model_id=model_id,
+        model_type=disc.model_type,
+        task=chosen_task,
+        opset=opset,
+        frontend=spec.frontend.value,
+        optimum_version=meta.get("optimum_version") or None,
+        optimum_onnx_version=meta.get("optimum_onnx_version") or None,
+        transformers_version=meta.get("transformers_version") or None,
+        onnx_model=norm.onnx_model,
+        external_data=norm.external_data,
+        io_inputs=norm.io_inputs,
+        io_outputs=norm.io_outputs,
+        kv_layers=norm.kv_layers,
+        tokenizer_files=norm.tokenizer_files,
+        generation_config=norm.generation_config,
+        trust_remote_code=trust_remote_code,
+        metadata=meta,
+    )
+
+
+__all__ = ["ExportResult", "optimum_available", "optimum_onnx_export", "export_inference"]
diff --git a/src/mobiletransformers/export/inference_package.py b/src/mobiletransformers/export/inference_package.py
new file mode 100644
index 0000000..ed880fd
--- /dev/null
+++ b/src/mobiletransformers/export/inference_package.py
@@ -0,0 +1,466 @@
+# This is the single inference-export orchestrator. It replaces
+# the overlapping gen_genai (artifact/onnx_builder.py) + Model.make_genai_config (inference/builder.py)
+# export paths with one entry that emits the flat external-data package + weight_handoff_map.json.
+# It lives under the legacy `inference/` root (out of the ruff/mypy gate) until inference/ moves into
+# src/; it imports the owner contracts from the packaged `mobiletransformers` namespace.
+"""Unified inference-export package builder (#9).
+
+Given a normalized inference ``model.onnx`` (as produced by ``mobiletransformers.export`` / #7) plus the
+training config that describes which layers were adapted, this produces the device-ready package:
+
+    <output_dir>/
+      model.onnx                 # graph; initializers are EXTERNAL refs only
+      genai_config.json          # augmented with the external-initializers session entry (if present)
+      weight_handoff_map.json    # SINGLE SOURCE OF TRUTH for tensor identity (#8 schema)
+      frozen_base.onnx.data      # frozen base tensors — one immutable flat blob, never merged-over
+      <trainable>.bin (+ .sha256)# one file per trainable/merge-target tensor (overwritten by merge)
+
+The handoff map is built through #8's ``TrainableTensorCodec`` / ``HandoffMap`` — names are *observed*
+from the actual graph initializers, never re-derived — and the required merger ONNX graphs are emitted
+via #9's ``build_merger_model``. Both the offline (``artifact/merger.py``) and on-device
+(``weight_merger.cpp``) mergers then write to the exact filenames this map records.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+import onnx
+from onnx import helper, numpy_helper
+from onnx.external_data_helper import write_external_data_tensors
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap, ObservedInit, TrainableTensorCodec
+from mobiletransformers.config.constants import HandoffMode, PEFTMethod
+from mobiletransformers.config.registry.architecture import resolve_architecture
+from mobiletransformers.config.registry.merger import build_merger_model, resolve_merger
+from mobiletransformers.config.registry.peft import get_peft_spec
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+MODEL_FILENAME = "model.onnx"
+GENAI_CONFIG_FILENAME = "genai_config.json"
+HANDOFF_MAP_FILENAME = "weight_handoff_map.json"
+FROZEN_BASE_BLOB = "frozen_base.onnx.data"
+
+#: The real ORT session-options key that points file/buffer loads at the external-initializer folder.
+#: Valid for a *directly driven* ORT session (the Native engine builds one in C++). It is NOT reachable
+#: through genai_config.json — see GENAI_SESSION_OPTION_KEYS.
+EXTERNAL_INITIALIZERS_FOLDER_KEY = "session.model_external_initializers_file_folder_path"
+
+#: The `model.decoder.session_options` keys the BUNDLED onnxruntime-genai accepts. Probed directly
+#: against onnxruntime-genai 0.14.1 (the version in `src/main/aarLibs/onnxruntime-genai.aar`), not read
+#: off the docs: each key was fed to `og.Model()` alone and classified by whether the config parsed.
+#:
+#: Anything outside this set makes GenAI reject the WHOLE file — it is a hard parse error, not an
+#: ignored key — so an unknown key does not degrade the package, it makes it unloadable. That is how
+#: `config_entries` silently reduced every training-stage package to Native-only.
+#:
+#: NOTE `config_entries` is deliberately absent and must stay absent. onnxruntime.ai's config reference
+#: documents it as available, but 0.14.1 rejects it outright. Re-probe before trusting the upstream
+#: docs on a version bump.
+GENAI_SESSION_OPTION_KEYS = frozenset(
+    {
+        "log_id",
+        "log_severity_level",
+        "enable_profiling",
+        "enable_cpu_mem_arena",
+        "enable_mem_pattern",
+        "intra_op_num_threads",
+        "inter_op_num_threads",
+        "graph_optimization_level",
+        "custom_ops_library",
+        "provider",
+        "provider_options",
+        "external_data_file",
+    }
+)
+
+#: Reconcile BOTH quantized-tensor vocabularies into the 4 canonical handoff roles: the QDQ /
+#: DequantizeLinear naming the merger emits (weight_quantized/weight_scale/weight_zero_point, see
+#: weight_merger.cpp::save_merged_parameters) and the GPTQ/int4 naming (qweight/scales/qzeros, see
+#: handoff_map.INFERENCE_SUFFIX_TO_ROLE). This single map closes Tier-0 finding #10 — the role of an
+#: observed initializer is data here, not a scattered string rule.
+_ROLE_BY_TOKEN = {
+    "weight": "weight",
+    "weight_quantized": "weight_quantized",
+    "weight_scale": "scale",
+    "weight_zero_point": "zero_point",
+    "qweight": "weight_quantized",
+    "scales": "scale",
+    "qzeros": "zero_point",
+}
+
+
+@dataclass
+class ExportedPackage:
+    output_dir: Path
+    model_path: Path
+    handoff_map_path: Path
+    frozen_base_blob: Path | None
+    trainable_bins: tuple[Path, ...]
+    merger_models: dict[str, str]
+
+
+def _seed_and_token(name: str) -> tuple[str, str]:
+    """Split an initializer name into (seed, role-token): ``a.b.MatMul.weight`` -> (``a.b.MatMul``, ``weight``)."""
+    seed, _, token = name.rpartition(".")
+    return seed, token
+
+
+def _sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _atomic_write_sidecar(path: Path, text: str) -> None:
+    """Write ``text`` to ``path`` via temp + fsync + os.replace (never a truncated sidecar)."""
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with open(tmp, "w", encoding="utf-8") as fh:
+        fh.write(text)
+        fh.flush()
+        os.fsync(fh.fileno())
+    os.replace(tmp, path)
+
+
+def _convert_initializers_to_inputs(
+    model: onnx.ModelProto, initializer_names: set[str], opset_version: int
+) -> onnx.ModelProto:
+    """Ported from ``gen_genai``'s ``weight_input=True`` path: promote the named initializers to graph
+    inputs (GenAI ``set_model_input`` handoff). Reserved for the ``model_input`` fallback mode, which is
+    not wired in v1 — kept here so a later plan implements that mode behind the existing enum key."""
+    initializers = {init.name: init for init in model.graph.initializer}
+    new_inputs = []
+    for name in initializer_names:
+        init = initializers.get(name)
+        if init is not None:
+            new_inputs.append(helper.make_tensor_value_info(name, init.data_type, init.dims))
+            model.graph.initializer.remove(init)
+    new_graph = helper.make_graph(
+        nodes=list(model.graph.node),
+        name=model.graph.name,
+        inputs=list(model.graph.input) + new_inputs,
+        outputs=list(model.graph.output),
+        initializer=[i for i in model.graph.initializer if i.name not in initializer_names],
+    )
+    return helper.make_model(new_graph, opset_imports=[helper.make_opsetid("", opset_version)])
+
+
+def _classify_initializers(
+    model: onnx.ModelProto, trainable_seeds: set[str]
+) -> tuple[list[ObservedInit], set[str]]:
+    """Return (observed trainable inits, set of trainable initializer names).
+
+    An initializer is a *trainable / merge-target* tensor iff its seed matches an adapted layer AND its
+    role-token is a recognized weight role. Everything else is frozen base.
+    """
+    observed: list[ObservedInit] = []
+    trainable_names: set[str] = set()
+    for init in model.graph.initializer:
+        seed, token = _seed_and_token(init.name)
+        role = _ROLE_BY_TOKEN.get(token)
+        if seed in trainable_seeds and role is not None:
+            dtype = str(helper.tensor_dtype_to_np_dtype(init.data_type))
+            observed.append(ObservedInit(name=init.name, dtype=dtype, shape=tuple(init.dims), role=role))
+            trainable_names.add(init.name)
+    return observed, trainable_names
+
+
+def _split_external_data(
+    model: onnx.ModelProto, output_dir: Path, trainable_names: set[str]
+) -> tuple[Path | None, list[Path]]:
+    """Point each initializer at its external file: trainables at a per-tensor ``<name>.bin``, frozen
+    base tensors at the single flat ``frozen_base.onnx.data``. Writes the blobs to ``output_dir``.
+    Returns (frozen_base_blob_path_or_None, trainable_bin_paths)."""
+    from onnx.external_data_helper import set_external_data
+
+    trainable_bins: list[Path] = []
+    wrote_base = False
+
+    # onnx's write_external_data_tensors APPENDS to an existing blob and records the tensor's (offset,
+    # length) into the graph. Re-exporting into a directory that already holds these files therefore
+    # doubles every `.bin` and points the graph at the second copy — the package still "validates"
+    # (the graph is self-consistent) but the device rejects it, because #23's on-disk contract is one
+    # raw tensor per file at offset 0 and it checks `file size == declared elements * dtype size`.
+    #
+    # That is exactly how a re-run of `--stages training` into an existing `build/pkg` produced
+    # `offset=1327104 length=1327104` inside a 2654208-byte file. Remove the stale blobs first so a
+    # re-export is idempotent rather than silently corrupting.
+    stale = [output_dir / FROZEN_BASE_BLOB]
+    stale += [output_dir / f"{name}.bin" for name in trainable_names]
+    for path in stale:
+        if path.exists():
+            path.unlink()
+        sidecar = path.with_suffix(path.suffix + ".sha256")
+        if sidecar.exists():
+            sidecar.unlink()
+
+    for init in model.graph.initializer:
+        # set_external_data needs raw_data present.
+        if not init.HasField("raw_data"):
+            arr = numpy_helper.to_array(init)
+            for field_name in (
+                "float_data",
+                "int32_data",
+                "int64_data",
+                "string_data",
+                "uint64_data",
+                "double_data",
+            ):
+                init.ClearField(field_name)
+            init.raw_data = arr.tobytes()
+        if init.name in trainable_names:
+            location = f"{init.name}.bin"
+            trainable_bins.append(output_dir / location)
+        else:
+            location = FROZEN_BASE_BLOB
+            wrote_base = True
+        set_external_data(init, location=location)
+
+    write_external_data_tensors(model, str(output_dir))
+    frozen_base = output_dir / FROZEN_BASE_BLOB if wrote_base else None
+    return frozen_base, trainable_bins
+
+
+def _drop_orphaned_external_data(model_path: Path, output_dir: Path) -> int:
+    """Delete the upstream export's external-data blob once the split has superseded it.
+
+    Optimum writes the whole model's weights to a single ``model.onnx_data`` beside ``model.onnx``.
+    :func:`_split_external_data` then re-points **every** initializer at either ``frozen_base.onnx.data``
+    or a per-tensor ``<name>.bin``, and writes those — so the original blob is left in the package
+    referenced by nothing.
+
+    Nothing noticed, because a package with a spare file still validates: the graph is self-consistent,
+    every declared file resolves, and the checksums match. But ``downloadPlan`` ships the inference
+    stage as the glob ``variants/<id>/inference/**``, so the dead copy is **downloaded to every
+    device**. It was roughly **45% of every package published so far** — 1,743 MB of FunctionGemma's
+    3,875 MB, 651 MB of SmolLM2's 1,586 MB — which is most of the reason a first pull looked so
+    expensive.
+
+    Deliberately narrow. Only ``*.onnx_data`` files are considered (the upstream naming; our own blobs
+    are ``frozen_base.onnx.data`` and ``*.bin``), and only when the freshly saved graph does not
+    reference them. A file that is referenced is never touched, so a future layout that keeps using the
+    upstream blob degrades to a no-op rather than to a corrupt package.
+
+    :return: how many files were removed.
+    """
+    from onnx.external_data_helper import ExternalDataInfo
+
+    saved = onnx.load(str(model_path), load_external_data=False)
+    referenced = {
+        ExternalDataInfo(init).location
+        for init in saved.graph.initializer
+        if init.HasField("data_location") and init.external_data
+    }
+
+    removed = 0
+    for candidate in sorted(output_dir.glob("*.onnx_data")):
+        if candidate.name in referenced:
+            continue
+        freed = candidate.stat().st_size
+        candidate.unlink()
+        removed += 1
+        logger.info(
+            "removed orphaned external data %s (%.0f MB): the split graph references %s instead",
+            candidate.name,
+            freed / 1e6,
+            FROZEN_BASE_BLOB,
+        )
+    return removed
+
+
+def _emit_merger_models(
+    output_dir: Path, peft_method: PEFTMethod, quant_in: bool, quant_out: bool
+) -> dict[str, str]:
+    """Emit the merger ONNX graph(s) this package needs and return ``{MergerVariant.value: filename}``."""
+    spec = resolve_merger(peft_method, quant_in=quant_in, quant_out=quant_out)
+    build_merger_model(spec, output_dir / spec.output_filename)
+    return {spec.variant.value: spec.output_filename}
+
+
+def _sanitize_genai_session_options(output_dir: Path) -> list[str]:
+    """Drop `session_options` keys the bundled GenAI runtime cannot parse, and return the dropped names.
+
+    This used to *add* `config_entries` pointing at the external-initializer folder ("belt and
+    suspenders"). Both halves of that were wrong:
+
+    1. **GenAI 0.14 rejects `config_entries`**, and rejects the entire config with it, so every package
+       this exporter touched was GenAI-unloadable. `ModelRuntimeFactory` then fell back to Native
+       silently, which turned the dual-engine parity test into a Native-vs-Native comparison that
+       passed while proving nothing (Gate 0.1 #1/#4).
+    2. **The value was a host path** (`build/pkg/variants/.../inference`). A package is a relocatable
+       artifact — it gets pushed to a device where that path does not exist — so even on a runtime that
+       accepted the key it would have pointed at nothing.
+
+    Neither is needed: ONNX external-data references resolve **relative to the model file's directory**,
+    which is exactly the on-disk contract #23 already requires (one raw tensor per `<name>.bin` at
+    offset 0, beside `model.onnx`). Verified end to end — the exported package loads under
+    onnxruntime-genai 0.14.1 and generates coherently with no session entry at all.
+
+    Sanitizing rather than merely not-emitting matters because `genai_config.json` is produced upstream
+    (inference builder / #15) and merely augmented here: an unsupported key introduced anywhere ahead of
+    this point would otherwise ship unnoticed and only surface as a fallback on a device.
+    """
+    path = output_dir / GENAI_CONFIG_FILENAME
+    if not path.exists():
+        logger.info("no %s to check (produced upstream); skipping", GENAI_CONFIG_FILENAME)
+        return []
+    config = json.loads(path.read_text(encoding="utf-8"))
+    session_options = config.get("model", {}).get("decoder", {}).get("session_options")
+    if not isinstance(session_options, dict):
+        return []
+
+    dropped = sorted(set(session_options) - GENAI_SESSION_OPTION_KEYS)
+    if not dropped:
+        return []
+    for key in dropped:
+        session_options.pop(key)
+    logger.warning(
+        "%s: dropped session_options key(s) the bundled onnxruntime-genai cannot parse: %s. Leaving "
+        "them in makes GenAI reject the whole config and the runtime fall back to Native.",
+        GENAI_CONFIG_FILENAME,
+        ", ".join(dropped),
+    )
+    _atomic_write_sidecar(path, json.dumps(config, indent=2) + "\n")
+    return dropped
+
+
+def export_inference_package(
+    model_path: str | os.PathLike[str],
+    output_dir: str | os.PathLike[str],
+    training_config: dict,
+    model_config: object,
+    peft_method: PEFTMethod,
+    quant_in: bool,
+    quant_out: bool,
+    handoff_mode: HandoffMode = HandoffMode.EXTERNAL_INITIALIZER,
+) -> ExportedPackage:
+    """Build the unified inference package from a normalized ``model.onnx`` + training config.
+
+    ``training_config`` must carry ``requires_grad`` (list of trainable-name substrings) and
+    ``peft_mapping`` (``{base_layer_name: {role: checkpoint_name}}``). ``model_config`` is the HF config
+    (or any object with ``architectures``) resolved to the architecture spec for name rewrites.
+
+    Fails closed: only ``external_initializer`` is supported in v1; ``model_input`` and ``adapter`` raise
+    ``NotImplementedError`` (F7 stubs behind the existing enum keys).
+    """
+    if handoff_mode is not HandoffMode.EXTERNAL_INITIALIZER:
+        raise NotImplementedError(
+            f"handoff mode {handoff_mode.value!r} not supported in v1 "
+            f"(only {HandoffMode.EXTERNAL_INITIALIZER.value!r} resolves); "
+            "model_input/adapter are reserved for a later plan"
+        )
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    peft_mapping = training_config.get("peft_mapping") or {}
+    requires_grad = training_config.get("requires_grad") or []
+    if not peft_mapping:
+        raise ExportError("training_config has no peft_mapping; nothing to hand off to the merger")
+
+    # Resolve from the class the TRAINING half loaded (recorded in training_config), falling back to
+    # the config only for packages exported before that was written. Re-deriving from
+    # `config.architectures` alone resolves an encoder fine-tune to its un-headed row.
+    arch_spec = resolve_architecture(model_config, architecture=training_config.get("architecture"))
+    peft_spec = get_peft_spec(peft_method)
+
+    model = onnx.load(str(model_path), load_external_data=True)
+
+    # Trainable seeds are the adapted layers' inference MatMul seeds (canonical, from #8's codec rule).
+    # Both attention-module spellings: the legacy builder's `attn` and Optimum's HF-canonical
+    # `self_attn`. The seed is a lookup key only — the observed initializer name is what gets recorded.
+    trainable_seeds = {
+        seed
+        for base in peft_mapping
+        for seed in TrainableTensorCodec.candidate_inference_names(
+            base if base.endswith(".base_layer") else base + ".base_layer", arch_spec
+        )
+    }
+    observed, trainable_names = _classify_initializers(model, trainable_seeds)
+    if not observed:
+        raise ExportError(
+            "no inference initializers matched the adapted layers; "
+            f"inference/training naming drifted (trainable seeds: {sorted(trainable_seeds)})"
+        )
+
+    # #8 codec joins training-side mapping with observed inference inits -> one entry per trainable MatMul.
+    entries = TrainableTensorCodec.from_peft_mapping(
+        peft_mapping=peft_mapping,
+        requires_grad=requires_grad,
+        observed_inference_inits=observed,
+        peft_spec=peft_spec,
+        arch_spec=arch_spec,
+        # Written by `gen_artifacts` from the training graph's initializers; lets the map describe the
+        # adapter factors (#35 rank-r). Absent for a caller that did not run the training stage.
+        trainable_tensor_specs=training_config.get("trainable_tensor_specs") or {},
+    )
+
+    frozen_base, trainable_bins = _split_external_data(model, output_dir, trainable_names)
+
+    # sha256 the bytes actually written for each trainable .bin, and record on the matching role.
+    bin_sha: dict[str, str] = {}
+    for bin_path in trainable_bins:
+        digest = _sha256_file(bin_path)
+        bin_sha[bin_path.name] = digest
+        _atomic_write_sidecar(bin_path.with_suffix(bin_path.suffix + ".sha256"), digest + "\n")
+    for entry in entries:
+        for role, location in entry.external_data_location.items():
+            if location in bin_sha:
+                entry.sha256[role] = bin_sha[location]
+
+    # The merger variant MUST describe the tensors that are actually in the package. The device
+    # resolves the variant from what it observes (`weight_merger.cpp`: `has_adapter_A && !has_quantized
+    # -> LORA`), so shipping a graph keyed on the *requested* quantization means `merge()` looks up a
+    # variant that is not there, logs "Merger model not found", and silently merges nothing.
+    #
+    # That is exactly what happened: `--quant int4` set quant_in/quant_out, so the package shipped
+    # `lora_q`, while the inference stage had emitted an unquantized graph and the device asked for
+    # `lora`. Derive from the entries instead, and make the disagreement loud — it is the same
+    # requested-vs-actual quantization gap that leaves the `cpu-int4` variant holding an fp32 graph.
+    observed_quantized = any(entry.is_quantized for entry in entries)
+    if observed_quantized != (quant_in or quant_out):
+        logger.warning(
+            "requested quantization (in=%s out=%s) disagrees with the exported tensors "
+            "(quantized=%s); emitting the merger for the OBSERVED state so the device can find it",
+            quant_in,
+            quant_out,
+            observed_quantized,
+        )
+    merger_models = _emit_merger_models(output_dir, peft_method, observed_quantized, observed_quantized)
+
+    handoff = HandoffMap(entries=entries, handoff_mode=handoff_mode, merger_models=merger_models)
+    handoff_map_path = output_dir / HANDOFF_MAP_FILENAME
+    handoff.save(handoff_map_path)  # validate() runs inside save(): fails closed on any contract breach
+
+    # Save the graph with external refs only (raw_data was cleared by write_external_data_tensors).
+    final_model_path = output_dir / MODEL_FILENAME
+    onnx.save(model, str(final_model_path))
+
+    _drop_orphaned_external_data(final_model_path, output_dir)
+
+    _sanitize_genai_session_options(output_dir)
+
+    logger.info(
+        "exported inference package: %d trainable tensor(s), frozen_base=%s, mergers=%s -> %s",
+        len(trainable_bins),
+        bool(frozen_base),
+        merger_models,
+        output_dir,
+    )
+    return ExportedPackage(
+        output_dir=output_dir,
+        model_path=final_model_path,
+        handoff_map_path=handoff_map_path,
+        frozen_base_blob=frozen_base,
+        trainable_bins=tuple(trainable_bins),
+        merger_models=merger_models,
+    )
diff --git a/src/mobiletransformers/export/model_card.py b/src/mobiletransformers/export/model_card.py
new file mode 100644
index 0000000..6e994ce
--- /dev/null
+++ b/src/mobiletransformers/export/model_card.py
@@ -0,0 +1,302 @@
+"""Model-card (README) renderer for a MobileTransformers package (#15, shared with #22 push-back)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+#: `selectedTask` -> the Hub's `pipeline_tag` vocabulary. The Hub rejects tags outside its own list,
+#: and our task names are Optimum's, which overlap but are not identical (`-with-past` is an export
+#: detail the Hub has never heard of). Unmapped tasks emit no tag rather than an invalid one.
+_PIPELINE_TAG_BY_TASK: dict[str, str] = {
+    "text-generation": "text-generation",
+    "text-generation-with-past": "text-generation",
+    "feature-extraction": "feature-extraction",
+    "text-classification": "text-classification",
+    "token-classification": "token-classification",
+    "fill-mask": "fill-mask",
+    "question-answering": "question-answering",
+}
+
+
+#: The framework a reader needs in order to do anything with one of these packages.
+#:
+#: A MobileTransformers package is NOT loadable by `transformers`, `optimum` or plain `onnxruntime`:
+#: it is a manifest plus per-variant stages with a weight-handoff map, and the thing that reads it is
+#: the Android SDK. Without this link the card describes an artifact with no stated way to run it.
+FRAMEWORK_REPOSITORY = "https://github.com/martinkorelic/mobiletransformers"
+
+#: The banner filename as referenced from a published card. It is uploaded ALONGSIDE the README into
+#: the model repo rather than hot-linked from GitHub, so the image renders from the moment the repo
+#: is published and keeps rendering regardless of the framework repository's visibility, default
+#: branch or later reorganisation. A card whose header image 404s looks abandoned.
+BANNER_FILENAME = "mobiletransformers_banner.png"
+
+#: Cite the framework, not just the base model. Kept here rather than in a doc so every published
+#: card carries it without anyone remembering to paste it.
+_CITATION = r"""@misc{mobiletransformers2025,
+  author       = {Koreli\v{c}, Martin and Pejovi{\'c}, Veljko},
+  title        = {MobileTransformers: An On-Device LLM PEFT Framework for Fine-Tuning and Inference},
+  year         = {2025},
+  howpublished = {\url{https://gitlab.fri.uni-lj.si/lrk/mobiletransformers}}
+}"""
+
+
+def _frontmatter(manifest: dict[str, Any], base: str, lic: dict[str, Any]) -> list[str]:
+    """The YAML block the Hub parses for a model page's metadata.
+
+    Without it a published repo renders with no licence, no link back to the base model and no task
+    filter — the card body says all three in prose, which the Hub does not read. `base_model` in
+    particular is what makes the package show up as a derivative of the model it was exported from,
+    which for a repo that ships no original weights is the main thing a reader needs to see.
+
+    Emits only fields whose value is actually known: a `license: null` line is worse than no line,
+    because the Hub renders it as a licence literally named "null". The framework licence is
+    deliberately NOT defaulted here — it is #32's open decision, and guessing it in published metadata
+    would be the loudest possible place to guess wrong.
+    """
+    out: list[str] = ["---"]
+    if base and base != "unknown":
+        out.append(f"base_model: {base}")
+    out.append("library_name: mobiletransformers")
+    tag = _PIPELINE_TAG_BY_TASK.get(str(manifest.get("selectedTask") or ""))
+    if tag:
+        out.append(f"pipeline_tag: {tag}")
+    weights_licence = lic.get("baseModelWeights")
+    if weights_licence:
+        # The WEIGHTS' licence, not the framework's: this repo redistributes an export of the base
+        # model, so the upstream terms are the ones that govern what is in it.
+        out.append(f"license: {weights_licence}")
+    tags = ["mobiletransformers", "onnx", "on-device", "android"]
+    # EVERY declared method, not a hardcoded `lora` test. A MARS package is this project's own
+    # research contribution and used to publish with no tag naming it at all, so a reader browsing the
+    # org — or anyone filtering the Hub by tag — could not tell a MARS export from a LoRA one.
+    for method in manifest.get("peftMethods") or []:
+        tags.append(str(method))
+    for quant in manifest.get("quantization") or []:
+        tags.append(str(quant))
+    out.append("tags:")
+    out.extend(f"  - {t}" for t in tags)
+    out.append("---")
+    out.append("")
+    return out
+
+
+#: Human-readable names for the PEFT vocabulary. A card that prints the bare enum value asks its
+#: reader to already know what `lora-xs` is; the point of the page is that they do not.
+_PEFT_DESCRIPTIONS: dict[str, str] = {
+    "lora": "LoRA — low-rank adapters on the attention projections.",
+    "lora-xs": "LoRA-XS — LoRA with a frozen SVD basis, training only a small r x r core.",
+    "mars": (
+        "MARS (Multi-Adapter Rank Sharing) — this project's own method: adapters shared across "
+        "layers, so parameter count grows with rank rather than with depth."
+    ),
+}
+
+
+def _read_peft_details(package_dir: str | None) -> dict[str, Any]:
+    """Rank and adapted modules for the training stage, or ``{}`` when there is no train stage.
+
+    These are **not** in the manifest — it carries `peftMethods` and nothing else about the tuning
+    setup. They live beside the training graph, in `train/trainable_parameters.json` (`peftMethod`,
+    `rank`) and `train/training_config.json` (`rank`, `peft_target`).
+
+    Best-effort by construction: a package exported for inference only has no train stage, and an
+    unreadable file must not fail a push. Every failure path returns ``{}`` and the caller omits the
+    lines rather than printing `None` — the mistake that once published "Framework: None" on a live
+    model page.
+    """
+    if not package_dir:
+        return {}
+    import json
+    from pathlib import Path
+
+    root = Path(package_dir)
+    details: dict[str, Any] = {}
+    # Variant-scoped, and the variant id is not knowable here — glob rather than guess a layout.
+    for name, keys in (
+        ("trainable_parameters.json", ("peftMethod", "rank")),
+        ("training_config.json", ("rank", "peft_target")),
+    ):
+        for path in sorted(root.glob(f"variants/*/train/{name}")):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                continue
+            for key in keys:
+                if payload.get(key) not in (None, "", [], {}):
+                    details.setdefault(key, payload[key])
+            break
+    return details
+
+
+def _cell(variant: dict[str, Any], key: str) -> str:
+    """One variant-table cell, rendering an undeclared value as ``—`` rather than ``None``.
+
+    A table full of the word ``None`` reads as a broken renderer, and leaves the reader unable to tell
+    it from a value that is genuinely absent. Every package the exporter has produced has nulls here.
+    """
+    value = variant.get(key)
+    return str(value) if value not in (None, "") else "—"
+
+
+def render_model_card(
+    manifest: dict[str, Any],
+    package_dir: str | None = None,
+    *,
+    banner: str | None = BANNER_FILENAME,
+    repo_id: str | None = None,
+) -> str:
+    """Render a Hub README from a ``mobiletransformers_manifest.json`` dict.
+
+    Includes the base model, both licenses, version pins, Android runtime requirements, and a variant
+    table (id / EP / quant / engines / features / min API / recommended RAM). Pure string building.
+
+    ``banner`` is the filename to reference for the header image, or ``None`` to omit it. A parameter
+    rather than a constant read from disk because this function does no IO — the caller (``push``)
+    owns deciding whether the file will actually be uploaded, and passing a name for an image that is
+    not there would render a broken image on a public page.
+
+    ``repo_id`` makes the usage snippets copy-pasteable. It is not in the manifest — a package does
+    not know where it will be published — so the publisher supplies it; without it the snippets fall
+    back to a placeholder.
+    """
+    base = manifest.get("baseModelId", "unknown")
+    lic = manifest.get("license", {}) or {}
+    android = manifest.get("androidRuntime", {}) or {}
+    lines: list[str] = []
+    lines.extend(_frontmatter(manifest, base, lic))
+    if banner:
+        lines.append(f"![MobileTransformers]({banner})")
+        lines.append("")
+    lines.append(f"# {base} — MobileTransformers package")
+    lines.append("")
+    lines.append(f"On-device (Android) package exported from **{base}** with MobileTransformers.")
+    lines.append("")
+    # What the package can DO, before how it was made: it decides which of the app's screens light up,
+    # and it is the first thing someone choosing between shelf entries needs.
+    features: list[str] = []
+    for variant in manifest.get("variants", []):
+        for feature in variant.get("features", []):
+            if feature not in features:
+                features.append(str(feature))
+    if features:
+        lines.append("## What this package can do")
+        explanations = {
+            "inference": "generate or score on device",
+            "train": "**fine-tune on device**, then merge the adapter back into the base weights",
+            "rag": "retrieve over documents you ingest, and ground answers in them",
+            "core": "shared files every other group needs",
+        }
+        for feature in features:
+            lines.append(f"- `{feature}` — {explanations.get(feature, 'see the docs')}")
+        if "train" not in features:
+            lines.append("- *(no `train` group: this package is inference-only)*")
+        lines.append("")
+
+    peft_methods = [str(m) for m in manifest.get("peftMethods") or []]
+    if peft_methods:
+        details = _read_peft_details(package_dir)
+        lines.append("## Fine-tuning method")
+        for method in peft_methods:
+            described = _PEFT_DESCRIPTIONS.get(method)
+            lines.append(f"- **{method}**{' — ' + described if described else ''}")
+        # Omit rather than guess: a rank printed for a package whose train stage says nothing is a
+        # number the reader would reasonably trust.
+        rank = details.get("rank")
+        if rank is not None:
+            lines.append(f"- Rank: `{rank}`")
+        targets = details.get("peft_target")
+        if targets:
+            lines.append(f"- Adapted modules: {', '.join(f'`{t}`' for t in targets)}")
+        lines.append("")
+
+    lines.append("## Provenance")
+    lines.append(f"- Base model: `{base}`")
+    lines.append(f"- Selected task: `{manifest.get('selectedTask')}`")
+    lines.append(f"- Quantization: {', '.join(manifest.get('quantization', [])) or 'n/a'}")
+    # Same rule as the licence lines below: a toolchain entry whose version is null is not evidence
+    # that the tool was absent, only that the export did not record it — and "optimum-onnx None"
+    # reads as a version literally named None. List the ones that are known; say so when none are.
+    toolchain = [
+        (label, manifest.get(key))
+        for label, key in (
+            ("optimum-onnx", "optimumOnnxVersion"),
+            ("transformers", "transformersVersion"),
+            ("ort-training", "onnxRuntimeTrainingVersion"),
+            ("ort-genai", "onnxRuntimeGenAIVersion"),
+        )
+    ]
+    known = [f"{label} {version}" for label, version in toolchain if version]
+    lines.append(f"- Toolchain: {', '.join(known) if known else 'not recorded in this package'}")
+    lines.append("")
+    lines.append("## Licenses")
+    # `or`, not a dict default: the keys EXIST with a null value on every package the exporter has
+    # produced, so `get(k, fallback)` returned None and the published page read "Framework: None" —
+    # which a reader can only interpret as "there is no licence".
+    lines.append(
+        f"- Framework: {lic.get('framework') or 'not declared in this package — see the repository'}"
+    )
+    lines.append(
+        f"- Base model weights: {lic.get('baseModelWeights') or 'see the base model above'} "
+        "(this package redistributes an export of those weights, so their terms govern its contents)"
+    )
+    lines.append("")
+    lines.append("## Android runtime")
+    lines.append(f"- Minimum API: {android.get('minimumAndroidApi') or 'not declared'}")
+    memory = android.get("recommendedDeviceMemoryMb")
+    # Only when measured. A device-memory recommendation is the number a reader uses to decide whether
+    # their phone can run this at all, so inventing one — or printing None — is worse than omitting it.
+    if memory:
+        lines.append(f"- Recommended device memory (MB): {memory}")
+    lines.append(f"- Required ABIs: {', '.join(android.get('requiredAbis', [])) or 'any'}")
+    lines.append("")
+    lines.append("## Variants")
+    lines.append("")
+    lines.append("| id | EP | quant | engines | features | min API | rec. RAM (MB) |")
+    lines.append("| --- | --- | --- | --- | --- | --- | --- |")
+    for v in manifest.get("variants", []):
+        lines.append(
+            f"| {_cell(v, 'id')} | {_cell(v, 'executionProvider')} | {_cell(v, 'quantization')} "
+            f"| {', '.join(v.get('supportedEngines', [])) or '—'} "
+            f"| {', '.join(v.get('features', [])) or '—'} "
+            f"| {_cell(v, 'minimumAndroidApi')} | {_cell(v, 'recommendedDeviceMemoryMb')} |"
+        )
+    lines.append("")
+    default = manifest.get("defaultVariant")
+    lines.append(f"Default variant: `{default}`.")
+    lines.append("")
+    lines.append("## Running this model")
+    lines.append("")
+    lines.append(
+        "This is a **MobileTransformers package**, not a plain Hugging Face model: it is a manifest "
+        "plus per-variant ONNX stages and a weight-handoff map. `transformers`, `optimum` and plain "
+        "`onnxruntime` cannot load it. Use the framework:"
+    )
+    lines.append("")
+    lines.append(f"**{FRAMEWORK_REPOSITORY}**")
+    lines.append("")
+    lines.append("```kotlin")
+    lines.append("// Android — pulls, verifies and installs on first use.")
+    lines.append("val model = MobileTransformers.fromPretrained(")
+    lines.append("    context = context,")
+    lines.append(f'    repoId  = "{repo_id or "<org>/<this-repo>"}",')
+    lines.append(")")
+    lines.append("```")
+    lines.append("")
+    lines.append("```bash")
+    lines.append("# Host — download and inspect the package without a device.")
+    lines.append(f"mobiletransformers pull --repo-id {repo_id or '<org>/<this-repo>'}")
+    lines.append("```")
+    lines.append("")
+    lines.append("## Citation")
+    lines.append("")
+    lines.append("If you are using this framework for your own work, please cite:")
+    lines.append("")
+    lines.append("```bibtex")
+    lines.append(_CITATION)
+    lines.append("```")
+    lines.append("")
+    return "\n".join(lines)
+
+
+__all__ = ["render_model_card"]
diff --git a/src/mobiletransformers/export/normalize.py b/src/mobiletransformers/export/normalize.py
new file mode 100644
index 0000000..ec9b6b0
--- /dev/null
+++ b/src/mobiletransformers/export/normalize.py
@@ -0,0 +1,213 @@
+"""Normalize a raw Optimum export into repo conventions.
+
+Optimum's ``main_export`` already emits HF-canonical IO names (``input_ids``/``attention_mask``/
+``position_ids`` in, ``logits`` + ``present.<i>.key/value`` out, ``past_key_values.<i>.key/value`` in) —
+the same scheme ``inference/builder.py``'s ``make_genai_config`` writes into ``genai_config.json``, so
+the Native and GenAI engines agree. So normalization here **verifies** those names (fail-closed if a
+required output is missing) and **consolidates external data into a single blob** beside ``model.onnx``,
+producing the flat package shape plan #9 (unified merger / handoff map) consumes.
+
+``onnx`` is imported lazily so this module stays importable in the core env.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+#: Canonical decoder input names (subset expected present; optimum emits these for text-generation).
+CANONICAL_TEXTGEN_INPUTS = ("input_ids", "attention_mask")
+
+#: Known tokenizer / processing artifacts optimum copies next to the graph.
+_TOKENIZER_FILES = (
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "tokenizer.model",
+    "vocab.json",
+    "merges.txt",
+    "special_tokens_map.json",
+    "spiece.model",
+    "added_tokens.json",
+)
+
+
+#: Initializer-name prefixes the ONNX exporters generate when a tensor has no meaningful name of its own.
+#: `torch.onnx` emits `onnx::MatMul_8914` for every inlined `nn.Linear` weight.
+_ANONYMOUS_INITIALIZER_PREFIXES = ("onnx::", "onnx_")
+
+#: Ops whose constant input is a layer weight worth naming (the merge targets #8/#9 key on).
+_WEIGHTED_OPS = ("MatMul", "Gemm", "Conv")
+
+
+def _is_anonymous(name: str) -> bool:
+    return name.startswith(_ANONYMOUS_INITIALIZER_PREFIXES)
+
+
+def canonicalize_initializer_names(onnx_model: object) -> dict[str, str]:
+    """Give every anonymous weight initializer the module path of the node that consumes it.
+
+    **This is where tensor identity is decided for the whole project.** The #8 handoff map, the #9
+    merger and the on-device loader all key on initializer names (`handoff_io.h:25`: *"No string-rewrite
+    on device"*), and `torch.onnx` — which Optimum uses, and which #7 made the inference front door —
+    inlines each `nn.Linear` weight as an anonymous ``onnx::MatMul_<n>`` initializer. HF parameter names
+    survive only for norms and embeddings, so a trainable projection weight had **no name to key on** and
+    no handoff map could be built for an Optimum-exported package at all.
+
+    The module path is not guessed: `torch.onnx` names the *node* after the module that produced it
+    (``/model/layers.0/self_attn/q_proj/MatMul``), so the weight's identity is recovered from the graph's
+    own structure — no per-architecture table, and it works for any module the exporter names, MLP
+    projections included. The result (``model.layers.0.self_attn.q_proj.MatMul.weight``) is exactly the
+    ``<seed>.<role-token>`` shape `export/inference_package.py` already splits on.
+
+    Idempotent and non-destructive: an initializer that already has a real name (the legacy
+    `inference/builder.py` graphs, or a re-normalized package) is left alone. Returns ``{old: new}``.
+    """
+    initializers = {init.name: init for init in onnx_model.graph.initializer}  # type: ignore[attr-defined]
+    renames: dict[str, str] = {}
+    taken = set(initializers)
+
+    for node in onnx_model.graph.node:  # type: ignore[attr-defined]
+        if node.op_type not in _WEIGHTED_OPS or not node.name.startswith("/"):
+            continue
+        module_path = node.name.lstrip("/").replace("/", ".")
+        for inp in node.input:
+            if inp not in initializers or not _is_anonymous(inp) or inp in renames:
+                continue
+            candidate = f"{module_path}.weight"
+            # Two nodes sharing one module path would collide; keep both addressable rather than
+            # silently dropping one, since a lost name means a lost merge target.
+            suffix = 1
+            while candidate in taken:
+                candidate = f"{module_path}.weight_{suffix}"
+                suffix += 1
+            renames[inp] = candidate
+            taken.add(candidate)
+
+    if not renames:
+        return {}
+
+    for init in onnx_model.graph.initializer:  # type: ignore[attr-defined]
+        if init.name in renames:
+            init.name = renames[init.name]
+    # Every reference must move with it: node inputs, and graph inputs when initializers are declared
+    # there too (older opsets/exporters do this).
+    for node in onnx_model.graph.node:  # type: ignore[attr-defined]
+        for i, inp in enumerate(node.input):
+            if inp in renames:
+                node.input[i] = renames[inp]
+    for graph_input in onnx_model.graph.input:  # type: ignore[attr-defined]
+        if graph_input.name in renames:
+            graph_input.name = renames[graph_input.name]
+
+    logger.info("canonicalized %d anonymous weight initializer name(s)", len(renames))
+    return renames
+
+
+@dataclass
+class NormalizedPackage:
+    onnx_model: Path
+    external_data: Path | None
+    io_inputs: tuple[str, ...]
+    io_outputs: tuple[str, ...]
+    kv_layers: int
+    tokenizer_files: tuple[str, ...]
+    generation_config: bool
+
+
+def _count_kv_layers(names: tuple[str, ...], prefix: str) -> int:
+    """Count distinct layer indices among ``<prefix>.<i>.key/value`` names."""
+    layers: set[str] = set()
+    for name in names:
+        if name.startswith(prefix + "."):
+            parts = name[len(prefix) + 1 :].split(".")
+            if parts and parts[0].isdigit():
+                layers.add(parts[0])
+    return len(layers)
+
+
+def normalize_package(
+    out_dir: str | Path,
+    *,
+    model_id: str,
+    task: str | None = None,
+    model_filename: str = "model.onnx",
+    external_data_filename: str = "model.onnx_data",
+) -> NormalizedPackage:
+    """Verify canonical IO and consolidate external data for the export at ``out_dir``.
+
+    Fails closed (``ExportError``) if the ONNX graph is absent, has no ``logits`` output for a
+    text-generation task, or is missing the ``present.*`` KV outputs a ``*-with-past`` task requires.
+    """
+    import onnx
+
+    out_dir = Path(out_dir)
+    model_path = out_dir / model_filename
+    if not model_path.is_file():
+        raise ExportError(f"export produced no {model_filename} in {out_dir} (model={model_id!r})")
+
+    onnx_model = onnx.load(str(model_path), load_external_data=True)
+    io_inputs = tuple(i.name for i in onnx_model.graph.input)
+    io_outputs = tuple(o.name for o in onnx_model.graph.output)
+
+    task = task or ""
+    if task.startswith("text-generation"):
+        if "logits" not in io_outputs:
+            raise ExportError(
+                f"text-generation export missing `logits` output (model={model_id!r}, "
+                f"outputs={list(io_outputs)})"
+            )
+        missing_inputs = [n for n in CANONICAL_TEXTGEN_INPUTS if n not in io_inputs]
+        if missing_inputs:
+            raise ExportError(
+                f"export missing canonical inputs {missing_inputs} (model={model_id!r}, "
+                f"inputs={list(io_inputs)})"
+            )
+        if task.endswith("-with-past") and _count_kv_layers(io_outputs, "present") == 0:
+            raise ExportError(
+                f"`{task}` export has no `present.*` KV outputs (model={model_id!r}, "
+                f"outputs={list(io_outputs)})"
+            )
+    elif not io_outputs:
+        raise ExportError(f"export graph has no outputs (model={model_id!r})")
+
+    kv_layers = _count_kv_layers(io_outputs, "present") or _count_kv_layers(io_inputs, "past_key_values")
+
+    # Tensor identity for #8/#9. Must run before the external-data split below, because that split is
+    # what writes each trainable tensor to its own `<name>.bin` — the name has to be final by then.
+    canonicalize_initializer_names(onnx_model)
+
+    # Consolidate all initializers into a single external blob beside model.onnx (flat #9 shape).
+    external_data = out_dir / external_data_filename
+    onnx.save_model(
+        onnx_model,
+        str(model_path),
+        save_as_external_data=True,
+        all_tensors_to_one_file=True,
+        location=external_data_filename,
+        size_threshold=1024,
+        convert_attribute=False,
+    )
+    logger.info(
+        "normalized %s: inputs=%s outputs=%s kv_layers=%s", model_id, io_inputs, io_outputs, kv_layers
+    )
+
+    tokenizer_files = tuple(f for f in _TOKENIZER_FILES if (out_dir / f).is_file())
+    generation_config = (out_dir / "generation_config.json").is_file()
+
+    return NormalizedPackage(
+        onnx_model=model_path,
+        external_data=external_data if external_data.is_file() else None,
+        io_inputs=io_inputs,
+        io_outputs=io_outputs,
+        kv_layers=kv_layers,
+        tokenizer_files=tokenizer_files,
+        generation_config=generation_config,
+    )
+
+
+__all__ = ["NormalizedPackage", "normalize_package"]
diff --git a/src/mobiletransformers/export/onnx_config_with_loss.py b/src/mobiletransformers/export/onnx_config_with_loss.py
new file mode 100644
index 0000000..bcc75a0
--- /dev/null
+++ b/src/mobiletransformers/export/onnx_config_with_loss.py
@@ -0,0 +1,191 @@
+"""Vendored ``OnnxConfigWithLoss`` — training-graph loss/labels wrapper for Optimum ONNX configs.
+
+**Why this exists.** Optimum 2.1 (the ``optimum-onnx`` split) *removed* ``OnnxConfigWithLoss`` with no
+replacement (verified by ``spikes/optimum_migration/check_symbols.py``). The lower-level ``export()``
+function it partnered with *survives*, and so do the base classes and dummy-input generators this
+wrapper needs. So rather than reconstruct the training graph by hand via ``torch.onnx`` (the plan's
+Fallback A) or pin a legacy optimum (Fallback B), we vendor the wrapper: the training-graph export
+stays on Optimum's durable ``export()`` path, self-owned and version-pinned here.
+
+**Provenance.** Adapted verbatim from ``optimum/exporters/onnx/base.py::OnnxConfigWithLoss`` at
+optimum v1.24.0 (Apache-2.0, © The HuggingFace Team). Only imports were repointed for optimum 2.1
+(``OnnxConfigWithPast`` now lives in ``optimum.exporters.onnx.base``) and type hints tightened. To be
+enumerated in ``THIRD_PARTY_NOTICES.md`` by the relicense pass (#32).
+
+**Profile.** Requires the export/train profile (optimum + torch installed). This module imports
+optimum at load, so it must never be imported on the core import path — only from the training-export
+site (``trainer/builder.py``). ``mobiletransformers.export.__init__`` stays empty by design.
+"""
+
+from __future__ import annotations
+
+import copy
+from collections import OrderedDict
+from collections.abc import Iterable
+from typing import Any
+
+from optimum.exporters.onnx import OnnxConfig
+from optimum.exporters.onnx.base import OnnxConfigWithPast
+from optimum.utils import DEFAULT_DUMMY_SHAPES, DummyLabelsGenerator
+
+
+class OnnxConfigWithLoss(OnnxConfig):
+    """Wrap an ``OnnxConfig`` so the exported graph carries ``labels`` inputs and a ``loss`` output.
+
+    This is what turns an inference OnnxConfig into a *training* graph (the graph
+    ``onnxruntime.training.artifacts.generate_artifacts`` consumes downstream, plan #8).
+    """
+
+    _tasks_to_extra_inputs: dict[str, dict[str, dict[int, str]]] = {
+        "feature-extraction": {"labels": {0: "batch_size"}},
+        "fill-mask": {"labels": {0: "batch_size", 1: "sequence_length"}},
+        "text-generation": {"labels": {0: "batch_size", 1: "sequence_length"}},
+        "text-generation-with-past": {"labels": {0: "batch_size"}},
+        "text2text-generation": {"labels": {0: "batch_size", 1: "sequence_length"}},
+        "text2text-generation-with-past": {"labels": {0: "batch_size"}},
+        "text-classification": {"labels": {0: "batch_size"}},
+        "token-classification": {"labels": {0: "batch_size", 1: "sequence_length"}},
+        "multiple-choice": {"labels": {0: "batch_size"}},
+        "question-answering": {
+            "start_positions": {0: "batch_size"},
+            "end_positions": {0: "batch_size"},
+        },
+        "image-classification": {"labels": {0: "batch_size"}},
+    }
+    _tasks_to_extra_outputs: dict[str, OrderedDict[str, dict[int, str]]] = {
+        "feature-extraction": OrderedDict({"loss": {}}),
+    }
+
+    DUMMY_EXTRA_INPUT_GENERATOR_CLASSES = (DummyLabelsGenerator,)
+
+    def __init__(
+        self,
+        config: OnnxConfig,
+        int_dtype: str = "int64",
+        float_dtype: str = "fp32",
+        legacy: bool = False,
+    ) -> None:
+        self._onnx_config = config
+        self.task = self._onnx_config.task
+        self.int_dtype = int_dtype
+        self.float_dtype = float_dtype
+        self._normalized_config = self._onnx_config._normalized_config
+        self.PATCHING_SPECS = self._onnx_config.PATCHING_SPECS
+        self.variant = "default"
+        self.legacy = legacy
+
+    @classmethod
+    def from_onnx_config(cls, config: OnnxConfig) -> OnnxConfigWithLoss:
+        return cls(config)
+
+    @property
+    def inputs(self) -> dict[str, dict[int, str]]:
+        inputs = self._onnx_config.inputs
+        inputs.update(self._tasks_to_extra_inputs[self.task])
+        return inputs
+
+    @property
+    def outputs(self) -> dict[str, dict[int, str]]:
+        common_outputs = self._onnx_config.outputs
+        extra_outputs = self._tasks_to_extra_outputs["feature-extraction"]
+        common_outputs.update(extra_outputs)
+        for key in reversed(extra_outputs.keys()):
+            common_outputs.move_to_end(key, last=False)
+        return copy.deepcopy(common_outputs)
+
+    def generate_dummy_inputs(self, framework: str = "pt", **kwargs: Any) -> dict[str, Any]:
+        dummy_inputs = self._onnx_config.generate_dummy_inputs(framework=framework, **kwargs)
+        input_name, _ = next(iter(self._onnx_config.inputs.items()))
+        batch_size = dummy_inputs[input_name].shape[0]
+
+        if (
+            isinstance(self._onnx_config, OnnxConfigWithPast)
+            and self._onnx_config.use_past_in_inputs is True
+            and self.task != "text-generation"
+        ):
+            kwargs["sequence_length"] = 1
+        else:
+            for _input_name, dynamic_axes in self._tasks_to_extra_inputs[self.task].items():
+                if "sequence_length" in dynamic_axes.values():
+                    kwargs["sequence_length"] = DEFAULT_DUMMY_SHAPES["sequence_length"]
+
+        kwargs["num_labels"] = self._onnx_config._config.num_labels
+
+        dummy_inputs_generators = [
+            cls_(self.task, self._normalized_config, batch_size=batch_size, **kwargs)
+            for cls_ in self.DUMMY_EXTRA_INPUT_GENERATOR_CLASSES
+        ]
+
+        for input_name in self._tasks_to_extra_inputs[self.task]:
+            input_was_inserted = False
+            for dummy_input_gen in dummy_inputs_generators:
+                if dummy_input_gen.supports_input(input_name):
+                    dummy_inputs[input_name] = dummy_input_gen.generate(
+                        input_name,
+                        framework=framework,
+                        int_dtype=self.int_dtype,
+                        float_dtype=self.float_dtype,
+                    )
+                    input_was_inserted = True
+                    break
+            if not input_was_inserted:
+                raise RuntimeError(
+                    f'Could not generate dummy input for "{input_name}". Try adding a proper dummy '
+                    "input generator to the model ONNX config."
+                )
+
+        return dummy_inputs
+
+    def generate_dummy_inputs_for_validation(
+        self, reference_model_inputs: dict[str, Any], onnx_input_names: list[str] | None = None
+    ) -> dict[str, Any]:
+        return self._onnx_config.generate_dummy_inputs_for_validation(reference_model_inputs)
+
+    def flatten_decoder_past_key_values(
+        self, flattened_output: dict[str, Any], name: str, idx: int, t: Any
+    ) -> None:
+        flattened_output[f"{name}.{idx}.key"] = t[0]
+        flattened_output[f"{name}.{idx}.value"] = t[1]
+
+    def flatten_seq2seq_past_key_values(
+        self, flattened_output: dict[str, Any], name: str, idx: int, t: Any
+    ) -> None:
+        if len(t) not in [2, 4]:
+            raise ValueError(
+                "past_key_values to flatten should be of length 2 (self-attention only) or 4 "
+                "(self and cross attention)."
+            )
+        if len(t) == 2:
+            flattened_output[f"{name}.{idx}.decoder.key"] = t[0]
+            flattened_output[f"{name}.{idx}.decoder.value"] = t[1]
+        if len(t) == 4:
+            flattened_output[f"{name}.{idx}.encoder.key"] = t[2]
+            flattened_output[f"{name}.{idx}.encoder.value"] = t[3]
+
+    def flatten_output_collection_property(self, name: str, field: Iterable[Any]) -> dict[str, Any]:
+        flattened_output: dict[str, Any] = {}
+        if name in ["present", "past_key_values"]:
+            if "text-generation" in self.task:
+                for idx, t in enumerate(field):
+                    self.flatten_decoder_past_key_values(flattened_output, name, idx, t)
+            elif "text2text-generation" in self.task:
+                for idx, t in enumerate(field):
+                    self.flatten_seq2seq_past_key_values(flattened_output, name, idx, t)
+        else:
+            flattened_output = super().flatten_output_collection_property(name, field)
+        return flattened_output
+
+    @property
+    def torch_to_onnx_input_map(self) -> dict[str, str]:
+        return self._onnx_config.torch_to_onnx_input_map
+
+    @property
+    def torch_to_onnx_output_map(self) -> dict[str, str]:
+        return self._onnx_config.torch_to_onnx_output_map
+
+    @property
+    def values_override(self) -> dict[str, Any] | None:
+        return self._onnx_config.values_override
+
+
+__all__ = ["OnnxConfigWithLoss"]
diff --git a/src/mobiletransformers/export/pipeline.py b/src/mobiletransformers/export/pipeline.py
new file mode 100644
index 0000000..834b35d
--- /dev/null
+++ b/src/mobiletransformers/export/pipeline.py
@@ -0,0 +1,1243 @@
+"""One-command export pipeline (#15) — the programmatic API the ``export``/``push`` CLIs wrap.
+
+Turns an HF repo id into a #14-shaped device-ready package (``variants/<id>/{train,inference,embedding}``
++ ``shared/`` + ``optimum/`` + ``mobiletransformers_manifest.json`` + ``checksums.json``). A thin
+orchestrator: it *reuses* the export stages (#7 task discovery, #9 inference-package emit, the legacy
+training-artifact + tokenizer builders, #9 mergers) and #14's ``build_manifest`` — it does not
+reimplement them.
+
+Two verifiable-in-CI entry points — ``plan_export`` (pure planning, no heavy deps) and
+``export_package(..., dry_run=True)`` — plus the real ``export_package`` run, which lazy-imports the
+heavy export/train stack and only executes under the export/ORT-training profiles (env-gated; not
+exercised in the core test gate).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.config.constants import PEFTMethod, TaskType
+from mobiletransformers.config.registry.architecture import import_from_path
+from mobiletransformers.config.registry.task import get_task_spec
+from mobiletransformers.exceptions import ConfigValidationError
+
+#: --quant value -> effective precision/weight-type knobs (consumed by the legacy builders).
+_QUANT_SPECS: dict[str, dict[str, Any]] = {
+    "qint8": {"precision": "int8", "weight_type": "QInt8", "dynamic": True},
+    "int4": {"precision": "int4", "weight_type": "MatMul4Bits", "dynamic": False},
+    "fp16": {"precision": "fp16", "weight_type": None, "dynamic": False},
+}
+
+
+def parse_peft(value: str) -> tuple[PEFTMethod, int | None]:
+    """``lora`` / ``lora-xs`` / ``mars`` / ``mars-optN`` (N in 0..4) -> (PEFTMethod, optimization_level)."""
+    value = value.strip().lower()
+    opt_level: int | None = None
+    if value.startswith("mars-opt"):
+        suffix = value[len("mars-opt") :]
+        if not suffix.isdigit() or not (0 <= int(suffix) <= 4):
+            raise ConfigValidationError(
+                f"invalid MARS optimization level in {value!r} (expected mars-opt0..mars-opt4)"
+            )
+        opt_level = int(suffix)
+        method = PEFTMethod.MARS
+    else:
+        try:
+            method = PEFTMethod(value)
+        except ValueError as exc:
+            raise ConfigValidationError(f"unknown --peft value: {value!r}") from exc
+        if method is PEFTMethod.MARS:
+            opt_level = 0
+    return method, opt_level
+
+
+def quant_spec(value: str) -> dict[str, Any]:
+    if value not in _QUANT_SPECS:
+        raise ConfigValidationError(
+            f"unknown --quant value: {value!r} (expected one of {sorted(_QUANT_SPECS)})"
+        )
+    return dict(_QUANT_SPECS[value])
+
+
+@dataclass(frozen=True)
+class ExportPlan:
+    """The resolved, side-effect-free plan for an export (what dry-run reports)."""
+
+    model_id: str
+    task: str
+    peft_method: PEFTMethod
+    optimization_level: int | None
+    rank: int
+    quant: str
+    variant_id: str
+    output_dir: Path
+    features: tuple[str, ...]
+    supported_engines: tuple[str, ...]
+    #: PEFT target modules override. Empty means "use the architecture registry's row for this model",
+    #: which is the per-model source of truth and the one place to edit for a new architecture.
+    peft_targets: tuple[str, ...] = ()
+
+    def variant_descriptor(self) -> dict[str, Any]:
+        """The #14 variant descriptor this plan will emit (fed to build_manifest)."""
+        ep = self.variant_id.split("-", 1)[0]
+        return {
+            "id": self.variant_id,
+            "executionProvider": ep,
+            "quantization": self.quant,
+            "supportedEngines": list(self.supported_engines),
+            "abi": None,
+            "features": list(self.features),
+            "minimumAndroidApi": 28,
+            "recommendedDeviceMemoryMb": None,
+        }
+
+
+def plan_export(
+    *,
+    model: str,
+    output: str | Path,
+    task: str | None = None,
+    peft: str = "lora",
+    rank: int = 8,
+    quant: str = "int4",
+    variant: str | None = None,
+    include_rag: bool = False,
+    engines: tuple[str, ...] = ("native",),
+    peft_targets: tuple[str, ...] = (),
+    discover: Callable[[str], str] | None = None,
+) -> ExportPlan:
+    """Resolve every export decision without touching large files or heavy deps.
+
+    ``task`` auto-selects via ``discover`` (default: the #7 registry) when omitted. ``discover`` is
+    injectable so tests avoid network. ``variant`` defaults to ``cpu-<quant>``.
+
+    ``peft_targets`` overrides which modules PEFT adapts. Left empty (the normal case) the
+    architecture registry's row for the model decides, so support for a new architecture is a data
+    row rather than a flag every caller has to remember.
+    """
+    method, opt = parse_peft(peft)
+    quant_spec(quant)  # validate early
+    resolved_task = task or _discover_task(model, discover)
+    variant_id = variant or f"cpu-{quant}"
+    # The task decides whether a training stage is even possible: `feature-extraction` has no head and
+    # therefore no loss, so claiming `train` produced a package advertising a stage that could never be
+    # built. `_effective_features` still demotes it afterwards based on what actually landed on disk.
+    task_spec = get_task_spec(resolved_task)
+    features = ["core", *task_spec.stages] + (["rag"] if include_rag else [])
+    if "genai" in engines:
+        features.append("genai")
+    return ExportPlan(
+        model_id=model,
+        task=resolved_task,
+        peft_method=method,
+        optimization_level=opt,
+        rank=rank,
+        quant=quant,
+        variant_id=variant_id,
+        output_dir=Path(output),
+        features=tuple(features),
+        supported_engines=tuple(engines),
+        peft_targets=tuple(peft_targets),
+    )
+
+
+def _discover_task(model: str, discover: Callable[[str], str] | None) -> str:
+    if discover is not None:
+        return discover(model)
+    # Real path: lazy-import the registry (pulls optimum). Only hit when no --task + no injection.
+    from mobiletransformers.config.settings import get_settings
+    from mobiletransformers.exceptions import UnsupportedModelError
+    from mobiletransformers.export.registry import choose_task, discover_tasks
+
+    # The token matters here: a GATED base model 401s on its config read, and `discover_tasks` is
+    # fail-open — it swallows the exception into `blocker` and returns no tasks.
+    discovery = discover_tasks(model, token=get_settings().hf_token)
+
+    # Surface that blocker. Without this the caller sees `choose_task(())` fail with "no supported
+    # task in preference order (...) for []", which names neither the model nor the reason — an empty
+    # list reads as "this architecture is unsupported" when the actual cause was a missing token or a
+    # network error. Measured 2026-08-17 on google/gemma-3-270m-it, which cost a full export run to
+    # diagnose because the real message had already been computed and thrown away.
+    if not discovery.supported_tasks:
+        raise UnsupportedModelError(
+            f"cannot determine an export task for {model!r}: "
+            f"{discovery.blocker or 'Optimum reports no ONNX task for this model type'}"
+        )
+    return choose_task(discovery.supported_tasks)
+
+
+def manifest_skeleton(plan: ExportPlan, *, base_model_id: str | None = None) -> dict[str, Any]:
+    """A planning-only manifest preview (no integrity maps) — what ``--dry-run`` prints."""
+    return {
+        "schemaVersion": "1.0",
+        "minReaderVersion": "1.0",
+        "baseModelId": base_model_id or plan.model_id,
+        "selectedTask": plan.task,
+        "peftMethods": [plan.peft_method.value],
+        "quantization": [plan.quant],
+        "defaultVariant": plan.variant_id,
+        "variants": [plan.variant_descriptor()],
+        "_dryRun": True,
+    }
+
+
+@dataclass
+class ExportedPackage:
+    output_dir: Path
+    manifest_path: Path
+    plan: ExportPlan
+    extras: dict[str, Any] = field(default_factory=dict)
+
+
+def assemble_package(
+    plan: ExportPlan,
+    stage_dirs: dict[str, str | Path],
+    *,
+    base_model_id: str,
+    report: dict[str, Any],
+    exported_at: str | None = None,
+) -> ExportedPackage:
+    """Reshape already-produced stage outputs into the #14 tree + emit manifest/checksums (steps 9-10).
+
+    ``stage_dirs`` maps ``inference``/``train``/``embedding``/``tokenizer`` -> a source directory already
+    in that stage's internal shape. Directories are copied into ``variants/<id>/<stage>`` (tokenizer into
+    ``shared/tokenizer``), then ``build_manifest`` stream-hashes the tree. Pure filesystem — verifiable in
+    CI over synthetic stage dirs; this is the layer the export-E2E checkpoint asserts against #13.
+    """
+    import shutil
+
+    from mobiletransformers.hub.package_format import (
+        build_manifest,
+        write_manifest,
+        write_variant_checksums,
+    )
+
+    out = plan.output_dir
+    vid = plan.variant_id
+    variant_root = out / "variants" / vid
+    for stage in ("train", "inference", "embedding"):
+        src = stage_dirs.get(stage)
+        if src is not None and Path(src).is_dir():
+            shutil.copytree(Path(src), variant_root / stage, dirs_exist_ok=True)
+    tok = stage_dirs.get("tokenizer")
+    if tok is not None and Path(tok).is_dir():
+        shutil.copytree(Path(tok), out / "shared" / "tokenizer", dirs_exist_ok=True)
+
+    # optimum/ provenance reports from the export metadata.
+    import json as _json
+
+    opt_dir = out / "optimum"
+    opt_dir.mkdir(parents=True, exist_ok=True)
+    (opt_dir / "export_report.json").write_text(_json.dumps(report, indent=2, sort_keys=True) + "\n")
+    (opt_dir / "supported_tasks.json").write_text(
+        _json.dumps(list(report.get("supportedTasks", [])), indent=2) + "\n"
+    )
+
+    manifest = build_manifest(
+        out,
+        [plan.variant_descriptor()],
+        base_model_id=base_model_id,
+        report=report,
+        default_variant=vid,
+        exported_at=exported_at,
+    )
+    write_variant_checksums(out, manifest)
+    manifest = build_manifest(
+        out,
+        [plan.variant_descriptor()],
+        base_model_id=base_model_id,
+        report=report,
+        default_variant=vid,
+        exported_at=exported_at,
+    )
+    manifest_path = write_manifest(out, manifest)
+    return ExportedPackage(output_dir=out, manifest_path=manifest_path, plan=plan)
+
+
+def export_package(
+    *,
+    model: str,
+    output: str | Path,
+    task: str | None = None,
+    peft: str = "lora",
+    rank: int = 8,
+    quant: str = "int4",
+    variant: str | None = None,
+    include_rag: bool = False,
+    embedding_model: str | None = None,
+    engines: tuple[str, ...] = ("native",),
+    peft_targets: tuple[str, ...] = (),
+    dry_run: bool = False,
+    stages: set[str] | None = None,
+    token: str | None = None,
+    discover: Callable[[str], str] | None = None,
+) -> ExportPlan | ExportedPackage:
+    """Export ``model`` into a #14 package at ``output``.
+
+    ``dry_run=True`` returns the resolved :class:`ExportPlan` (no files, no heavy deps). A real run
+    lazy-imports the export stack and builds the selected ``stages`` (default: auto by request +
+    importable deps). A train-capable package is produced across two profile-scoped runs (see
+    :func:`_full_export`).
+    """
+    plan = plan_export(
+        model=model,
+        output=output,
+        task=task,
+        peft=peft,
+        rank=rank,
+        quant=quant,
+        variant=variant,
+        include_rag=include_rag,
+        engines=engines,
+        peft_targets=peft_targets,
+        discover=discover,
+    )
+    if dry_run:
+        return plan
+    return _full_export(plan, token=token, embedding_model=embedding_model, stages=stages)
+
+
+# --- real export: stage-gated orchestrator (#15) ------------------------------------------------
+
+#: Stage name -> the manifest feature it satisfies (F1 feature→subtree contract, #13 validator).
+_STAGE_FEATURE = {"inference": "inference", "training": "train", "embedding": "rag"}
+
+
+@dataclass
+class StageOutput:
+    """What one stage builder produced: the stage_dirs to hand ``assemble_package`` + report fields.
+
+    ``stage_dirs`` keys are the assemble keys (``inference``/``train``/``embedding``/``tokenizer``);
+    ``report`` fields are merged into the manifest provenance (non-null wins).
+    """
+
+    stage_dirs: dict[str, Path] = field(default_factory=dict)
+    report: dict[str, Any] = field(default_factory=dict)
+
+
+#: A stage builder: resolved plan + a staging dir -> its outputs. Heavy deps imported lazily inside.
+StageBuilder = Callable[..., StageOutput]
+
+
+def _pkg_version(dist: str) -> str | None:
+    from importlib import metadata
+
+    try:
+        return metadata.version(dist)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _training_available() -> bool:
+    """True iff the ORT-training stack is actually **usable** (``ort-training-local`` profile active).
+
+    This performs the real import rather than probing for the module, because *present* and *usable*
+    are different things here and the difference is not hypothetical: the **public** ``onnxruntime``
+    wheel ships an ``onnxruntime/training/`` directory too, so ``find_spec`` returns a spec under the
+    export profile — but importing it dies with
+
+        ImportError: cannot import name 'PropagateCastOpsStrategy' from 'onnxruntime.capi._pybind_state'
+
+    because the public build has no training pybind state. `_select_stages` then selected the training
+    stage under a profile that cannot build one, and the export crashed inside ``artifacts/builder.py``
+    with a traceback naming a symbol rather than the profile.
+
+    Importing costs a second and happens once per export, against a failure mode that costs a full
+    export cycle. The symbols are the ones ``artifacts/builder.py`` imports at module scope, so this
+    answers the question that is actually being asked: *will that import succeed?*
+    """
+    try:
+        from onnxruntime.training import artifacts, onnxblock  # noqa: F401
+    except Exception:  # noqa: BLE001 - any failure means the stage cannot be built
+        return False
+    return True
+
+
+def _select_stages(plan: ExportPlan, stages: set[str] | None) -> set[str]:
+    """Which stages to attempt. Explicit ``stages`` wins; else auto-detect by request + importable deps."""
+    if stages is not None:
+        unknown = stages - set(_STAGE_FEATURE)
+        if unknown:
+            raise ConfigValidationError(f"unknown export stage(s): {sorted(unknown)}")
+        return set(stages)
+    selected = {"inference"}  # the always-required floor
+    if "rag" in plan.features:
+        selected.add("embedding")
+    if _training_available():
+        selected.add("training")
+    return selected
+
+
+def _base_report(plan: ExportPlan) -> dict[str, Any]:
+    return {
+        "mobiletransformersVersion": _pkg_version("mobiletransformers") or "0.0.0",
+        "architectures": [],
+        "supportedTasks": [plan.task],
+        "selectedTask": plan.task,
+        "trustRemoteCode": False,
+        "peftMethods": [plan.peft_method.value],
+        "quantization": [plan.quant],
+        "androidRuntime": {"minimumAndroidApi": 28, "recommendedDeviceMemoryMb": None, "requiredAbis": []},
+        "license": {"framework": None, "baseModelWeights": None, "noticeFile": None},
+    }
+
+
+def _effective_features(plan: ExportPlan, stage_dirs: dict[str, str | Path]) -> tuple[str, ...]:
+    """Features the manifest may honestly claim: ``core`` + the stages actually present (+ ``genai`` iff
+    requested AND a ``genai_config.json`` was emitted). Unions THIS run's ``stage_dirs`` with what is
+    already on disk in the assembled variant tree, so a training-only re-assembly (a separate profile run)
+    does not drop the ``inference``/``genai`` features produced by the earlier run. Never claim a subtree
+    that isn't present — the #13 validator checks feature→path presence for train/inference/rag."""
+    variant_dir = plan.output_dir / "variants" / plan.variant_id
+
+    def present(stage: str, marker: str) -> bool:
+        return stage in stage_dirs or (variant_dir / stage / marker).exists()
+
+    feats = ["core"]
+    if present("inference", "model.onnx"):
+        feats.append("inference")
+    if present("train", "training_config.json"):
+        feats.append("train")
+    if present("embedding", "rag_config.json"):
+        feats.append("rag")
+
+    inf = stage_dirs.get("inference")
+    genai_config = (
+        (Path(inf) / "genai_config.json").is_file()
+        if inf is not None
+        else (variant_dir / "inference" / "genai_config.json").is_file()
+    )
+    if "genai" in plan.supported_engines and genai_config:
+        feats.append("genai")
+    return tuple(feats)
+
+
+#: Manifest provenance whose ONLY producer is the inference stage: (report key, optimum_config key).
+#:
+#: A train-capable package is necessarily built by two profile-scoped runs into one output dir (the
+#: onnxruntime profiles cannot co-install), and the second run rebuilds the manifest from
+#: ``_base_report``, which knows none of these. So `--stages training` used to publish a manifest with
+#: ``transformersVersion: null`` and ``architectures: []`` — the fields that would have attributed a
+#: pushed package to a transformers line, which is exactly what was needed to diagnose the 4.57 export
+#: regression.
+_INFERENCE_PROVENANCE: tuple[tuple[str, str], ...] = (
+    ("transformersVersion", "transformersVersion"),
+    ("optimumOnnxVersion", "optimumOnnxVersion"),
+    ("architectures", "modelType"),
+    ("trustRemoteCode", "trustRemoteCode"),
+)
+
+
+def _carry_forward_inference_provenance(
+    plan: ExportPlan, report: dict[str, Any], stage_dirs: dict[str, str | Path]
+) -> None:
+    """Recover inference-stage provenance from disk when this run did not build that stage.
+
+    Read back from ``inference/optimum_config.json`` — which the inference stage wrote next to the graph
+    it describes — rather than re-derived from the current environment: the training profile pins a
+    *different* transformers than the export profile, so re-deriving would stamp the manifest with a
+    version that never touched the graph. That is worse than the null it replaces.
+
+    Only unset-shaped values are filled, so a run that DID export inference always wins.
+    """
+    if "inference" in stage_dirs:
+        return
+    config_path = plan.output_dir / "variants" / plan.variant_id / "inference" / "optimum_config.json"
+    if not config_path.is_file():
+        return
+
+    import json as _json
+
+    from mobiletransformers.utils.logging import get_logger
+
+    try:
+        recorded = _json.loads(config_path.read_text())
+    except (OSError, ValueError):  # a corrupt side-car must not fail an otherwise-good export
+        return
+
+    for report_key, config_key in _INFERENCE_PROVENANCE:
+        value = recorded.get(config_key)
+        if value in (None, "", [], {}):
+            continue
+        if report_key == "architectures":
+            value = [value]
+        current = report.get(report_key)
+        if current in (None, "", [], {}) or (report_key == "trustRemoteCode" and current is False):
+            report[report_key] = value
+
+    # The task is NOT carried over — this run built its own stage for `plan.task`, and silently
+    # relabelling the package as the recorded task would hide a genuine disagreement. Say so instead:
+    # the training and packaging halves resolving different rows for one model is a defect this
+    # project has already paid for once.
+    recorded_task = recorded.get("task")
+    if recorded_task and recorded_task != report.get("selectedTask"):
+        get_logger(__name__).warning(
+            "export: this run's task %r differs from the task the shipped inference graph was "
+            "exported for (%r, from %s). The package now describes two different tasks.",
+            report.get("selectedTask"),
+            recorded_task,
+            config_path,
+        )
+
+
+def _default_builders() -> dict[str, StageBuilder]:
+    return {
+        "inference": _build_inference_stage,
+        "training": _build_training_stage,
+        "embedding": _build_embedding_stage,
+    }
+
+
+def _build_inference_stage(
+    plan: ExportPlan, dest: Path, *, token: str | None, embedding_model: str | None
+) -> StageOutput:
+    """Real inference stage (``export`` profile): one dir both engines read from a single source of truth.
+
+    Produces ``inference/`` with the normalized Native-ready ``model.onnx`` (+ ``model.onnx_data``),
+    ``generation_config.json``, tokenizer files, an empty ``weight_handoff_map.json`` (all-frozen base —
+    the training stage overwrites it with trainable entries), and a best-effort ``genai_config.json`` so
+    the GenAI engine loads the SAME ``model.onnx``. Tokenizer is also copied to the ``tokenizer`` stage
+    for ``shared/tokenizer`` + the on-device ``mobiletransformers_tokenizer_config.json``.
+    """
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+    from mobiletransformers.export.inference_export import export_inference
+    from mobiletransformers.utils.logging import get_logger
+
+    log = get_logger(__name__)
+    # What this stage writes beyond the graph — cache metadata, a GenAI decoder block — is a property
+    # of the TASK, not something every package gets.
+    task_spec = get_task_spec(plan.task)
+    dest = Path(dest)
+    inf = dest / "inference"
+    tok = dest / "tokenizer"
+    inf.mkdir(parents=True, exist_ok=True)
+    tok.mkdir(parents=True, exist_ok=True)
+
+    result = export_inference(plan.model_id, inf, task=plan.task, token=token)
+
+    # All-frozen base: a valid empty handoff map (the #13 validator + build_manifest require the file to
+    # exist and resolve; the training stage replaces it with the trainable-tensor entries).
+    HandoffMap(entries=[]).save(inf / "weight_handoff_map.json")
+
+    # Tokenizer stage (copied — the GenAI dir also needs tokenizer.json beside model.onnx/genai_config).
+    _populate_tokenizer_stage(plan, result, inf, tok, token=token, log=log)
+
+    # The Native engine reads its KV-cache geometry from the graph's own metadata, so this is required,
+    # not best-effort — see _stamp_runtime_metadata.
+    # Only for tasks that HAVE a cache. The Native engine fails closed when this metadata is missing,
+    # but an encoder has no cache to size, and stamping a decoder's geometry onto one is worse than
+    # omitting it.
+    if task_spec.stamps_kv_metadata:
+        _stamp_runtime_metadata(plan, inf / "model.onnx", result, token=token)
+
+    # Best-effort GenAI config so both engines read one dir; dropped from features if it can't be emitted.
+    if task_spec.emits_genai_config and "genai" in plan.supported_engines:
+        try:
+            _emit_genai_config(plan, inf, result, token=token)
+        except Exception as exc:  # noqa: BLE001 - never fail the whole export on the GenAI side-car
+            log.warning("genai_config.json not emitted (package will be Native-only): %s", exc)
+
+    report = {
+        "architectures": [result.model_type] if result.model_type else [],
+        "supportedTasks": [result.task],
+        "selectedTask": result.task,
+        "optimumOnnxVersion": result.optimum_onnx_version,
+        "transformersVersion": result.transformers_version,
+        "trustRemoteCode": result.trust_remote_code,
+    }
+
+    # #15 DoD: record HOW this graph was produced, next to the graph. Without it a shipped package
+    # cannot be traced back to the exporter/task that made it.
+    #
+    # `quantization` is the variant's REQUESTED setting, which drives the training stage and the
+    # variant id (`cpu-<quant>`). The inference export does not quantize, so a variant named
+    # `cpu-int4` ships an fp32 inference graph — a real asymmetry that nothing declared, leaving the
+    # directory name as the only (wrong) signal. `inferenceGraphPrecision` is measured from the graph
+    # that actually shipped, so the two can never silently diverge again.
+    from mobiletransformers.artifacts.parameter_budget import describe_graph_precision
+
+    optimum_config: dict[str, Any] = {
+        "modelId": plan.model_id,
+        "task": result.task,
+        "modelType": result.model_type,
+        "optimumOnnxVersion": result.optimum_onnx_version,
+        "transformersVersion": result.transformers_version,
+        "trustRemoteCode": result.trust_remote_code,
+        "quantization": plan.quant,
+        "inferenceGraphPrecision": describe_graph_precision(inf / "model.onnx"),
+        "supportedEngines": list(plan.supported_engines),
+    }
+
+    # A classification head predicts an INDEX, and an index is not an answer. Without the label names
+    # the device can run the graph and report `LABEL_3` — a number in a costume — so #33's encoder
+    # support stopped one step short of being usable: a model could be fine-tuned on device and then
+    # never asked anything meaningful. The names live in the source model's own config and cost a few
+    # bytes to carry.
+    id2label = _read_id2label(plan, token=token, log=log)
+    if id2label:
+        optimum_config["id2label"] = id2label
+
+    _write_json(inf / "optimum_config.json", optimum_config)
+    return StageOutput(
+        stage_dirs={"inference": inf, "tokenizer": tok},
+        report={k: v for k, v in report.items() if v is not None},
+    )
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    """Deterministic JSON write (sorted keys) so package checksums are stable."""
+    import json
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def _populate_tokenizer_stage(
+    plan: ExportPlan, result: Any, inf: Path, tok: Path, *, token: str | None, log: Any
+) -> None:
+    """Copy the exported tokenizer files into the tokenizer stage, emit ``chat_template.jinja``, and
+    the on-device ``mobiletransformers_tokenizer_config.json`` (Android Native tokenizer)."""
+    import shutil
+
+    for name in getattr(result, "tokenizer_files", ()):  # relative names under the export dir
+        src = inf / name
+        if src.is_file():
+            shutil.copy2(src, tok / Path(name).name)
+
+    # #15 DoD: the chat template as a standalone file. It is reshaped to shared/chat_template.jinja and
+    # flattened into tokenizer/ by the installers, which is where the device conversation state reads it.
+    _emit_chat_template(plan, tok, token=token, log=log)
+
+    # Migration Map S1: this now lives in the package, so it resolves from an installed wheel too.
+    from mobiletransformers.export.tokenizer_export import export_tokenizer_config
+
+    try:
+        # export_tokenizer_config appends its own `tokenizer/` under output_dir, so it takes the stage's
+        # PARENT. Passing `tok` nested it one level deeper (`tokenizer/tokenizer/…`), which duplicated
+        # every tokenizer file into the package and — because this is the only file carrying
+        # `model.vocab_size` — left `ORTTokenizerNative.vocabSize` at 0 on device, aborting generation in
+        # `greedySampling`'s `vocab_size > 0` assert.
+        export_tokenizer_config(plan.model_id, output_dir=str(tok.parent), hf_token=token)
+    except Exception as exc:
+        from mobiletransformers.exceptions import ExportError
+
+        raise ExportError(
+            f"mobiletransformers_tokenizer_config.json could not be emitted for {plan.model_id!r}: {exc}"
+        ) from exc
+
+    # Required, not best-effort: the Native tokenizer reads vocab_size / special-token ids only from
+    # this file. Its absence is not a degraded package — generation aborts on device in
+    # `greedySampling`'s `vocab_size > 0` assert, long after the export reported success.
+    emitted = tok / "mobiletransformers_tokenizer_config.json"
+    if not emitted.is_file():
+        from mobiletransformers.exceptions import ExportError
+
+        raise ExportError(
+            f"expected {emitted} after tokenizer export; the Native engine cannot load a package without it."
+        )
+
+
+def _emit_chat_template(plan: ExportPlan, tok: Path, *, token: str | None, log: Any) -> None:
+    """Write the tokenizer's Jinja chat template to ``chat_template.jinja`` when the model has one."""
+    try:
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(plan.model_id, token=token)
+        template = getattr(tokenizer, "chat_template", None)
+    except Exception as exc:  # noqa: BLE001 - a base model without a chat template is normal
+        log.warning("chat_template.jinja not emitted: %s", exc)
+        return
+    if not template:
+        log.info("%s declares no chat_template; skipping chat_template.jinja", plan.model_id)
+        return
+    (tok / "chat_template.jinja").write_text(template, encoding="utf-8")
+
+
+#: ONNX custom-metadata keys the Android Native engine reads to size its KV cache
+#: (`session_cache.h::loadModelMetadata`). Names are the contract; do not rename one side only.
+RUNTIME_METADATA_KEYS = ("head_dim", "num_kv_heads", "num_layers")
+
+
+def _read_id2label(plan: ExportPlan, *, token: str | None, log: Any) -> dict[str, str]:
+    """The classification head's label names, keyed by stringified class index.
+
+    A classification graph predicts an **index**, and an index is not an answer. Without the names the
+    device can run the model and report ``LABEL_3``, so #33's encoder support stopped one step short of
+    usable: a classifier could be fine-tuned on device and then never asked anything meaningful.
+
+    Keys are strings because that is how HF writes them and how JSON carries them; the Kotlin reader
+    (``packages/PackageTask.kt``) parses them back to ints.
+
+    Best-effort by design. A model whose config omits ``id2label``, or a config that cannot be reached,
+    must not fail an otherwise-good export — the names are a convenience for one task, and every other
+    task ignores them entirely.
+    """
+    try:
+        spec = get_task_spec(plan.task)
+    except Exception:  # noqa: BLE001 - an unknown task simply has no labels to record
+        return {}
+    if spec.task is not TaskType.SEQUENCE_CLASSIFICATION:
+        # Not a classification objective. A decoder's `id2label` is either absent or a leftover from
+        # some other head, and recording it would tell the device this package classifies.
+        return {}
+
+    try:
+        from transformers import AutoConfig
+
+        cfg = AutoConfig.from_pretrained(plan.model_id, token=token, trust_remote_code=False)
+    except Exception as exc:  # noqa: BLE001 - a missing side-car must not fail the export
+        log.warning("id2label not recorded (config unreadable): %s", exc)
+        return {}
+
+    mapping = getattr(cfg, "id2label", None)
+    if not isinstance(mapping, dict) or not mapping:
+        return {}
+    return {str(index): str(name) for index, name in mapping.items()}
+
+
+def _model_dims(plan: ExportPlan, result: Any, *, token: str | None) -> dict[str, int]:
+    """Decoder geometry from the HF config, with the same fallbacks both consumers need.
+
+    Single source for `genai_config.json` and the graph metadata, so the two can never disagree about
+    how many layers or KV heads the exported model has.
+    """
+    from transformers import AutoConfig
+
+    cfg = AutoConfig.from_pretrained(
+        plan.model_id, token=token, trust_remote_code=getattr(result, "trust_remote_code", False)
+    )
+
+    def _attr(*names: str, default: Any = None) -> Any:
+        for n in names:
+            if getattr(cfg, n, None) is not None:
+                return getattr(cfg, n)
+        return default
+
+    hidden = _attr("hidden_size", default=0)
+    heads = _attr("num_attention_heads", default=0)
+    return {
+        "hidden_size": hidden,
+        "num_attention_heads": heads,
+        "num_kv_heads": _attr("num_key_value_heads", "num_attention_heads", default=heads),
+        "head_dim": _attr("head_dim", default=(hidden // heads if heads else 0)),
+        "context_length": _attr("max_position_embeddings", "n_positions", default=2048),
+        "num_layers": _attr("num_hidden_layers", "n_layer", default=result.kv_layers),
+        "vocab_size": _attr("vocab_size", default=0),
+        "bos_token_id": _attr("bos_token_id", default=1),
+        "eos_token_id": _attr("eos_token_id", default=2),
+        "pad_token_id": _attr("pad_token_id", "eos_token_id", default=0),
+        "model_type": _attr("model_type", default=result.model_type or ""),
+    }
+
+
+def _stamp_runtime_metadata(plan: ExportPlan, model_path: Path, result: Any, *, token: str | None) -> None:
+    """Write the KV-cache geometry into the graph's `metadata_props`.
+
+    The Android Native engine sizes its KV cache purely from these three keys
+    (`session_cache.h::loadModelMetadata` -> `initializeKVCache`). The legacy `inference/builder.py`
+    graphs carried them; an Optimum-exported graph does not. Without them `num_layers` stays 0, no past
+    key/value tensors are created, and `generateWithKVCache` then hands ORT 3 input values while
+    declaring the graph's full input count — an out-of-bounds read that **segfaults on device**. Nothing
+    host-side could see it: the manifest validates, both engines load, and only a real generate crashes.
+
+    Cheap: the model is loaded with `load_external_data=False`, so only the graph proto is rewritten and
+    the `model.onnx_data` blob beside it is untouched.
+    """
+    import onnx
+
+    dims = _model_dims(plan, result, token=token)
+    model = onnx.load(str(model_path), load_external_data=False)
+    existing = {p.key for p in model.metadata_props}
+    for key in RUNTIME_METADATA_KEYS:
+        if key in existing:
+            continue
+        entry = model.metadata_props.add()
+        entry.key = key
+        entry.value = str(dims[key])
+    onnx.save(model, str(model_path))
+
+
+def _emit_genai_config(plan: ExportPlan, inference_dir: Path, result: Any, *, token: str | None) -> None:
+    """Emit ``genai_config.json`` into ``inference_dir`` describing the exported ``model.onnx`` so the
+    GenAI engine loads the SAME graph the Native engine does.
+
+    ``genai_config`` is model-intrinsic — dims / head & layer counts / canonical KV-IO names / special
+    tokens — and the canonical IO scheme is fixed (the same names ``normalize.py`` verifies and the
+    legacy ``make_genai_config`` hard-wires). We build it directly from the HF ``AutoConfig`` (+ the
+    normalized ``ExportResult``), so it needs only ``transformers`` (the ``export`` profile) — not the
+    vendored GenAI builder, which imports an ``onnxruntime`` symbol absent from that profile.
+    """
+    import json
+
+    dims = _model_dims(plan, result, token=token)
+    hidden = dims["hidden_size"]
+    heads = dims["num_attention_heads"]
+    kv_heads = dims["num_kv_heads"]
+    head_size = dims["head_dim"]
+    context = dims["context_length"]
+    layers = dims["num_layers"]
+
+    genai = {
+        "model": {
+            "bos_token_id": dims["bos_token_id"],
+            "eos_token_id": dims["eos_token_id"],
+            "pad_token_id": dims["pad_token_id"],
+            "context_length": context,
+            "type": dims["model_type"],
+            "vocab_size": dims["vocab_size"],
+            "decoder": {
+                "session_options": {"provider_options": []},
+                "filename": "model.onnx",
+                "head_size": head_size,
+                "hidden_size": hidden,
+                "num_attention_heads": heads,
+                "num_key_value_heads": kv_heads,
+                "num_hidden_layers": layers,
+                "inputs": {
+                    "input_ids": "input_ids",
+                    "attention_mask": "attention_mask",
+                    "position_ids": "position_ids",
+                    "past_key_names": "past_key_values.%d.key",
+                    "past_value_names": "past_key_values.%d.value",
+                },
+                "outputs": {
+                    "logits": "logits",
+                    "present_key_names": "present.%d.key",
+                    "present_value_names": "present.%d.value",
+                },
+            },
+        },
+        "search": {
+            "max_length": context,
+            "min_length": 0,
+            "do_sample": False,
+            "top_k": 1,
+            "top_p": 1.0,
+            "temperature": 1.0,
+            "repetition_penalty": 1.0,
+        },
+    }
+    (inference_dir / "genai_config.json").write_text(json.dumps(genai, indent=2) + "\n", encoding="utf-8")
+
+
+def _build_training_stage(
+    plan: ExportPlan, dest: Path, *, token: str | None, embedding_model: str | None
+) -> StageOutput:
+    """Training stage seam (``ort-training-local`` profile). Wires ``gen_artifacts`` (→ training/eval/
+    optimizer models + checkpoint + the extended ``training_config.json`` carrying ``peft_mapping``) and
+    then ``export_inference_package`` for the per-tensor ``.bin`` + ``frozen_base.onnx.data`` +
+    trainable ``weight_handoff_map.json`` + merger graphs into the inference dir.
+
+    Staged: the body lands in a follow-on ``ort-training-local`` run. Selected-but-unavailable fails
+    closed naming the profile.
+    """
+    import os
+
+    from mobiletransformers.exceptions import ExportError
+    from mobiletransformers.utils.logging import get_logger
+
+    log = get_logger(__name__)
+    if not _training_available():
+        raise ExportError(
+            "training stage requires the ort-training-local profile "
+            "(`uv sync --python 3.12 --group ort-training-local`)"
+        )
+
+    # The inference stage (a prior `export`-profile run) must already have assembled the package; the
+    # training stage reads that inference model.onnx and writes the trainable split back into it.
+    inference_dir = plan.output_dir / "variants" / plan.variant_id / "inference"
+    inference_onnx = inference_dir / "model.onnx"
+    if not inference_onnx.is_file():
+        raise ExportError(
+            f"training stage requires the inference package first — {inference_onnx} not found. "
+            "Run the inference export (export profile) into the same --output before --stages training."
+        )
+
+    if token:
+        os.environ.setdefault("HF_TOKEN", token)
+
+    dest = Path(dest)
+    train_export = dest / "train_export"  # optimum_hf_export scratch (quant_model.onnx + training_config)
+    train_stage = dest / "train"  # the assembled train/ stage dir
+    train_export.mkdir(parents=True, exist_ok=True)
+    train_stage.mkdir(parents=True, exist_ok=True)
+
+    # Migration Map S2: in the package now, and core-importable (onnx only) — so it is a normal import.
+    # Migration Map S4: training_export is in the package (its torch/optimum imports stay lazy inside).
+    # Migration Map S5: the last legacy arrow is gone — the export path is fully in-package, so it
+    # resolves from an installed wheel. Its torch/onnxruntime-training imports remain lazy inside.
+    from transformers import AutoConfig
+
+    from mobiletransformers.artifacts.builder import gen_artifacts
+    from mobiletransformers.export.inference_package import export_inference_package
+    from mobiletransformers.export.training_export import optimum_hf_export
+
+    quantized = plan.quant != "fp16"
+    # `get_task_spec` already strips the `-with-past` suffix (the suffix selects graph shape, not task
+    # identity), so this is the registry lookup the old `plan.task.startswith("text-generation")`
+    # string test was standing in for.
+    task_spec = get_task_spec(plan.task)
+    task_type = task_spec.task.value
+
+    # 1) Producer of peft_mapping/requires_grad + the training graph (quant_model.onnx + training_config).
+    log.info("training stage: optimum_hf_export(%s) -> %s", plan.model_id, train_export)
+    optimum_hf_export(
+        model_id=plan.model_id,
+        model_output=str(train_export),
+        training_mode=True,
+        train_method=plan.peft_method.value,
+        lora_rank=plan.rank,
+        lora_alpha=plan.rank,
+        quantize=quantized,
+        task_type=task_type,
+        # Empty -> the architecture registry's row decides (the per-model source of truth).
+        lora_target=list(plan.peft_targets) or None,
+    )
+
+    # 2) Training artifacts (training/eval/optimizer models + checkpoint/ + extended training_config.json).
+    extended_config = gen_artifacts(
+        train_dir=str(train_export),
+        artifact_dir=str(train_stage),
+        model_name="quant_model.onnx" if quantized else "model.onnx",
+        training_config={},
+    )
+
+    # 3) Overwrite the empty handoff map with the real trainable split into the assembled inference dir.
+    model_config = AutoConfig.from_pretrained(plan.model_id, token=token, trust_remote_code=False)
+    log.info("training stage: export_inference_package -> %s (trainable split + handoff map)", inference_dir)
+    export_inference_package(
+        model_path=str(inference_onnx),
+        output_dir=str(inference_dir),
+        training_config=extended_config,
+        model_config=model_config,
+        peft_method=plan.peft_method,
+        quant_in=quantized,
+        quant_out=quantized,
+    )
+
+    # 3b) Prove the two halves of the merge contract agree BEFORE the package ships.
+    #
+    # The handoff map records a `trainingBaseLayerName` per entry; the device merger turns each into a
+    # checkpoint lookup. Nothing verified those lookups could succeed, so three separate name-shape
+    # defects each survived export, push and install, and only surfaced as a merge that wrote nothing.
+    # This is the cheap host-side check that would have caught all three (see checkpoint_names.py).
+    from mobiletransformers.artifacts.checkpoint_names import verify_handoff_names_resolve
+
+    checkpoint_path = train_stage / "checkpoint"
+    if checkpoint_path.exists():
+        verify_handoff_names_resolve(inference_dir / "weight_handoff_map.json", checkpoint_path)
+    else:
+        log.warning(
+            "no checkpoint at %s — skipping the handoff-name check; the merge contract is UNVERIFIED",
+            checkpoint_path,
+        )
+
+    # 3c) Prove the training graph carries the model's parameters — the check that was missing.
+    #
+    # The name check above is structural: it proves the merge can FIND its weights, not that the
+    # weights are there. Nothing counted anything, which is how a byte/dtype arithmetic slip became a
+    # recorded "two thirds of the model is missing" v1 blocker that was never true. This counts, per
+    # dtype, against the source model's own parameter count. See artifacts/parameter_budget.py.
+    from mobiletransformers.artifacts.parameter_budget import verify_checkpoint_parameter_budget
+
+    training_model_path = train_stage / "training_model.onnx"
+    parameter_summary = None
+    if training_model_path.exists():
+        parameter_summary = verify_checkpoint_parameter_budget(
+            training_model_path,
+            extended_config.get("source_parameter_count"),
+        )
+    else:
+        log.warning(
+            "no training model at %s — skipping the parameter-budget check; the training stage is "
+            "UNVERIFIED against the source model",
+            training_model_path,
+        )
+
+    # 3d) Prove the two graphs agree on numbers, not just on names.
+    #
+    # The budget check proves the parameters are present; this proves they are the SAME ones the
+    # inference half ships, by running identical tokens through both and bounding the loss gap. It is
+    # what supplies a reference for any later "the training loss looks high" question — the absence of
+    # one is how a quantization-sized gap was once read as missing weights.
+    parity = None
+    if task_spec.parity_check is None:
+        # Recorded, not skipped silently. The causal checker shifts logits[:, :-1] against
+        # input_ids[:, 1:] and needs rank-3 logits; a per-sequence objective emits [batch, labels], so
+        # running it there would raise and read as "the package is broken".
+        log.warning(
+            "no train/inference parity gate for task %r — this package ships without that check",
+            task_spec.task.value,
+        )
+    elif training_model_path.exists() and inference_onnx.exists():
+        verify_parity = import_from_path(task_spec.parity_check)
+        parity = verify_parity(inference_onnx, train_stage)
+
+    # #15 DoD: name the trainable tensors in the package itself. The count alone (in the manifest)
+    # says how many; this says WHICH, so an adapter push or a federated round can be checked against
+    # the package without re-deriving the PEFT mapping.
+    peft_mapping = extended_config.get("peft_mapping") or {}
+    _write_json(
+        train_stage / "trainable_parameters.json",
+        {
+            "peftMethod": plan.peft_method.value,
+            "rank": plan.rank,
+            "trainableParameterCount": extended_config.get("trainable_parameter_count"),
+            "baseLayers": sorted(peft_mapping),
+            "requiresGrad": sorted(extended_config.get("requires_grad") or []),
+        },
+    )
+
+    report = {
+        "peftMethods": [plan.peft_method.value],
+        "trainableParameterCount": extended_config.get("trainable_parameter_count"),
+        "onnxRuntimeTrainingVersion": _pkg_version("onnxruntime-training"),
+    }
+    if parameter_summary is not None:
+        # Recorded so a package can be audited without re-reading its graph — and so the fp32/quantized
+        # split is visible rather than inferred from a file size (the mistake parameter_budget.py exists
+        # to prevent).
+        report["trainingParameterCount"] = parameter_summary.total
+        report["trainingQuantizedParameterCount"] = parameter_summary.quantized
+        report["sourceParameterCount"] = extended_config.get("source_parameter_count")
+    if parity is not None:
+        # The measured gap between the package's two halves. Recorded so the next reader of a
+        # surprising training loss has a number to compare against instead of a guess.
+        report["trainInferenceLossDeltaNats"] = round(parity.delta, 4)
+    return StageOutput(
+        stage_dirs={"train": train_stage},
+        report={k: v for k, v in report.items() if v is not None},
+    )
+
+
+#: Default RAG encoder for ``--include-rag`` without ``--embedding-model``. 384-dim (in
+#: ``DimensionRegistry.SUPPORTED_DIMENSIONS``) and small enough to ship beside the decoder.
+DEFAULT_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+#: Dimensions the on-device vector store can index. Mirrors the Kotlin `DimensionRegistry`
+#: (`rag/VectorStoreRegistry.kt`) — a package whose encoder emits anything else cannot be indexed,
+#: so the export fails closed rather than shipping an unusable `embedding/` subtree.
+SUPPORTED_EMBEDDING_DIMENSIONS = (64, 128, 256, 384, 512, 768, 1024, 1536)
+
+#: On-device embedding graph filename. `ORTRetriever.createEmbeddingModel` resolves
+#: `<embedding>/<ORTRagConfig.onnxName>`, appending `.onnx` when absent — so the config records the
+#: stem and this is the file it resolves to.
+EMBEDDING_MODEL_STEM = "embedding_model"
+
+#: Tokenizer files `ORTTokenizerNative` reads from `embedding/tokenizer/`.
+_EMBEDDING_TOKENIZER_FILES = ("tokenizer.json", "tokenizer_config.json", "special_tokens_map.json")
+
+
+def _pooled_embedding_dimension(pooling_config: dict[str, Any]) -> int:
+    """The dimension the pooled graph actually emits.
+
+    sentence-transformers concatenates every enabled pooling mode, so the output width is the word
+    embedding dimension times the number of active modes — not the word dimension itself.
+    """
+    word_dim = pooling_config.get("word_embedding_dimension")
+    if not isinstance(word_dim, int) or word_dim <= 0:
+        raise ConfigValidationError(
+            f"pooling config declares no usable word_embedding_dimension: {pooling_config!r}"
+        )
+    modes = (
+        "pooling_mode_cls_token",
+        "pooling_mode_mean_tokens",
+        "pooling_mode_max_tokens",
+        "pooling_mode_mean_sqrt_len_tokens",
+    )
+    active = sum(1 for m in modes if pooling_config.get(m, False))
+    return word_dim * active if active else word_dim
+
+
+def _build_embedding_stage(
+    plan: ExportPlan, dest: Path, *, token: str | None, embedding_model: str | None
+) -> StageOutput:
+    """Real embedding/RAG stage (``export`` profile): the encoder subtree ``ORTRetriever`` loads.
+
+    Exports the sentence-transformer encoder through the same optimum front door the inference stage
+    uses (task ``feature-extraction``), grafts the model's declared sentence-transformers pooling onto
+    the graph — the device does no pooling, so an unpooled encoder would hand the vector store a
+    ``[batch, seq, dim]`` tensor it cannot index — and lays the subtree out exactly as
+    ``ORTRetriever.createEmbeddingModel`` reads it::
+
+        embedding/
+          embedding_model.onnx      # pooled: [batch, seq] -> [batch, dim]
+          rag_config.json           # repoName / onnxName / embeddingDimension + retrieval defaults
+          tokenizer/                # tokenizer.json + config + special tokens map
+
+    Fails closed when the pooled dimension is not one the Kotlin ``DimensionRegistry`` can index: a
+    package whose vectors cannot enter the store is worse than one with no RAG subtree at all, because
+    the failure would only surface on device at first ingest.
+    """
+    import shutil
+
+    from mobiletransformers.exceptions import ExportError
+    from mobiletransformers.export.embedding_export import (
+        add_pooling_to_onnx_model,
+        load_pooling_config_from_hub,
+    )
+    from mobiletransformers.export.inference_export import export_inference
+    from mobiletransformers.hub.package_format import sanitize_repo_id
+    from mobiletransformers.utils.logging import get_logger
+
+    log = get_logger(__name__)
+    emb_id = embedding_model or DEFAULT_EMBEDDING_MODEL
+    dest = Path(dest)
+    raw = dest / "raw"
+    emb = dest / "embedding"
+    tok = emb / "tokenizer"
+    emb.mkdir(parents=True, exist_ok=True)
+    tok.mkdir(parents=True, exist_ok=True)
+
+    log.info("embedding stage: exporting encoder %s (feature-extraction)", emb_id)
+    result = export_inference(emb_id, raw, task="feature-extraction", token=token)
+
+    # Pooling is model-declared (modules.json / 1_Pooling/config.json), never guessed.
+    pooling_config = load_pooling_config_from_hub(emb_id)
+    if not pooling_config:
+        raise ExportError(
+            f"{emb_id!r} declares no sentence-transformers pooling config; the on-device retriever "
+            "cannot pool token embeddings itself. Pass --embedding-model with a sentence-transformers "
+            "encoder."
+        )
+    dimension = _pooled_embedding_dimension(pooling_config)
+    if dimension not in SUPPORTED_EMBEDDING_DIMENSIONS:
+        raise ExportError(
+            f"{emb_id!r} pools to {dimension} dimensions, which the on-device vector store cannot "
+            f"index (supported: {list(SUPPORTED_EMBEDDING_DIMENSIONS)})."
+        )
+
+    import onnx
+
+    # Self-contained: load external data back in and save one file, so `embedding/` is a single graph
+    # the ORT embedding session opens by name (no sidecar blob to keep in step).
+    graph = onnx.load(str(result.onnx_model), load_external_data=True)
+    add_pooling_to_onnx_model(graph, emb_id, str(emb / f"{EMBEDDING_MODEL_STEM}.onnx"))
+
+    for name in _EMBEDDING_TOKENIZER_FILES:
+        src = raw / name
+        if src.is_file():
+            shutil.copy2(src, tok / name)
+    missing = [n for n in ("tokenizer.json",) if not (tok / n).is_file()]
+    if missing:
+        raise ExportError(
+            f"encoder export produced no {missing} for {emb_id!r} (needed by the device tokenizer)"
+        )
+
+    # repoName must match the on-device package directory (the sanitized BASE model id) — the retriever
+    # resolves `<cacheDir>/<repoName>/embedding/`, not the encoder's own id.
+    _write_json(
+        emb / "rag_config.json",
+        {
+            "repoName": sanitize_repo_id(plan.model_id),
+            "onnxName": EMBEDDING_MODEL_STEM,
+            "embeddingDimension": dimension,
+            "embeddingModelId": emb_id,
+            "topK": 10,
+            "searchType": "semantic",
+            "minScore": 0.0,
+            "indexingMode": "precompute",
+            "maxTextLength": 1024,
+            "chunkSize": 512,
+            "chunkOverlap": 50,
+        },
+    )
+
+    report = {
+        "embeddingModel": emb_id,
+        "embeddingDimension": dimension,
+        "embeddingOptimumOnnxVersion": result.optimum_onnx_version,
+    }
+    return StageOutput(
+        stage_dirs={"embedding": emb},
+        report={k: v for k, v in report.items() if v is not None},
+    )
+
+
+def _full_export(
+    plan: ExportPlan,
+    *,
+    token: str | None,
+    embedding_model: str | None,
+    stages: set[str] | None = None,
+    builders: dict[str, StageBuilder] | None = None,
+) -> ExportedPackage:
+    """Real export orchestration — stage-gated, reuses existing stages, heavy imports lazy (#15).
+
+    Builds each selected stage into a staging dir, computes the features actually produced, and delegates
+    the #14 reshape + #13 manifest/checksums to :func:`assemble_package`. ``stages`` selects which to
+    attempt (default: auto by request + importable deps — inference always, embedding iff RAG requested,
+    training iff the ORT-training stack is present). ``builders`` is injectable so the orchestration is
+    unit-testable in the core env without the heavy export stack.
+
+    Producing a train-capable package straddles two conflicting uv profiles, so it runs as separate
+    profile-scoped invocations into the same ``output``: assemble copies with ``dirs_exist_ok`` and
+    rebuilds the manifest from disk, so a later ``stages={"training"}`` run fills in ``train/`` + the
+    trainable handoff map without rework.
+    """
+    import tempfile
+
+    from mobiletransformers.utils.logging import get_logger
+
+    log = get_logger(__name__)
+    builders = builders or _default_builders()
+    selected = _select_stages(plan, stages)
+    report = _base_report(plan)
+
+    with tempfile.TemporaryDirectory(prefix="mtf-export-") as staging_root:
+        staging = Path(staging_root)
+        stage_dirs: dict[str, str | Path] = {}
+        for stage in ("inference", "training", "embedding"):  # deterministic order
+            if stage not in selected:
+                log.info(
+                    "export: skipping %s stage (not selected). Add it with a %s-profile run / --stages.",
+                    stage,
+                    stage,
+                )
+                continue
+            out = builders[stage](plan, staging / stage, token=token, embedding_model=embedding_model)
+            stage_dirs.update(out.stage_dirs)
+            report.update({k: v for k, v in out.report.items() if v is not None})
+
+        if "inference" not in stage_dirs and "train" not in stage_dirs:
+            from mobiletransformers.exceptions import ExportError
+
+            raise ExportError("no export stage produced any output")
+
+        import dataclasses
+
+        # Same reasoning as _effective_features below: a stage this run did not build still exists on
+        # disk, and what it recorded about itself must survive the manifest rebuild.
+        _carry_forward_inference_provenance(plan, report, stage_dirs)
+
+        eff_features = _effective_features(plan, stage_dirs)
+        # Honesty: don't advertise an engine the package can't serve. genai stays only if a genai_config
+        # was actually emitted (i.e. "genai" survived into effective features).
+        eff_engines = tuple(e for e in plan.supported_engines if e != "genai" or "genai" in eff_features)
+        effective_plan = dataclasses.replace(plan, features=eff_features, supported_engines=eff_engines)
+        log.info(
+            "export: assembling package with features %s engines %s",
+            effective_plan.features,
+            effective_plan.supported_engines,
+        )
+        return assemble_package(
+            effective_plan,
+            stage_dirs,
+            base_model_id=plan.model_id,
+            report=report,
+        )
+
+
+__all__ = [
+    "ExportPlan",
+    "ExportedPackage",
+    "parse_peft",
+    "quant_spec",
+    "plan_export",
+    "manifest_skeleton",
+    "assemble_package",
+    "export_package",
+]
diff --git a/src/mobiletransformers/export/quantizer_compat.py b/src/mobiletransformers/export/quantizer_compat.py
new file mode 100644
index 0000000..5ed82a6
--- /dev/null
+++ b/src/mobiletransformers/export/quantizer_compat.py
@@ -0,0 +1,95 @@
+"""One import that works across ONNX Runtime's rename of the weight-only MatMul quantizer.
+
+## What this unblocks
+
+`inference/builder.py` — the 3,441-line inference-graph builder, the largest file in the repo and the
+last unmigrated one — was recorded for months as "unimportable under every declared profile", which
+blocked Migration S6 *and* the rewrite of its 14-branch architecture ladder onto the registry.
+
+The real blocker turned out to be **one line**:
+
+```python
+from onnxruntime.quantization.matmul_4bits_quantizer import MatMul4BitsQuantizer, QuantFormat
+```
+
+Everything else it needs from `onnxruntime.quantization` (`QuantFormat`, `QuantType`,
+`quantize_dynamic`, `quantize_static`, `ONNXQuantizer`, `QuantizationMode`) resolves fine on a current
+ORT. ONNX Runtime generalised the 4-bit quantizer to N-bit and **renamed both the module and the
+class**, deleting the old names outright rather than leaving a deprecation alias
+(`matmul_4bits_quantizer.py` is a 404 on `microsoft/onnxruntime@main`):
+
+| old (<= the pinned era) | new (ORT 1.27 verified) |
+| --- | --- |
+| `onnxruntime.quantization.matmul_4bits_quantizer` | `onnxruntime.quantization.matmul_nbits_quantizer` |
+| `MatMul4BitsQuantizer` | `MatMulNBitsQuantizer` |
+
+The constructor is call-compatible for our use: every keyword the builder passes (`model`,
+`block_size`, `is_symmetric`, `accuracy_level`, `nodes_to_exclude`, `quant_format`,
+`op_types_to_quantize`) exists on the new class, which additionally takes `bits: int = 4` — so the
+default already means 4-bit and the old behaviour is preserved without passing it.
+
+## Why a resolver rather than just editing the import
+
+Both spellings are live in the wild: the repo pins two ORT lines (1.24.3 and 1.27.0 under different
+resolution markers) and the source-built training wheel provides its own. Hard-coding either name
+re-breaks the other. This resolves at call time and fails with a message naming both spellings and the
+installed version, instead of a bare `ModuleNotFoundError` that reads like a missing dependency.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+#: Newest first — the name a current ORT actually ships.
+_CANDIDATES = (
+    ("onnxruntime.quantization.matmul_nbits_quantizer", "MatMulNBitsQuantizer"),
+    ("onnxruntime.quantization.matmul_4bits_quantizer", "MatMul4BitsQuantizer"),
+)
+
+
+def load_weight_only_matmul_quantizer() -> Any:
+    """Return ORT's weight-only MatMul quantizer class, whatever this ORT calls it.
+
+    Raises:
+        ImportError: naming both spellings and the installed ONNX Runtime version, so the failure is
+            actionable instead of looking like onnxruntime is missing entirely.
+    """
+    import importlib
+
+    tried: list[str] = []
+    for module_path, attr in _CANDIDATES:
+        try:
+            module = importlib.import_module(module_path)
+        except ImportError:
+            tried.append(f"{module_path} (module not found)")
+            continue
+        candidate = getattr(module, attr, None)
+        if candidate is not None:
+            return candidate
+        tried.append(f"{module_path}.{attr} (module present, class absent)")
+
+    try:
+        import onnxruntime
+
+        version = getattr(onnxruntime, "__version__", "unknown")
+    except ImportError:
+        raise ImportError(
+            "onnxruntime is not installed. The inference-graph builder needs it for int4 "
+            "weight-only quantization — install the `export` extra."
+        ) from None
+
+    raise ImportError(
+        "could not locate ONNX Runtime's weight-only MatMul quantizer in onnxruntime "
+        f"{version}. Tried:\n  " + "\n  ".join(tried) + "\n"
+        "ORT renamed MatMul4BitsQuantizer -> MatMulNBitsQuantizer (and the module "
+        "matmul_4bits_quantizer -> matmul_nbits_quantizer) when the quantizer was generalised to "
+        "N-bit. If a newer ORT renamed it again, add the new spelling to _CANDIDATES in "
+        "mobiletransformers/export/quantizer_compat.py — newest first."
+    )
+
+
+def load_quant_format() -> Any:
+    """Return ``QuantFormat``. Re-exported by both quantizer modules and by the package root."""
+    from onnxruntime.quantization import QuantFormat
+
+    return QuantFormat
diff --git a/src/mobiletransformers/export/registry.py b/src/mobiletransformers/export/registry.py
new file mode 100644
index 0000000..a0ffd08
--- /dev/null
+++ b/src/mobiletransformers/export/registry.py
@@ -0,0 +1,187 @@
+"""Export discovery + front-door registries — the single inference-export dispatcher.
+
+Two data-driven registries, no ``if/elif`` in business logic:
+
+* **Task discovery** wraps Optimum's ``TasksManager`` (``discover_tasks`` / ``choose_task`` /
+  ``is_supported``). It answers *which ONNX task* a model supports; it does **not** pick the
+  per-architecture ``OnnxConfig`` class — that mapping is the architecture registry
+  (``config.registry.architecture``). TasksManager keys on ``AutoConfig.model_type`` (``"llama"``),
+  not ``architectures[0]`` (``"LlamaForCausalLM"``).
+* **Export-frontend registry** (F3) selects the export *engine* as data: ``optimum-onnx`` (default,
+  durable inference exporter) and ``torch.onnx`` (the manual graph path used by the training-graph
+  fallback after optimum 2.1 removed ``OnnxConfigWithLoss`` — see ``spikes/optimum_migration``).
+  Adding a frontend is a registry row + an :class:`ExportFrontend` enum member, never a branch.
+
+Optimum imports are lazy (inside functions) so this module imports cleanly in the core env.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from mobiletransformers.config.constants import ExportFrontend
+from mobiletransformers.config.registry.architecture import import_from_path
+from mobiletransformers.exceptions import ExportError, UnsupportedModelError
+
+#: Optimum exporter backend key.
+ONNX_EXPORTER = "onnx"
+
+#: Auto task-selection order. ``*-with-past`` is preferred because the inference engine needs the
+#: KV-cache (past/present) graph; ``feature-extraction`` covers encoders. An explicit override wins.
+TASK_PREFERENCE: tuple[str, ...] = (
+    "text-generation-with-past",
+    "text-generation",
+    "feature-extraction",
+    "sentence-similarity",
+)
+
+
+# --------------------------------------------------------------------------------------------------
+# Task discovery (TasksManager wrapper)
+# --------------------------------------------------------------------------------------------------
+@dataclass(frozen=True)
+class TaskDiscovery:
+    """Result of ONNX task discovery for one model. Never raises on unknown types — fail-open here,
+    fail-closed at export time."""
+
+    model_type: str | None
+    supported_tasks: tuple[str, ...]
+    optimum_exportable: bool
+    blocker: str | None = None
+
+
+def _ensure_onnx_registered() -> None:
+    """Import the model-config module so its ``@register_tasks_manager_onnx`` decorators populate
+    ``TasksManager``'s ONNX map. Importing ``TasksManager`` alone leaves the map empty (optimum 2.1)."""
+    import optimum.exporters.onnx.model_configs  # noqa: F401  (import for its registration side effect)
+
+
+def supported_onnx_tasks(model_type: str, library_name: str = "transformers") -> tuple[str, ...]:
+    """Sorted ONNX-supported task names for ``model_type`` (empty tuple if the type is unknown)."""
+    _ensure_onnx_registered()
+    from optimum.exporters.tasks import TasksManager
+
+    try:
+        tasks = TasksManager.get_supported_tasks_for_model_type(
+            model_type, ONNX_EXPORTER, library_name=library_name
+        )
+    except KeyError:
+        return ()
+    return tuple(sorted(tasks.keys()))
+
+
+def is_supported(model_type: str, library_name: str = "transformers") -> bool:
+    """True iff Optimum can export any ONNX task for ``model_type``."""
+    return bool(supported_onnx_tasks(model_type, library_name=library_name))
+
+
+def discover_tasks(
+    model_id: str, *, token: str | None = None, trust_remote_code: bool = False
+) -> TaskDiscovery:
+    """Discover the ONNX tasks Optimum supports for ``model_id``.
+
+    Reads ``AutoConfig.model_type`` (the TasksManager key), then looks up its supported ONNX tasks.
+    An unknown/unsupported model type yields an empty set with ``optimum_exportable=False`` and a
+    blocker note — it does **not** raise (fail-open discovery; export itself fails closed).
+    """
+    from transformers import AutoConfig
+
+    try:
+        config = AutoConfig.from_pretrained(model_id, token=token, trust_remote_code=trust_remote_code)
+    except Exception as exc:  # noqa: BLE001  (report any load failure as a discovery blocker)
+        return TaskDiscovery(None, (), False, f"could not load config for {model_id!r}: {exc}")
+
+    model_type = getattr(config, "model_type", None)
+    if not model_type:
+        return TaskDiscovery(None, (), False, f"{model_id!r} config has no model_type")
+
+    tasks = supported_onnx_tasks(model_type)
+    if not tasks:
+        return TaskDiscovery(
+            model_type, (), False, f"model_type {model_type!r} has no ONNX exporter in Optimum"
+        )
+    return TaskDiscovery(model_type, tasks, True, None)
+
+
+def choose_task(supported_tasks: tuple[str, ...] | list[str], override: str | None = None) -> str:
+    """Pick the export task.
+
+    An explicit ``override`` is honored verbatim (it forces a task, even outside the auto order, and
+    is recorded by the caller). Otherwise the first :data:`TASK_PREFERENCE` entry present in
+    ``supported_tasks`` wins; if none match, fail closed.
+    """
+    if override is not None:
+        return override
+    supported = set(supported_tasks)
+    for task in TASK_PREFERENCE:
+        if task in supported:
+            return task
+    raise UnsupportedModelError(
+        f"no supported task in preference order {TASK_PREFERENCE} for {sorted(supported)}"
+    )
+
+
+# --------------------------------------------------------------------------------------------------
+# Export-frontend registry (F3)
+# --------------------------------------------------------------------------------------------------
+@dataclass(frozen=True)
+class ExportFrontendSpec:
+    """One export engine, declared as data. Callables are lazy dotted paths (resolved only when an
+    export runs) so the registry imports cleanly in the core env."""
+
+    frontend: ExportFrontend
+    export_callable: str  # dotted path to the export function
+    availability_probe: str  # dotted path to a ``() -> bool`` availability check
+    capabilities: frozenset[str] = field(default_factory=frozenset)  # e.g. {"inference"}/{"training"}
+
+    def load_export(self) -> Any:
+        return import_from_path(self.export_callable)
+
+    def available(self) -> bool:
+        try:
+            return bool(import_from_path(self.availability_probe)())
+        except Exception:  # noqa: BLE001  (a missing/broken probe means "unavailable", never a crash)
+            return False
+
+
+EXPORT_FRONTEND_REGISTRY: dict[ExportFrontend, ExportFrontendSpec] = {
+    ExportFrontend.OPTIMUM_ONNX: ExportFrontendSpec(
+        ExportFrontend.OPTIMUM_ONNX,
+        "mobiletransformers.export.inference_export.optimum_onnx_export",
+        "mobiletransformers.export.inference_export.optimum_available",
+        frozenset({"inference"}),
+    ),
+    ExportFrontend.TORCH_ONNX: ExportFrontendSpec(
+        ExportFrontend.TORCH_ONNX,
+        "mobiletransformers.export.torch_frontend.torch_onnx_training_export",
+        "mobiletransformers.export.torch_frontend.torch_available",
+        frozenset({"training"}),
+    ),
+}
+
+
+def resolve_frontend(frontend: ExportFrontend | str) -> ExportFrontendSpec:
+    """Look up a frontend spec by enum or wire value. Fail closed on any unknown key."""
+    try:
+        key = frontend if isinstance(frontend, ExportFrontend) else ExportFrontend(frontend)
+    except ValueError as exc:
+        raise ExportError(f"unknown export frontend: {frontend!r}") from exc
+    spec = EXPORT_FRONTEND_REGISTRY.get(key)
+    if spec is None:
+        raise ExportError(f"no export frontend registered for {key!r}")
+    return spec
+
+
+__all__ = [
+    "ONNX_EXPORTER",
+    "TASK_PREFERENCE",
+    "TaskDiscovery",
+    "supported_onnx_tasks",
+    "is_supported",
+    "discover_tasks",
+    "choose_task",
+    "ExportFrontendSpec",
+    "EXPORT_FRONTEND_REGISTRY",
+    "resolve_frontend",
+]
diff --git a/src/mobiletransformers/export/support_matrix.py b/src/mobiletransformers/export/support_matrix.py
new file mode 100644
index 0000000..727d3e6
--- /dev/null
+++ b/src/mobiletransformers/export/support_matrix.py
@@ -0,0 +1,116 @@
+"""Seed/merge ``model_support_matrix.json`` — the per-model export-status truth.
+
+This plan (#7) sets the two statuses it can prove: ``optimum_exportable`` (from task discovery) and
+``mobile_package_exportable`` (from a successful normalized export). The remaining canonical statuses
+(``train_artifacts_exportable``, ``android_inference_ready``, ``android_training_ready``, ``rag_ready``)
+are seeded as ``None`` and flipped later. This module owns the canonical schema
++ field list and is the reporting layer that reads/extends this file — so ``merge_row`` preserves any
+field it does not own.
+
+Pure stdlib/JSON (no onnx/optimum), so it runs in any profile.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+#: Envelope versioning (uniform contract, see canonical decisions). #20 finalizes the schema.
+SCHEMA_VERSION = "1.0"
+MIN_READER_VERSION = "1.0"
+
+#: Statuses #7 owns. The other canonical statuses are seeded None and owned by later plans.
+_OWNED_STATUSES = ("optimum_exportable", "mobile_package_exportable")
+_DEFERRED_STATUSES = (
+    "train_artifacts_exportable",
+    "android_inference_ready",
+    "android_training_ready",
+    "rag_ready",
+)
+
+
+@dataclass
+class SupportRow:
+    """One model's export status, as far as #7 can determine it."""
+
+    model_id: str
+    model_type: str | None
+    optimum_exportable: bool
+    mobile_package_exportable: bool
+    supported_tasks: tuple[str, ...] = ()
+    chosen_task: str | None = None
+    blocker: str | None = None
+    toolchain: dict[str, str] = field(default_factory=dict)
+
+    def owned_fields(self) -> dict[str, Any]:
+        """The subset of the wire row this plan owns (merged over any existing row)."""
+        return {
+            "modelType": self.model_type,
+            "supportedTasks": list(self.supported_tasks),
+            "chosenTask": self.chosen_task,
+            "optimum_exportable": self.optimum_exportable,
+            "mobile_package_exportable": self.mobile_package_exportable,
+            "blocker": self.blocker,
+            "toolchain": dict(self.toolchain),
+        }
+
+
+def empty_matrix() -> dict[str, Any]:
+    return {"schemaVersion": SCHEMA_VERSION, "minReaderVersion": MIN_READER_VERSION, "models": {}}
+
+
+def load_matrix(path: str | Path) -> dict[str, Any]:
+    """Load an existing matrix, or a fresh empty one if the file does not exist."""
+    path = Path(path)
+    if not path.is_file():
+        return empty_matrix()
+    matrix = json.loads(path.read_text(encoding="utf-8"))
+    matrix.setdefault("schemaVersion", SCHEMA_VERSION)
+    matrix.setdefault("minReaderVersion", MIN_READER_VERSION)
+    matrix.setdefault("models", {})
+    return matrix
+
+
+def merge_row(matrix: dict[str, Any], row: SupportRow) -> dict[str, Any]:
+    """Merge ``row`` into ``matrix`` in place, keyed by ``model_id``.
+
+    Updates only the fields #7 owns and preserves everything else (statuses set by later plans).
+    Idempotent: merging the same row twice yields the same matrix.
+    """
+    models = matrix.setdefault("models", {})
+    existing = models.get(row.model_id, {})
+    # Seed deferred statuses as None the first time we see a model; never clobber a later plan's value.
+    for status in _DEFERRED_STATUSES:
+        existing.setdefault(status, None)
+    existing.update(row.owned_fields())
+    models[row.model_id] = existing
+    return matrix
+
+
+def write_matrix(matrix: dict[str, Any], path: str | Path) -> None:
+    """Write ``matrix`` deterministically (sorted keys) for stable diffs."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(matrix, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def update_support_matrix(path: str | Path, row: SupportRow) -> dict[str, Any]:
+    """Load → merge ``row`` → write. Returns the updated matrix."""
+    matrix = load_matrix(path)
+    merge_row(matrix, row)
+    write_matrix(matrix, path)
+    return matrix
+
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "MIN_READER_VERSION",
+    "SupportRow",
+    "empty_matrix",
+    "load_matrix",
+    "merge_row",
+    "write_matrix",
+    "update_support_matrix",
+]
diff --git a/src/mobiletransformers/export/tokenizer_export.py b/src/mobiletransformers/export/tokenizer_export.py
new file mode 100644
index 0000000..a26b363
--- /dev/null
+++ b/src/mobiletransformers/export/tokenizer_export.py
@@ -0,0 +1,284 @@
+"""On-device tokenizer config emit (``mobiletransformers_tokenizer_config.json``).
+
+Migrated from ``tools/tokenizer_export.py`` (Migration Map S1). ``transformers`` is imported inside the
+functions so the module stays importable in the core environment — the export pipeline imports it
+eagerly and must not drag transformers in on a ``--dry-run``.
+
+### The file this writes is load-bearing, and it used to be mostly wrong
+
+``ORTTokenizerNative`` reads ``model.vocab_size`` out of this file and hands it to
+``performInferenceStep``, which scans exactly that many floats of the logits row to pick the next
+token. So the number here is not documentation — it defines the set of token ids the sampler may
+return.
+
+The previous version built the whole block from whatever ``GenerationConfig.from_pretrained``
+returned, falling back to ``AutoConfig`` only when that *raised*. A ``GenerationConfig`` carries none
+of the architecture fields, so for every model with a ``generation_config.json`` each
+``getattr(config, ..., default)`` silently took the default: 12 heads, 12 layers, context 2048, type
+``"unknown"`` — and ``vocab_size`` fell through to ``len(tokenizer.get_vocab())``.
+
+That last one is the one that bites. ``len(tokenizer)`` counts **added tokens**, which need not be
+backed by embedding rows. FunctionGemma's tokenizer declares ``<image_soft_token>`` (262144) and
+``<end_of_image>`` (262145) above a 262144-row embedding table, so the emitted vocab_size was 262146
+and the sampler read two floats past the end of every logits row. When that garbage won the argmax
+the id was fed straight back as the next input and ORT failed the embedding lookup with
+
+    Gather node ... indices element out of data bounds, idx=262145 ... range [-262144,262143]
+
+SmolLM2 survived it only because its added tokens happen to fit inside its declared vocabulary — the
+same code was wrong there too and nothing could see it.
+
+So: the architecture facts come from the **model** config and the token ids from the **generation**
+config, each from the object that actually declares them, and a vocab size that cannot be sourced
+from the model config is an error rather than a guess.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+# What the device does when a field is absent. Only ever reached for a model config that genuinely
+# omits the field; they are NOT a fallback for reading the wrong object.
+_DEFAULT_CONTEXT_LENGTH = 2048
+_DEFAULT_ATTENTION_HEADS = 12
+_DEFAULT_HIDDEN_LAYERS = 12
+
+
+def _first_attr(obj: Any, *names: str, default: Any = None) -> Any:
+    """The first of ``names`` that is present **and not None** on ``obj``.
+
+    ``getattr(cfg, "bos_token_id", 2)`` returns ``None`` — not 2 — for a config that declares the
+    attribute as null, which is how ``bos_token_id: null`` reached a package exported from a model
+    whose real BOS is 2.
+    """
+    for name in names:
+        value = getattr(obj, name, None)
+        if value is not None:
+            return value
+    return default
+
+
+def _text_config(config: Any) -> Any:
+    """The sub-config carrying the decoder's shape.
+
+    Multimodal configs (Gemma 3, Llava, Qwen-VL) put ``num_hidden_layers``/``vocab_size`` on a nested
+    ``text_config`` and leave the top level describing the composite. Reading the top level yields a
+    config with none of the fields, i.e. all the defaults again.
+    """
+    nested = getattr(config, "text_config", None)
+    return nested if nested is not None and getattr(nested, "vocab_size", None) is not None else config
+
+
+def build_device_tokenizer_config(
+    model_config: Any,
+    generation_config: Any = None,
+    tokenizer: Any = None,
+) -> dict:
+    """Assemble the ``mobiletransformers_tokenizer_config.json`` payload.
+
+    Pure, and deliberately takes duck-typed objects rather than transformers classes, so the field
+    routing that this module got wrong for its whole life is testable without loading a model.
+
+    :param model_config: an ``AutoConfig`` — the authority for architecture and ``vocab_size``.
+    :param generation_config: a ``GenerationConfig``, when the model ships one. Authority for the
+        token ids *only*: its ``eos_token_id`` is frequently a longer list than the model config's
+        (FunctionGemma adds ``106``/``<end_of_turn>``), and stopping on more of them is correct.
+    :param tokenizer: consulted only for token ids the configs leave unset. **Never** for
+        ``vocab_size`` — see the module docstring.
+    :raises ValueError: when no ``vocab_size`` can be read off the model config. Emitting a guess is
+        what produced an out-of-bounds sampler, and a package that fails to export is strictly better
+        than one that fails on the phone.
+    """
+    text = _text_config(model_config)
+
+    vocab_size = _first_attr(text, "vocab_size")
+    if vocab_size is None:
+        raise ValueError(
+            "the model config declares no vocab_size, so the number of embedding rows the sampler "
+            "may address is unknown. It must NOT be taken from len(tokenizer): added tokens are not "
+            "guaranteed to have embedding rows, and a sampler allowed to return an id above the "
+            "table fails inside ORT's Gather with an out-of-bounds index."
+        )
+
+    # Token ids: the generation config wins where it has an opinion, because that is the object that
+    # describes how the model is meant to be decoded.
+    sources = [c for c in (generation_config, text, model_config) if c is not None]
+
+    def token_id(*names: str) -> Any:
+        for source in sources:
+            value = _first_attr(source, *names)
+            if value is not None:
+                return value
+        return None
+
+    eos_token_id = token_id("eos_token_id")
+    if eos_token_id is None and tokenizer is not None:
+        eos_token_id = _first_attr(tokenizer, "eos_token_id")
+
+    bos_token_id = token_id("bos_token_id")
+    if bos_token_id is None and tokenizer is not None:
+        bos_token_id = _first_attr(tokenizer, "bos_token_id")
+
+    pad_token_id = token_id("pad_token_id")
+    if pad_token_id is None and tokenizer is not None:
+        pad_token_id = _first_attr(tokenizer, "pad_token_id")
+    if pad_token_id is None:
+        # Padding with EOS is the transformers convention for models that declare no pad token.
+        pad_token_id = eos_token_id[0] if isinstance(eos_token_id, list) and eos_token_id else eos_token_id
+
+    num_attention_heads = _first_attr(text, "num_attention_heads", default=_DEFAULT_ATTENTION_HEADS)
+
+    payload = {
+        "model": {
+            "bos_token_id": bos_token_id,
+            "context_length": _first_attr(
+                text,
+                "max_position_embeddings",
+                "max_sequence_length",
+                "n_positions",
+                default=_DEFAULT_CONTEXT_LENGTH,
+            ),
+            "num_attention_heads": num_attention_heads,
+            "num_hidden_layers": _first_attr(
+                text, "num_hidden_layers", "n_layer", default=_DEFAULT_HIDDEN_LAYERS
+            ),
+            "num_key_value_heads": _first_attr(text, "num_key_value_heads", default=num_attention_heads),
+            "eos_token_id": eos_token_id,
+            "pad_token_id": pad_token_id,
+            "type": _first_attr(text, "model_type", default="unknown"),
+            "vocab_size": vocab_size,
+        }
+    }
+
+    # Not fatal, but worth naming: it is the exact discrepancy that used to be written out as truth.
+    declared = None
+    if tokenizer is not None:
+        get_vocab = getattr(tokenizer, "get_vocab", None)
+        added = getattr(tokenizer, "get_added_vocab", None)
+        if callable(get_vocab):
+            try:
+                declared = len(get_vocab())
+                if callable(added):
+                    declared = max(declared, max((v for v in added().values()), default=-1) + 1)
+            except Exception:  # noqa: BLE001 - a tokenizer that cannot enumerate is not an export failure
+                declared = None
+    if declared is not None and declared != vocab_size:
+        print(
+            f"note: the tokenizer addresses {declared} ids but the model config declares "
+            f"{vocab_size} embedding rows. Using {vocab_size} — ids above it have no row and must "
+            "never be sampled."
+        )
+
+    return payload
+
+
+def export_tokenizer_config(model_name_or_path, output_dir="build", hf_token=None, trust_remote_code=True):
+    from transformers import AutoConfig, AutoTokenizer, GenerationConfig  # noqa: PLC0415
+
+    """
+    Export tokenizer and config files from HuggingFace model.
+
+    Args:
+        model_name_or_path (str): HuggingFace model name or local path
+        output_dir (str): Output directory (default: "build")
+        hf_token (str): HuggingFace token for private models
+        trust_remote_code (bool): Whether to trust remote code
+
+    Returns:
+        dict: The generated config dictionary
+    """
+
+    # Create output directories
+    tokenizer_dir = Path(output_dir) / "tokenizer"
+    tokenizer_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Load tokenizer and config
+        print(f"Loading tokenizer from {model_name_or_path}...")
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name_or_path, token=hf_token, trust_remote_code=trust_remote_code
+        )
+
+        # The MODEL config, always: it is the only object that knows how many embedding rows exist.
+        model_config = AutoConfig.from_pretrained(
+            model_name_or_path, token=hf_token, trust_remote_code=trust_remote_code
+        )
+
+        # The generation config is additive and optional — a model without one is not an error.
+        try:
+            generation_config = GenerationConfig.from_pretrained(
+                model_name_or_path, token=hf_token, trust_remote_code=trust_remote_code
+            )
+        except Exception as exc:  # noqa: BLE001 - absence is the common case, not a failure
+            print(
+                f"No generation config for {model_name_or_path} ({exc}); using the model config's token ids."
+            )
+            generation_config = None
+
+        # Save tokenizer files to build/tokenizer directory
+        print(f"Saving tokenizer files to {tokenizer_dir}...")
+        tokenizer.save_pretrained(tokenizer_dir)
+
+        mobiletransformers_config = build_device_tokenizer_config(
+            model_config=model_config,
+            generation_config=generation_config,
+            tokenizer=tokenizer,
+        )
+
+        # Save the main config file
+        config_path = Path(output_dir) / "tokenizer" / "mobiletransformers_tokenizer_config.json"
+        print(f"Saving main config to {config_path}...")
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(mobiletransformers_config, f, indent=4, ensure_ascii=False)
+
+        print("Export completed successfully!")
+        print("Files saved:")
+        print(f"  - Main config: {config_path}")
+        print(f"  - Tokenizer files: {tokenizer_dir}")
+
+        # List tokenizer files that were saved
+        tokenizer_files = list(tokenizer_dir.glob("*.json"))
+        for file in tokenizer_files:
+            print(f"    - {file.name}")
+
+        return mobiletransformers_config
+
+    except Exception as e:
+        print(f"Error exporting tokenizer: {str(e)}")
+        raise
+
+
+def export_tokenizer_config_advanced(
+    model_name_or_path, output_dir="build", hf_token=None, trust_remote_code=True, extra_config_overrides=None
+):
+    """
+    Advanced version with additional configuration options.
+
+    Args:
+        model_name_or_path (str): HuggingFace model name or local path
+        output_dir (str): Output directory
+        hf_token (str): HuggingFace token
+        trust_remote_code (bool): Whether to trust remote code
+        extra_config_overrides (dict): Additional config values to override
+
+    Returns:
+        dict: The generated config dictionary
+    """
+
+    config = export_tokenizer_config(model_name_or_path, output_dir, hf_token, trust_remote_code)
+
+    # Apply any overrides
+    if extra_config_overrides:
+        for key, value in extra_config_overrides.items():
+            if key in config["model"]:
+                config["model"][key] = value
+                print(f"Override applied: {key} = {value}")
+
+        # Save updated config
+        config_path = Path(output_dir) / "mobiletransformers_tokenizer_config.json"
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=4, ensure_ascii=False)
+
+    return config
diff --git a/src/mobiletransformers/export/torch_frontend.py b/src/mobiletransformers/export/torch_frontend.py
new file mode 100644
index 0000000..64713a4
--- /dev/null
+++ b/src/mobiletransformers/export/torch_frontend.py
@@ -0,0 +1,45 @@
+"""``torch.onnx`` export frontend — the reserved last-resort training-graph path (Fallback A).
+
+The plan flagged ``torch.onnx`` as Fallback A for when optimum's ``OnnxConfigWithLoss``/``export`` are
+gone. The migration spike found ``OnnxConfigWithLoss`` removed but ``export()`` *surviving*, so the
+active training path vendors ``OnnxConfigWithLoss`` (see ``onnx_config_with_loss.py``) and stays on the
+durable optimum ``export()`` — no manual graph reconstruction required.
+
+This module therefore stays a **declared, fail-closed** registry row: it keeps ``EXPORT_FRONTEND_REGISTRY``
+extensible (F3) and documents the escape hatch, but selecting it raises with guidance rather than
+shipping an unexercised torch.onnx reconstruction. Wire it up only if a future optimom removes
+``export()`` too.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from typing import Any
+
+from mobiletransformers.exceptions import ExportError
+
+
+def torch_available() -> bool:
+    """Availability probe for the torch.onnx frontend."""
+    return importlib.util.find_spec("torch") is not None
+
+
+def torch_onnx_training_export(
+    model: Any,
+    out_dir: Path,
+    task: str,
+    opset: int,
+    trust_remote_code: bool,
+    token: str | None,
+) -> dict[str, str]:
+    """Reserved fallback (not active). Fails closed with guidance toward the vendored path."""
+    raise ExportError(
+        "torch.onnx export frontend is a reserved fallback and is not implemented: the active "
+        "training-graph path uses the vendored OnnxConfigWithLoss on optimum's surviving export() "
+        "(mobiletransformers.export.onnx_config_with_loss). Only wire this up if optimum removes "
+        "export() as well (see spikes/optimum_migration)."
+    )
+
+
+__all__ = ["torch_available", "torch_onnx_training_export"]
diff --git a/src/mobiletransformers/export/training_export.py b/src/mobiletransformers/export/training_export.py
new file mode 100644
index 0000000..3cdd33f
--- /dev/null
+++ b/src/mobiletransformers/export/training_export.py
@@ -0,0 +1,998 @@
+"""
+Script that fetches the Huggingface LLM model and converts it into a ONNX graph compatible for artifact training generation.
+"""
+
+import argparse
+import gc
+import inspect
+import json
+import textwrap
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import onnx
+import torch
+from onnx import TensorProto, helper, numpy_helper
+from optimum.exporters.onnx import export
+from peft import LoraConfig, PeftModel, PeftType, get_peft_model
+
+from mobiletransformers.utils.yaml import load_config_from_file
+
+# peft renamed its PeftType -> tuner-class registry in 0.15 (`PEFT_TYPE_TO_MODEL_MAPPING` ->
+# `PEFT_TYPE_TO_TUNER_MAPPING`). The `ort-training-local` group floats `peft>=0.13` while
+# `third_party/onnxruntime/manifest.json` records the tested pairing as 0.13.2, so a fresh resolve picks
+# up a much newer peft and this module stopped importing at all — which fails the whole training stage
+# before it does any work. Accept both spellings rather than pinning the profile to a 2024 peft.
+try:  # peft < 0.15
+    from peft.peft_model import PEFT_TYPE_TO_MODEL_MAPPING
+except ImportError:  # peft >= 0.15
+    from peft.peft_model import PEFT_TYPE_TO_TUNER_MAPPING as PEFT_TYPE_TO_MODEL_MAPPING
+from transformers import AutoConfig
+
+# OnnxConfigWithLoss was REMOVED in optimum 2.1 (the optimum-onnx split; verified by
+# spikes/optimum_migration/check_symbols.py). export() survives, so we keep the training-graph export
+# on it with a VENDORED OnnxConfigWithLoss. Per-architecture *OnnxConfig classes now resolve via the
+# architecture registry (#6/#9) — the old architectures[0] ladder is gone.
+# PEFT registry (#6) — the old `train_method == "..."` chain is gone: the wire value is parsed ONCE
+# into the PEFTMethod enum (fail-closed on an unknown method) and every branch keys off that member.
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.config.registry.architecture import import_from_path, resolve_architecture
+from mobiletransformers.config.registry.peft import build_adapter_mapping
+from mobiletransformers.config.registry.task import get_task_spec
+from mobiletransformers.exceptions import UnsupportedModelError
+from mobiletransformers.export.embedding_export import add_pooling_to_onnx_model
+from mobiletransformers.export.onnx_config_with_loss import OnnxConfigWithLoss
+from mobiletransformers.export.registry import choose_task, supported_onnx_tasks
+from mobiletransformers.peft.mars.config import MarsConfig
+from mobiletransformers.peft.mars.model import MarsModel
+
+
+def add_peft_type(name, value):
+    """Dynamically add a new value to the PeftType enum."""
+    setattr(PeftType, name, value)
+    PeftType._value2member_map_[value] = name
+
+
+# Add custom PEFT type dynamically
+add_peft_type("MARS", "MARS")
+PEFT_TYPE_TO_MODEL_MAPPING[PeftType("MARS")] = MarsModel
+
+# All operators supported for training should be in https://onnx.ai/onnx/operators/index.html
+from dotenv import load_dotenv
+from onnxruntime.quantization import QuantType, quantize_dynamic
+
+from mobiletransformers.peft.lora_xs.initialization_utils import find_and_initialize
+
+load_dotenv()
+
+from mobiletransformers.config.constants import TRAIN_CONFIG
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_layers_with_grad(model):
+    """
+    Collects layers with required grad and frozen parameter layers.
+    """
+    layers_with_grad = []
+    layers_with_no_grad = []
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            layers_with_grad.append(name)
+        else:
+            layers_with_no_grad.append(name)
+    return layers_with_grad, layers_with_no_grad
+
+
+def ensure_training_mode_input(graph):
+    """
+    Add training mode boolean input to the graph for conditional flow.
+    """
+
+    training_mode_exists = any(input.name == "training_mode" for input in graph.input)
+    if not training_mode_exists:
+        # Add 'training_mode' input to the graph as a boolean tensor
+        training_mode_input = helper.make_tensor_value_info("training_mode", TensorProto.BOOL, [1])
+        graph.input.append(training_mode_input)
+
+
+class OnnxInferenceWrapper(torch.nn.Module):
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = False
+        self.backbone.use_cache = True
+
+    def forward(self, input_ids, attention_mask, position_ids, past_key_values):
+        return self.backbone(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=True,
+        )
+
+
+class OnnxTrainerWrapper(torch.nn.Module):
+    """Decoder training-graph wrapper.
+
+    **The parameter names are the exported ONNX input names** — `torch.onnx` reads them by
+    introspection — so they are part of the on-device contract (`ORTDataCurator` feeds `position_ids`
+    by name). They must not be generalised into `*args`/`**kwargs`, and this signature must not
+    change. The encoder variant is a separate class for exactly that reason; the registry picks
+    between them (`TaskSpec.trainer_wrapper_class`).
+    """
+
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = True
+
+    def forward(self, input_ids, attention_mask, position_ids, labels):
+        return self.backbone(
+            input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, labels=labels
+        )
+
+
+def _check_wrapper_matches_config_inputs(wrapper_cls: type, onnx_config: Any) -> None:
+    """Fail closed when the trainer wrapper's forward signature disagrees with the config's inputs.
+
+    Optimum hands the generated dummy inputs to the traced module **positionally**, so the wrapper's
+    parameter list and ``OnnxConfig.inputs`` are one contract with two authors — and nothing checked
+    that they agreed. When they did not, the mismatch surfaced as a bare
+
+        TypeError: OnnxTrainerWrapper.forward() missing 1 required positional argument: 'labels'
+
+    raised from ``torch/jit/_trace.py``, with nothing in the message naming the config, the
+    architecture, or the actual input sets. Diagnosing it meant reproducing the dummy-input generation
+    by hand. This turns that into one sentence at the boundary, before the model is wrapped.
+
+    Compares against the wrapped config's ``inputs`` (which already include ``labels``), because that
+    is exactly the dict whose values are passed positionally.
+    """
+    declared = [p for p in inspect.signature(wrapper_cls.forward).parameters if p != "self"]
+    expected = list(onnx_config.inputs.keys())
+    if declared != expected:
+        raise UnsupportedModelError(
+            f"{wrapper_cls.__name__}'s forward signature does not match "
+            f"{type(onnx_config).__name__}'s inputs, and Optimum passes them positionally, so the "
+            f"export would bind the wrong tensor to each name.\n"
+            f"  wrapper forward : {declared}\n"
+            f"  config inputs   : {expected}\n"
+            "Set `trainer_wrapper_class` on this architecture's ARCHITECTURE_REGISTRY row to a wrapper "
+            "whose parameters are exactly the config's inputs, in order."
+        )
+
+
+class OnnxDecoderNoPositionIdsTrainerWrapper(torch.nn.Module):
+    """Decoder training-graph wrapper for architectures whose ``OnnxConfig`` omits ``position_ids``.
+
+    Same objective as :class:`OnnxTrainerWrapper` — causal LM, one label per token — differing only in
+    the exported input set. It exists because **Gemma-3 does not declare `position_ids`**:
+    ``LlamaOnnxConfig.inputs`` is ``[input_ids, attention_mask, position_ids]`` while
+    ``Gemma3TextOnnxConfig.inputs`` is ``[input_ids, attention_mask]``, and Optimum passes the dummy
+    inputs to the traced module **positionally**. Against the four-parameter decoder wrapper that made
+    ``labels`` land in ``position_ids``' slot and left ``labels`` unbound, which surfaces as
+
+        TypeError: OnnxTrainerWrapper.forward() missing 1 required positional argument: 'labels'
+
+    thrown from inside ``torch.jit`` tracing, several frames below anything this repo owns.
+
+    A separate class rather than an optional parameter for the reason given on
+    :class:`OnnxTrainerWrapper`: ``torch.onnx`` derives the exported ONNX input names from the forward
+    signature by introspection, so the signature IS the on-device contract and has to be written out
+    literally. The model still receives correct positions — HF computes them from the attention mask
+    when the argument is absent.
+    """
+
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = True
+
+    def forward(self, input_ids, attention_mask, labels):
+        return self.backbone(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
+
+
+class OnnxEncoderTrainerWrapper(torch.nn.Module):
+    """Encoder (BERT-family) training-graph wrapper.
+
+    Differs from the decoder wrapper in one input: `token_type_ids` instead of `position_ids`. Optimum
+    asserts the `OnnxConfig`'s dummy inputs are a subset of the model's, and `BertOnnxConfig` generates
+    `token_type_ids`, so a decoder-shaped wrapper fails the export with
+    `{token_type_ids, …} vs {position_ids, …}`.
+    """
+
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = True
+
+    def forward(self, input_ids, attention_mask, token_type_ids, labels):
+        return self.backbone(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            labels=labels,
+        )
+
+
+class OnnxSequenceClassificationTrainerWrapper(torch.nn.Module):
+    """Encoder **classification** training-graph wrapper (#33).
+
+    Same input names as the encoder wrapper; the difference is the label contract, which is why this
+    is a distinct class rather than a flag. Classification supervises **one label per sequence**
+    (`[batch]`, int64 class indices) where every other trainable task here supervises one per token
+    (`[batch, seq]`). That shape is declared on the task row (`TaskSpec.label_shape`) and consumed by
+    the dummy-label generator, so the two cannot drift apart.
+
+    The head is randomly initialised — it does not exist in an encoder checkpoint — which is correct:
+    it is precisely the part fine-tuning learns. The pretrained *backbone* is what must survive, and
+    that is what the export-time parameter budget checks.
+    """
+
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = True
+
+    def forward(self, input_ids, attention_mask, token_type_ids, labels):
+        return self.backbone(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            labels=labels,
+        )
+
+
+class OnnxSequenceClassificationNoTokenTypeIdsTrainerWrapper(torch.nn.Module):
+    """Classification training-graph wrapper for encoders that have no ``token_type_ids``.
+
+    Same objective and label contract as :class:`OnnxSequenceClassificationTrainerWrapper` — one
+    ``[batch]`` class index per sequence — differing only in the exported input set. It exists because
+    **DistilBERT has no segment embedding**: it dropped BERT's next-sentence-prediction objective, so
+    ``DistilBertOnnxConfig.inputs`` is ``[input_ids, attention_mask]`` where ``BertOnnxConfig``'s is
+    ``[input_ids, attention_mask, token_type_ids]``, and Optimum passes the dummy inputs to the traced
+    module **positionally**. Against the four-parameter classification wrapper that would bind
+    ``labels`` into ``token_type_ids``' slot and leave ``labels`` unbound.
+
+    This is the encoder form of the same disagreement :class:`OnnxDecoderNoPositionIdsTrainerWrapper`
+    exists for on the decoder side, and it was caught by
+    :func:`_check_wrapper_matches_config_inputs` — the cross-check written for that one — before
+    ``torch.jit`` could report it as a bare ``TypeError`` from a frame this repo does not own.
+
+    A separate class rather than an optional parameter for the reason given on
+    :class:`OnnxTrainerWrapper`: ``torch.onnx`` derives the exported ONNX input names from the forward
+    signature by introspection, so the signature IS the on-device contract and must be written out
+    literally.
+    """
+
+    def __init__(self, model) -> None:
+        super().__init__()
+        self.backbone = model
+        self.config = model.config
+        self.training = True
+
+    def forward(self, input_ids, attention_mask, labels):
+        return self.backbone(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
+
+
+def compare_weights(model_path1, model_path2):
+    """
+    Compares weights of two models based on their initializers.
+    """
+
+    onnx_model = onnx.load(model_path1)
+    INTIALIZERS = onnx_model.graph.initializer
+    onnx_weights_1 = {}
+
+    for initializer in INTIALIZERS:
+        W = numpy_helper.to_array(initializer)
+        onnx_weights_1[initializer.name] = W
+
+    del onnx_model
+    onnx_model = onnx.load(model_path2)
+    INTIALIZERS = onnx_model.graph.initializer
+    onnx_weights_2 = {}
+
+    for initializer in INTIALIZERS:
+        W = numpy_helper.to_array(initializer)
+        onnx_weights_2[initializer.name] = W
+
+        if initializer.name not in onnx_weights_1 or initializer.name not in onnx_weights_2:
+            print(f"MISMATCH IN INITIALIZERS - missing {initializer.name}")
+            continue
+
+        are_equal = np.array_equal(onnx_weights_1[initializer.name], onnx_weights_2[initializer.name])
+
+        if not are_equal:
+            # print(are_equal)
+            print("Not equal")
+            print(initializer.name)
+            # print(onnx_weights_1[initializer.name])
+            # print(onnx_weights_2[initializer.name])
+            # print(onnx_weights_1[initializer.name].shape)
+            # print(onnx_weights_2[initializer.name].shape)
+
+    onnx.save(onnx_model, "model.onnx", location="model.onnx_data", save_as_external_data=True)
+
+
+def trim_initializers(model_path1):
+    """
+    Removes all the layers of initializers that start with:
+    - ONNX basic nodes with "/"
+    - ONNX nodes with "onnx::"
+    """
+
+    onnx_model = onnx.load(model_path1)
+    INTIALIZERS = onnx_model.graph.initializer
+    onnx_weights_1 = {}
+
+    for initializer in INTIALIZERS:
+        W = numpy_helper.to_array(initializer)
+
+        onnx_weights_1[initializer.name] = W
+
+        if initializer.name.startswith("/") or initializer.name.startswith("onnx::"):
+            print("Removed:")
+            print(initializer.name)
+            onnx_model.graph.initializer.remove(initializer)
+        else:
+            print("Not removed:")
+            print(initializer.name)
+
+    onnx.save(onnx_model, "model.onnx", location="model.onnx_data", save_as_external_data=True)
+
+
+def inspect_weights(model_path, only_trainable=False):
+    """
+    Inspects the weights of the model provided.
+    """
+
+    onnx_model = onnx.load(model_path)
+    INTIALIZERS = onnx_model.graph.initializer
+
+    for param in INTIALIZERS:
+        print(f"Layer name: {param.name}")
+
+
+def apply_metadata(model_path, model_id):
+    """
+    Load ONNX model, apply metadata to both model and graph, and resave it (replacing original files).
+
+    Args:
+        model_path (Path): Path to the .onnx model file
+        model_id (str): Model ID to add as metadata
+
+    Returns:
+        Path: Path to the updated model file
+    """
+    # Load the model
+    model = onnx.load(str(model_path))
+
+    # Remove existing model_id metadata from model if it exists
+    to_remove = []
+    for i, prop in enumerate(model.metadata_props):
+        if prop.key == "model_id":
+            to_remove.append(i)
+
+    # Remove in reverse order to maintain indices
+    for i in reversed(to_remove):
+        del model.metadata_props[i]
+
+    # Add metadata to model level
+    model_metadata_entry = onnx.StringStringEntryProto()
+    model_metadata_entry.key = "model_id"
+    model_metadata_entry.value = str(model_id)
+    model.metadata_props.append(model_metadata_entry)
+
+    # Remove existing model_id metadata from graph if it exists
+    graph_to_remove = []
+    for i, prop in enumerate(model.graph.metadata_props):
+        if prop.key == "model_id":
+            graph_to_remove.append(i)
+
+    # Remove in reverse order to maintain indices
+    for i in reversed(graph_to_remove):
+        del model.graph.metadata_props[i]
+
+    # Add metadata to graph level
+    graph_metadata_entry = onnx.StringStringEntryProto()
+    graph_metadata_entry.key = "model_id"
+    graph_metadata_entry.value = str(model_id)
+    model.graph.metadata_props.append(graph_metadata_entry)
+
+    return model
+
+
+def preprocess_model(model: torch.nn.Module, epsilon_high=1e-8, epsilon_low=1e-10):
+    """
+    Add a really small epsilon to the model parameters if they are all zeroes.
+    This is to prevent the ONNX from not saving the extra weights, as they need to be included as initializers.
+    """
+    for _, param in model.named_parameters():
+        if torch.all(param.data == 0):
+            random_values = torch.rand_like(param.data)
+            random_values = (epsilon_high - epsilon_low) * random_values + epsilon_low
+            param.data += random_values
+
+    return model
+
+
+def optimum_hf_export(
+    model_id,
+    model_output="onnx_models",
+    training_mode=False,
+    train_method="lora",
+    lora_target=None,
+    lora_rank=4,
+    lora_alpha=4,
+    quantize=True,
+    weight_type=QuantType.QInt8,
+    peft_config={},
+    specific_peft_config={},
+    postprocess=False,
+    exclude_extra_layers=None,
+    exclude_specific=False,
+    exclude_specific_layers=[],
+    opset=20,
+    task_type="text-generation",
+    add_pooling=False,
+    model_init_kwargs=None,
+):
+    """
+    Exports the model from Huggingface to an ONNX model representation.
+    """
+
+    # #6/#33: one boundary parse, then the registry says what this task implies — the auto-model
+    # class, the KV-cache kwargs and PEFT's task type. Previously three separate branches, one of
+    # which (PEFT's `task_type`) was not a branch at all but a hardcoded "CAUSAL_LM".
+    task_spec = get_task_spec(task_type)
+    if training_mode and not task_spec.trainable:
+        # Fails here with a sentence instead of deep inside torch with
+        # "BertModel.forward() got an unexpected keyword argument 'labels'".
+        raise UnsupportedModelError(
+            f"task {task_spec.task.value!r} has no head and therefore no loss, so it cannot produce a "
+            "training graph. Use 'text-classification' to fine-tune an encoder; "
+            "'feature-extraction' is the inference/embedding task (it is what the RAG embedder ships)."
+        )
+
+    model = import_from_path(task_spec.auto_model_class).from_pretrained(
+        model_id,
+        trust_remote_code=True,
+        token=get_settings().hf_token,
+        # Objective-specific load kwargs (e.g. num_labels for a classification head). Caller wins.
+        **{**task_spec.model_init_kwargs, **(model_init_kwargs or {})},
+    )
+    config = AutoConfig.from_pretrained(model_id, token=get_settings().hf_token)
+
+    # The reference for the export-time parameter-budget gate (artifacts/parameter_budget.py), taken
+    # here because this is the only moment the source model is in memory. Recording the number beats
+    # re-deriving it from AutoConfig shapes downstream, which would need per-architecture maintenance.
+    # `parameters()` de-duplicates, so tied embeddings count once — as they do in the exported graph.
+    source_parameter_count = sum(p.numel() for p in model.parameters())
+
+    # Registry-driven dispatch (no architectures[0] ladder): the architecture registry maps the HF
+    # architecture -> its Optimum OnnxConfig class, and choose_task routes task selection. Unknown
+    # architectures fail closed inside resolve_architecture. Adding one is a registry entry, not an elif.
+    # Resolved from the CLASS THAT WAS LOADED, not from `config.architectures`: the head is part of the
+    # architecture identity, and a sentence-transformers checkpoint still declares `["BertModel"]` when
+    # loaded as a `BertForSequenceClassification`. For decoders the two agree.
+    loaded_architecture = type(model).__name__
+    spec = resolve_architecture(config, architecture=loaded_architecture)
+
+    # PEFT target modules, resolved per model rather than assumed.
+    #
+    # This used to default to a hardcoded ["q_proj", "k_proj"], which is decoder-specific AND
+    # disagreed with the architecture registry's own `target_modules` (`("q_proj", "v_proj")` for every
+    # decoder row — the LoRA convention of adapting Wq/Wv). Nothing passed the argument, so the
+    # registry's value was dead data and an encoder could not be targeted at all.
+    #
+    # The registry row is now the source of truth and the place to edit for a new/changed model — one
+    # data row per architecture — while an explicit `lora_target` (CLI `--lora-target`) still wins for
+    # ad-hoc runs.
+    if not lora_target:
+        lora_target = list(spec.target_modules)
+        logger.info(
+            "peft targets for %s taken from the architecture registry: %s",
+            spec.architecture,
+            lora_target,
+        )
+    else:
+        lora_target = list(lora_target)
+
+    resolved_task = choose_task(supported_onnx_tasks(config.model_type), override=task_type)
+    onnx_config_class = spec.load_onnx_config_class()
+    # The architecture's own task wins over the requested one: a BertModel row declares
+    # feature-extraction and must not be handed KV-cache kwargs its OnnxConfig cannot accept.
+    ocl = onnx_config_class(
+        config,
+        task=resolved_task,
+        **get_task_spec(spec.task).onnx_config_kwargs(training_mode=training_mode),
+    )
+
+    lora_config = None
+    lora_model = None
+    # The exact trainable parameter names, needed by the quantizer below so it never freezes one.
+    # Bound here because it is populated only on the training path but read on both.
+    grad_layers: list[str] = []
+
+    if training_mode:
+        ocl = OnnxConfigWithLoss(ocl)
+
+    onnx_path = Path(f"{model_output}/model.onnx")
+
+    # #6: one fail-closed parse at the boundary; PEFTMethod(...) raises ValueError on an unknown
+    # method rather than silently falling through every branch and leaving `lora_model` unbound.
+    peft_method = PEFTMethod(train_method)
+
+    # The architecture's task drives PEFT's task_type. Both sites below hardcoded "CAUSAL_LM", which
+    # mis-wraps an encoder: PEFT uses this to decide which modules to adapt and which head stays
+    # trainable, and a feature-extraction model has no LM head to find.
+    peft_task_type = get_task_spec(spec.task).peft_task_type
+
+    if training_mode and peft_method is PEFTMethod.LORA:
+        # Apply LoRA to the model
+        lora_config = LoraConfig(
+            r=lora_rank, target_modules=lora_target, task_type=peft_task_type, **peft_config
+        )
+        lora_model = PeftModel(model, lora_config, adapter_name="lora")
+    elif training_mode and peft_method is PEFTMethod.LORA_XS:
+        # TODO: Add specific PEFT config
+        lora_config = LoraConfig(
+            r=lora_rank, target_modules=lora_target, task_type=peft_task_type, **peft_config
+        )
+        lora_model = get_peft_model(model, lora_config)
+        adapter_name = "default"
+        peft_config_dict = {}
+        reconstruct_dict = {
+            "reconstruction_type": "svd",
+            "reconstr_mode": "separated",
+            "half_init_dec": False,
+            "replacement_module_random_init": False,
+            "r_squared": True,
+            "svd": {"rank": lora_rank, "n_iter": 10, "random_state": 42},
+        }
+        peft_config_dict[adapter_name] = lora_config
+        find_and_initialize(model, peft_config_dict, adapter_name, "svd", reconstruct_dict, None)
+    elif training_mode and peft_method is PEFTMethod.MARS:
+        mars_config = MarsConfig(
+            peft_type="MARS",
+            r=lora_rank,
+            alpha=lora_alpha,
+            onnx_export=True,  # always needs to be True for export
+            target_modules=lora_target,  # Target specific model layers
+            task_type=None,
+            **specific_peft_config,
+        )
+
+        lora_model = get_peft_model(model, mars_config, adapter_name="mars")
+    elif training_mode and peft_method is PEFTMethod.ALL:
+        # Make only linear layers trainable
+        for name, module in model.named_modules():
+            if isinstance(module, (torch.nn.Linear)):
+                for param in module.parameters():
+                    param.requires_grad = True
+            else:
+                for param in module.parameters():
+                    param.requires_grad = False
+        lora_model = model
+    elif not training_mode or peft_method is PEFTMethod.NOLORA:
+        lora_model = model
+
+    # #6 A3: the ONE adapter-mapping entry point — the registry resolves each method's builder, so
+    # this no longer re-derives "which mapping function" from the method string.
+    mapping = {}
+    if training_mode:
+        mapping_kwargs = (
+            {"shared_qkv": mars_config.enabled_qkv, "shared_mlp_enabled": mars_config.enabled_mlp}
+            if peft_method is PEFTMethod.MARS
+            else {}
+        )
+        mapping = build_adapter_mapping(peft_method, lora_model, **mapping_kwargs)
+
+    if training_mode:
+        # The registry picks the wrapper, because its forward signature IS the exported input set.
+        # The ARCHITECTURE row wins over the task's default when it sets one: the task owns the
+        # objective, but this row's OnnxConfig owns the input set, and Gemma-3 disagrees with the
+        # other decoders about `position_ids`.
+        trainer_wrapper = import_from_path(
+            spec.trainer_wrapper_class or get_task_spec(spec.task).trainer_wrapper_class
+        )
+        _check_wrapper_matches_config_inputs(trainer_wrapper, ocl)
+        if peft_method is not PEFTMethod.ALL:
+            my_model = trainer_wrapper(lora_model.base_model.model)
+        else:
+            my_model = trainer_wrapper(lora_model)
+        my_model.train()
+    elif task_type == "text-generation":
+        my_model = OnnxInferenceWrapper(lora_model)
+        my_model.eval()
+    else:
+        # Infer from the model
+        my_model = lora_model
+        my_model.eval()
+
+    # Preprocessing methods
+    if training_mode:
+        my_model = preprocess_model(my_model)
+
+    # Trainable count
+    trainable_count = count_trainable_parameters(my_model)
+
+    export(my_model, ocl, onnx_path, opset, do_constant_folding=not training_mode)
+
+    # Apply some metadata to model
+    onnx_model = apply_metadata(onnx_path, model_id)
+
+    # Add pooling operations to the embedding model and save
+    if task_type == "feature-extraction" and add_pooling:
+        add_pooling_to_onnx_model(onnx_model, model_id, f"{model_output}/embedding_model.onnx")
+
+    # Save gradient layer names
+    if training_mode:
+        # Get layers with gradients in the LoRA model
+        grad_layers, no_grad_layers = get_layers_with_grad(my_model)
+        with open(f"{model_output}/training_config.json", "w+", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "requires_grad": grad_layers,
+                    "frozen_params": no_grad_layers,
+                    "peft_mapping": mapping,
+                    "trainable_parameter_count": trainable_count,
+                    # Reference for the export-time parameter-budget gate; see parameter_budget.py.
+                    "source_parameter_count": source_parameter_count,
+                    "rank": lora_rank,
+                    "alpha": lora_alpha,
+                    "peft_target": lora_target,
+                    # The class that was actually LOADED, so the packaging half resolves the same
+                    # architecture row this one did. Without it `export_inference_package` re-resolved
+                    # from `config.architectures`, which for a sentence-transformers checkpoint says
+                    # `["BertModel"]` even when loaded as `BertForSequenceClassification` — the two
+                    # halves of one export then disagreed about the architecture.
+                    "architecture": loaded_architecture,
+                },
+                f,
+                ensure_ascii=False,
+            )
+
+    del my_model
+    my_model = None
+    gc.collect()
+
+    # Apply dynamic quantization to non-trainable layers
+    if quantize:
+        lora_target = [] if not training_mode else lora_target
+        onnx_dynamic_quantization(
+            onnx_model,
+            onnx_path.absolute().as_posix(),
+            f"{model_output}/quant_model.onnx",
+            # Keep the PEFT adapters OUT of quantization. This argument was commented out, so with
+            # `--quant int4` the quantizer packed the LoRA A/B weights along with the frozen base: no
+            # float trainable initializer survived, `requires_grad` resolved to only `*_quantized`
+            # companions, and `generate_artifacts` died — first on "Cannot compute the partial
+            # derivative for '…weight_quantized'", then, once those were correctly excluded, on an
+            # empty trainable set (`IndexError` in optim.py). A quantized base with float adapters is
+            # the project's premise (the base/trainable external split #8/#9 are built around); the
+            # line above computes `lora_target` for exactly this and then discarded it.
+            exclude_weights=lora_target,
+            weight_type=weight_type,
+            # Task-declared: whatever sits on the gradient path between the loss and the adapters must
+            # stay unquantized, because ORT has no gradient for DynamicQuantizeLinear. Decoders need
+            # only the LM head; encoder classification also needs `pooler`/`classifier`.
+            exclude_extra_layers=(
+                list(exclude_extra_layers)
+                if exclude_extra_layers is not None
+                else list(get_task_spec(spec.task).quantization_exclude_layers)
+            ),
+            exclude_specific=exclude_specific,
+            exclude_specific_layers=exclude_specific_layers,
+            # Belt-and-braces over `exclude_weights`, and the ONLY thing that covers a shared adapter
+            # living outside its target modules' subtrees (MARS). Empty when not training.
+            exclude_trainable_initializers=grad_layers,
+        )
+
+        # Add pooling operations to the quantized embedding model and save
+        if task_type == "feature-extraction" and add_pooling:
+            add_pooling_to_onnx_model(
+                f"{model_output}/quant_model.onnx", model_id, f"{model_output}/embedding_quant_model.onnx"
+            )
+
+
+def onnx_dynamic_quantization(
+    onnx_model,
+    onnx_model_path,
+    onnx_model_quant_output,
+    weight_type=QuantType.QInt16,
+    exclude_weights=[],
+    exclude_extra_layers=[],
+    exclude_specific=False,
+    exclude_specific_layers=[],
+    exclude_trainable_initializers=(),
+):
+
+    nodes_to_not_quantize = []
+
+    # A tensor the export declared TRAINABLE must never be quantized, because quantized means frozen:
+    # the quantizer replaces `<w>.weight` with `<w>.weight_quantized`/`_scale`/`_zero_point`, and
+    # `gen_artifacts` (correctly) refuses to ask for a gradient of an int tensor. So the tensor is
+    # silently demoted to a frozen parameter and training simply does not touch it.
+    #
+    # `exclude_weights` alone does not cover this. It holds the PEFT TARGET MODULE names
+    # (`q_proj`/`v_proj`, `query`/`value`), matched as substrings of NODE names — which works for LoRA
+    # because `lora_A`/`lora_B` live inside the target module's own subtree. MARS's shared adapter does
+    # not: it is attached to the attention block (`.../attention/shared_qkv/...`), OUTSIDE any target
+    # module's path, which is the entire point of sharing it across projections. Measured before this
+    # fix: MARS lost exactly its shared half on both architectures (decoder 4 of 8 trainables,
+    # encoder 12 of 24), while LoRA lost none.
+    #
+    # Matching here is on node INPUTS and is EXACT, because these are full initializer names rather
+    # than name fragments — substring matching over 120 long names would be both slow and prone to
+    # accidental hits.
+    trainable_initializers = set(exclude_trainable_initializers)
+
+    # Exclude trainable nodes
+    for param in onnx_model.graph.node:
+        if trainable_initializers and any(inp in trainable_initializers for inp in param.input):
+            nodes_to_not_quantize.append(param.name)
+            continue
+
+        if not exclude_specific:
+            if any((allowed_layer in param.name) for allowed_layer in exclude_weights):
+                nodes_to_not_quantize.append(param.name)
+        else:
+            if any((allowed_layer in param.name) for allowed_layer in exclude_specific_layers):
+                nodes_to_not_quantize.append(param.name)
+
+        if any(allowed_layer in param.name for allowed_layer in exclude_extra_layers):
+            nodes_to_not_quantize.append(param.name)
+        else:
+            for input_weight in param.input:
+                if any(allowed_layer in input_weight for allowed_layer in exclude_extra_layers):
+                    nodes_to_not_quantize.append(param.name)
+                    break
+
+    # `Gemm` is renamed before it is quantized, so excluding it by its own name silently misses.
+    #
+    # ONNX Runtime rewrites `Gemm` -> `MatMul` (+`Add`) during quantization and matches
+    # `nodes_to_exclude` against the **rewritten** name `<gemm>_MatMul`. A caller excluding
+    # `/backbone/bert/pooler/dense/Gemm` therefore excludes nothing, and the node comes back as
+    # `/backbone/bert/pooler/dense/Gemm_MatMul_quant` — a `MatMulInteger` fed by a
+    # `DynamicQuantizeLinear`, i.e. a **quantized activation**.
+    #
+    # That matters beyond tidiness: quantized *weights* are frozen and dequantize to float
+    # (`DequantizeLinear`), so the backward pass flows through them untouched. A quantized
+    # *activation* has no gradient at all — ORT registers no gradient builder for
+    # `DynamicQuantizeLinear` — so any such node on the path between the loss and the adapters makes
+    # `generate_artifacts` fail outright. Decoders never hit it because their linear layers export as
+    # `MatMul`; BERT-family heads export as `Gemm`.
+    gemm_names = {node.name for node in onnx_model.graph.node if node.op_type == "Gemm"}
+    nodes_to_not_quantize += [f"{name}_MatMul" for name in nodes_to_not_quantize if name in gemm_names]
+
+    # Does not work
+    # quant_pre_process(onnx_model_path, f"pre_{onnx_model_quant_output}", save_as_external_data=True, all_tensors_to_one_file=True, external_data_location=f"pre_{onnx_model_quant_output}")
+
+    del onnx_model
+    gc.collect()
+
+    quantize_dynamic(
+        extra_options={
+            "ActivationSymmetric": False,  # True for inference speed. False may keep more accuracy.
+            "WeightSymmetric": False,  # True for inference speed. False may keep more accuracy.
+            "EnableSubgraph": False,  # True for more quant.
+            "ForceQuantizeNoInputCheck": True,  # True for more quant.
+            "MatMulConstBOnly": True,  # False for more quant. Sometime, the inference speed may get worse. Keep this True in case of training graph.
+        },
+        nodes_to_exclude=nodes_to_not_quantize,
+        model_input=onnx_model_path,
+        model_output=onnx_model_quant_output,
+        per_channel=True,
+        use_external_data_format=True,
+        weight_type=weight_type,
+        reduce_range=False,
+    )
+
+
+def count_trainable_parameters(model) -> int:
+    """Count trainable parameters."""
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def check_extra_options(kv_pairs):
+    if "exclude_extra_layers" in kv_pairs:
+        op_types_to_quantize = ()
+        for op_type in kv_pairs["exclude_extra_layers"].split("/"):
+            op_types_to_quantize += (op_type,)
+        kv_pairs["exclude_extra_layers"] = op_types_to_quantize
+    if "exclude_specific_layers" in kv_pairs:
+        op_types_to_quantize = ()
+        for op_type in kv_pairs["exclude_specific_layers"].split("/"):
+            op_types_to_quantize += (op_type,)
+        kv_pairs["exclude_specific_layers"] = op_types_to_quantize
+
+
+def parse_argument_list(targt):
+    return targt.split("/")
+
+
+def parse_extra_options(extra_options: list[str]) -> dict[str, str]:
+    """
+    Parse additional options in KEY=VALUE format into a dictionary.
+    """
+    options_dict = {}
+    for option in extra_options:
+        if "=" in option:
+            key, value = option.split("=", 1)
+            options_dict[key] = value
+        else:
+            raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
+
+    print(f"Extra options: {options_dict}")
+    check_extra_options(options_dict)
+    return options_dict
+
+
+def load_train_config_from_file(config_file: str):
+    """Load a config YAML and return **only its train section**.
+
+    This is the one `load_config_from_file` copy that was never the shared helper: it pre-indexes into
+    ``config[TRAIN_CONFIG]``, so a caller expecting the whole document gets the train section instead.
+    That difference is exactly what the config-layering deferral note warned about — silently
+    repointing this name at `utils.yaml.load_config_from_file` would have changed what every call site
+    receives. Renamed rather than merged, so the two shapes can no longer be confused.
+    """
+    return load_config_from_file(config_file)[TRAIN_CONFIG]
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="Exporting the HF model into a ONNX graph compatible for on-device training.",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    parser.add_argument("--model_id", type=str, help="Identifier for the model to be converted.")
+    parser.add_argument("--output", type=str, help="Path to the model output location.")
+    parser.add_argument(
+        "--training_mode",
+        type=lambda x: x.lower() == "true",
+        default=True,
+        help="Whether the model is in training mode. Default is True.",
+    )
+    parser.add_argument(
+        "--train_method",
+        type=str,
+        choices=["lora", "lora-xs", "mars", "nolora"],
+        default="lora",
+        help="The training method to use, such as LoRA. Default is 'lora'.",
+    )
+    parser.add_argument(
+        "--lora_target",
+        type=parse_argument_list,
+        # `None`, NOT a literal pair. This defaulted to ["q_proj", "k_proj"] — the decoder-specific
+        # pairing the architecture registry replaced — and because argparse always supplies a value,
+        # every run through this entry point silently OVERRODE the registry with it, including on
+        # encoders where those modules do not exist. The registry is the source of truth; an explicit
+        # --lora_target still wins.
+        default=None,
+        help="Target layers for PEFT. Default: the architecture registry's target_modules.",
+    )
+    parser.add_argument(
+        "--lora_rank", type=int, default=16, help="Rank for the given LoRA method. Default is 16."
+    )
+    parser.add_argument("--lora_alpha", type=int, default=32, help="Alpha for the PEFT method.")
+    parser.add_argument(
+        "--quantize", type=bool, default=True, help="Whether to apply quantization. Default is True."
+    )
+    parser.add_argument(
+        "--weight_type",
+        type=lambda x: QuantType[x],
+        choices=list(QuantType),
+        default=QuantType.QUInt8,
+        help="The quantization weight type, e.g., QUInt8. Default is QuantType.QUInt8. Recommended QInt8 so it stays in the same quantization domain as inference model.",
+    )
+    parser.add_argument(
+        "--task_type",
+        type=str,
+        choices=["text-generation", "feature-extraction"],
+        default="text-generation",
+        help="Task type to build the model for.",
+    )
+    parser.add_argument(
+        "--config_file",
+        type=str,
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
+    )
+    parser.add_argument(
+        "--extra_options",
+        type=str,
+        nargs="*",
+        metavar="KEY=VALUE",
+        default=[],
+        help=textwrap.dedent("""\
+         Key value pairs for various options. Currently supports:
+            postprocess = False : Whether to try to do operator fusion after creating the graph. The applied fused operators should be supported by training.
+            opset = 20 : Opset version for model operators.
+            exclude_extra_layers = layer1/layer2... : Extra layers to further exclude from the quantization. Keywords should be separated by "/".
+            """),
+    )
+
+    args = parser.parse_args()
+
+    user_extra_options = {}
+    default_extra_options = {
+        "postprocess": False,
+        "add_pooling": True,
+        "opset": 20,
+        "exclude_extra_layers": [],
+        "exclude_specific": False,
+        "exclude_specific_layers": [],
+    }
+
+    config_dict = None
+
+    if args.config_file:
+        config_dict = load_train_config_from_file(args.config_file)
+
+        args.peft_config = config_dict["peft_config"]
+        setattr(args, config_dict["train_method"], config_dict[config_dict["train_method"]])
+
+        # Override any command-line argument with values from the config file
+        for key, value in config_dict.items():
+            # Convert to the correct type
+            if hasattr(args, key):
+                setattr(args, key, value)
+        # Override any command-line argument with values from the config file
+        for key, value in config_dict["extra_options"].items():
+            default_extra_options[key] = value
+        args.weight_type = QuantType[config_dict["weight_type"]]
+    else:
+        user_extra_options = parse_extra_options(args.extra_options)
+    args.extra_options = {**default_extra_options, **user_extra_options}
+
+    return args
+
+
+if __name__ == "__main__":
+    args = parse_arguments()
+
+    method = getattr(args, "train_method", "lora")
+    peft_config = getattr(args, "peft_config", None)
+    specific_peft_config = getattr(args, method, None)
+
+    print(f"{TRAIN_CONFIG} arguments:")
+    for arg, value in vars(args).items():
+        print(f"{arg}: {value}")
+
+    if peft_config:
+        print("PEFT arguments:")
+        for arg, value in peft_config.items():
+            print(f"{arg}: {value}")
+
+    if specific_peft_config:
+        print("Extra specific PEFT arguments:")
+        for arg, value in specific_peft_config.items():
+            print(f"{arg}: {value}")
+
+    optimum_hf_export(
+        model_id=args.model_id,
+        model_output=args.output,
+        train_method=args.train_method,
+        training_mode=args.training_mode,
+        lora_target=args.lora_target,
+        lora_rank=args.lora_rank,
+        lora_alpha=args.lora_alpha,
+        quantize=args.quantize,
+        weight_type=args.weight_type,
+        task_type=args.task_type,
+        peft_config=peft_config,
+        specific_peft_config=specific_peft_config,
+        **args.extra_options,
+    )
diff --git a/src/mobiletransformers/federated/__init__.py b/src/mobiletransformers/federated/__init__.py
new file mode 100644
index 0000000..d53da24
--- /dev/null
+++ b/src/mobiletransformers/federated/__init__.py
@@ -0,0 +1,26 @@
+"""Federated adapter codec + Python Flower simulation (#35, Tier-3 showcase).
+
+Framing: *Flower-compatible federated adapter experiments*, not production federated Android LLM training.
+Option A (Python-only in-process simulation) only. The exchange record (:mod:`adapter_record`) and the
+aggregation math (:mod:`flower_sim`) are pure numpy + stdlib — importable and testable without Flower or an
+ORT-training runtime. The Flower ``ClientApp``/``run_simulation`` orchestration (:mod:`flower_client`) imports
+``flwr`` lazily and is exercised in the manual workflow leg.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.federated.adapter_record import (
+    FederatedAdapterRecord,
+    FederatedTensor,
+    codec_tensor_specs,
+)
+from mobiletransformers.federated.flower_sim import ClientUpdate, federated_average, save_global_adapter
+
+__all__ = [
+    "FederatedAdapterRecord",
+    "FederatedTensor",
+    "codec_tensor_specs",
+    "ClientUpdate",
+    "federated_average",
+    "save_global_adapter",
+]
diff --git a/src/mobiletransformers/federated/adapter_record.py b/src/mobiletransformers/federated/adapter_record.py
new file mode 100644
index 0000000..8481784
--- /dev/null
+++ b/src/mobiletransformers/federated/adapter_record.py
@@ -0,0 +1,317 @@
+"""``FederatedAdapterRecord`` — a thin wrapper over the canonical tensor codec (#8) for federation (#35).
+
+The record **invents no tensor ordering**: the exchanged tensor list (names, order, dtype, shape) comes
+straight from :class:`~mobiletransformers.artifacts.handoff_map.HandoffMap` /
+:meth:`HandoffEntry.tensor_specs` — the ONE source of tensor identity. ``adapterFormatVersion`` **equals**
+the handoff-map ``schemaVersion`` and is gated by the shared ``check_compat`` helper, so a record built
+against an incompatible codec fails closed.
+
+**Byte serialization (pinned — #36's JNI ``ByteArray`` uses exactly this):** a 4-byte little-endian
+``uint32`` header length, then the UTF-8 JSON header (each tensor entry carrying ``byteOffset``/``byteLength``
+instead of inline bytes), then the concatenated raw tensor payloads in **codec order** — each little-endian,
+contiguous C-order, dtype/shape exactly as declared. No compression, no alignment padding in v1.
+
+**v1 simplification (not a silent cap):** the federatable set is the codec's ordered *trainable* tensor
+specs (the per-layer LoRA-shaped trainable weights). True A/B-factor-only exchange is a future refinement;
+using the handoff map's tensor identity keeps us from inventing a second ordering (F8).
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap, TensorSpec
+from mobiletransformers.artifacts.versioning import check_compat
+from mobiletransformers.exceptions import HandoffError
+
+if TYPE_CHECKING:
+    import numpy as np
+
+#: Reader schema version for the federated record contract (see ``check_compat``).
+FEDERATED_RECORD_READER_VERSION = "1.0"
+
+#: handoff dtype name -> little-endian numpy dtype string. Only float/int8 trainables are federatable in v1;
+#: int4 (packed quantized base weights) are never exchanged and fail closed.
+_DTYPE_TO_NP = {
+    "float16": "<f2",
+    "float32": "<f4",
+    "float64": "<f8",
+    "int8": "|i1",
+    "uint8": "|u1",
+    "int32": "<i4",
+}
+
+
+def _np_dtype(dtype: str) -> str:
+    np_dtype = _DTYPE_TO_NP.get(dtype)
+    if np_dtype is None:
+        raise HandoffError(f"dtype {dtype!r} is not federatable in v1 (float/int8 trainables only)")
+    return np_dtype
+
+
+def codec_tensor_specs(handoff: HandoffMap) -> list[TensorSpec]:
+    """The deterministic, codec-derived list of federatable tensor specs (order == serialization order).
+
+    **These are the rank-r ADAPTER FACTORS, not the merged weights (#35, decided 2026-08-09).**
+
+    The two vocabularies are genuinely different objects, and conflating them is what stopped the
+    simulation dead: `HandoffEntry.tensor_specs()` describes ONE merged inference initializer per
+    adapted layer (60 tensors at full weight shape on SmolLM2-135M), while the ORT checkpoint holds
+    `lora_A` + `lora_B` per adapted layer (120 tensors at rank-r shape). Federation now exchanges the
+    factors:
+
+    * per-round traffic drops by roughly ``d_in * d_out / (r * (d_in + d_out))`` — about 36x at r=8 on
+      this model, and the ratio grows with ``d/r``;
+    * it matches the tier doc's "do not aggregate merged base weights";
+    * a client no longer has to merge locally before it can send anything.
+
+    Fails closed on a map that cannot describe its factors (any package exported before handoff-map
+    schema 1.1). Falling back to the merged specs would silently resurrect the exact ambiguity this
+    decision removed, and the failure would surface as a shape mismatch several layers away.
+    """
+    specs: list[TensorSpec] = []
+    missing: list[str] = []
+    for entry in handoff._sorted_entries():
+        entry_specs = entry.adapter_tensor_specs()
+        if not entry_specs:
+            missing.append(entry.training_base_layer_name)
+        specs.extend(entry_specs)
+
+    if missing:
+        raise HandoffError(
+            f"{len(missing)} handoff entries carry no adapter dtype/shape (e.g. {missing[0]}), so the "
+            "rank-r factors cannot be described. This package predates weight_handoff_map schema 1.1 "
+            "— re-export it with the training stage. (Federation exchanges adapter factors as of #35; "
+            "it does not fall back to merged weights.)"
+        )
+    return specs
+
+
+#: The only aggregation v1 produces or accepts (#35, decided 2026-08-08).
+#:
+#: The dataclass used to advertise `"weighted_average" | "average" | "server_only"` in a comment, but
+#: no caller ever set the other two — they were vocabulary with no implementation behind them. An
+#: unreachable enum value in a **wire format** is worse than absent: a peer may legitimately emit it,
+#: and this side would have accepted it and then aggregated as if it were a weighted average.
+#: Rejected on read instead. Adding a value back means implementing it AND regenerating the golden.
+SUPPORTED_AGGREGATIONS = frozenset({"weighted_average"})
+
+#: The tensor roles the record carries — `TrainableTensorCodec`'s vocabulary (#8), which #35 ratified
+#: as normative over the tier doc's never-implemented `{adapter, trainable_weight, head}`.
+SUPPORTED_ROLES = frozenset(
+    {
+        # Adapter factors — what v1 exchanges as of the #35 rank-r decision.
+        "shared_A",
+        "intermediate",
+        "adapter_A",
+        "adapter_B",
+        # Merged-weight roles. Still accepted on READ so records written under the previous
+        # merged-weight vocabulary deserialize rather than failing as "unknown role"; nothing
+        # produces them any more.
+        "weight",
+        "weight_quantized",
+        "scale",
+        "zero_point",
+    }
+)
+
+
+@dataclass
+class FederatedTensor:
+    name: str
+    dtype: str
+    shape: tuple[int, ...]
+    role: str  # one of SUPPORTED_ROLES
+    aggregation: str  # SUPPORTED_AGGREGATIONS — single-valued in v1
+
+
+@dataclass
+class FederatedAdapterRecord:
+    """One round's adapter payload — metadata wrapper + the raw tensor arrays (in codec order)."""
+
+    base_model_id: str
+    peft_method: str
+    adapter_format_version: str
+    tensors: list[FederatedTensor]
+    arrays: list[np.ndarray]
+    round: int = 0
+    mobiletransformers_package_revision: str = ""
+    metrics: dict[str, Any] = field(default_factory=dict)
+    schema_version: str = "1.0"
+    min_reader_version: str = "1.0"
+
+    def __post_init__(self) -> None:
+        if len(self.tensors) != len(self.arrays):
+            raise HandoffError(
+                f"tensor/array count mismatch: {len(self.tensors)} specs vs {len(self.arrays)} arrays"
+            )
+
+    # --- construction from the canonical codec ---------------------------------------------------
+    @classmethod
+    def from_handoff(
+        cls,
+        handoff: HandoffMap,
+        arrays: Sequence[np.ndarray],
+        *,
+        base_model_id: str,
+        peft_method: str,
+        round: int = 0,
+        package_revision: str = "",
+        metrics: dict[str, Any] | None = None,
+        aggregation: str = "weighted_average",
+    ) -> FederatedAdapterRecord:
+        specs = codec_tensor_specs(handoff)
+        if len(arrays) != len(specs):
+            raise HandoffError(f"expected {len(specs)} arrays (codec-derived), got {len(arrays)}")
+        tensors = [FederatedTensor(s.name, s.dtype, tuple(s.shape), s.role, aggregation) for s in specs]
+        return cls(
+            base_model_id=base_model_id,
+            peft_method=peft_method,
+            adapter_format_version=handoff.schema_version,
+            tensors=tensors,
+            arrays=list(arrays),
+            round=round,
+            mobiletransformers_package_revision=package_revision,
+            metrics=metrics or {},
+        )
+
+    def check_format(self, handoff: HandoffMap) -> None:
+        """Fail closed unless this record's ``adapterFormatVersion`` matches the codec it rides on (F1/F8)."""
+        check_compat(self.schema_version, self.min_reader_version, FEDERATED_RECORD_READER_VERSION)
+        if self.adapter_format_version != handoff.schema_version:
+            raise HandoffError(
+                f"adapterFormatVersion {self.adapter_format_version!r} != weight_handoff_map "
+                f"schemaVersion {handoff.schema_version!r}"
+            )
+
+    # --- ndarray view ----------------------------------------------------------------------------
+    def to_ndarrays(self) -> list[np.ndarray]:
+        return list(self.arrays)
+
+    # --- pinned byte serialization ---------------------------------------------------------------
+    def serialize(self) -> bytes:
+        import numpy as np
+
+        payloads: list[bytes] = []
+        tensor_headers: list[dict[str, Any]] = []
+        offset = 0
+        for spec, arr in zip(self.tensors, self.arrays, strict=True):
+            np_dtype = _np_dtype(spec.dtype)
+            buf = np.ascontiguousarray(arr, dtype=np_dtype).tobytes(order="C")
+            tensor_headers.append(
+                {
+                    "name": spec.name,
+                    "dtype": spec.dtype,
+                    "shape": list(spec.shape),
+                    "role": spec.role,
+                    "aggregation": spec.aggregation,
+                    "byteOffset": offset,
+                    "byteLength": len(buf),
+                }
+            )
+            payloads.append(buf)
+            offset += len(buf)
+
+        header = {
+            "schemaVersion": self.schema_version,
+            "minReaderVersion": self.min_reader_version,
+            "baseModelId": self.base_model_id,
+            "mobiletransformersPackageRevision": self.mobiletransformers_package_revision,
+            "peftMethod": self.peft_method,
+            "adapterFormatVersion": self.adapter_format_version,
+            "round": self.round,
+            "tensors": tensor_headers,
+            "metrics": self.metrics,
+        }
+        header_bytes = json.dumps(header, sort_keys=True).encode("utf-8")
+        return struct.pack("<I", len(header_bytes)) + header_bytes + b"".join(payloads)
+
+    @classmethod
+    def deserialize(cls, data: bytes) -> FederatedAdapterRecord:
+        import numpy as np
+
+        if len(data) < 4:
+            raise HandoffError("truncated federated record (no header length)")
+        (header_len,) = struct.unpack("<I", data[:4])
+        header_end = 4 + header_len
+        if len(data) < header_end:
+            raise HandoffError("truncated federated record (header shorter than declared)")
+        header = json.loads(data[4:header_end].decode("utf-8"))
+        payload = data[header_end:]
+
+        # F1/F8: gate the WIRE record's schema before trusting any of its offsets. This used to run
+        # only if a caller happened to invoke check_format afterwards, and no caller did — so a peer
+        # record built against an incompatible codec was accepted by the only ingest path there is.
+        check_compat(
+            header.get("schemaVersion", "1.0"),
+            header.get("minReaderVersion", "1.0"),
+            FEDERATED_RECORD_READER_VERSION,
+        )
+
+        tensors: list[FederatedTensor] = []
+        arrays: list[np.ndarray] = []
+        for t in header["tensors"]:
+            start, length = t["byteOffset"], t["byteLength"]
+            # Bounds-check before slicing: byteOffset/byteLength come from an untrusted peer, and a
+            # Python slice silently clamps rather than raising.
+            if start < 0 or length < 0 or start + length > len(payload):
+                raise HandoffError(
+                    f"tensor {t['name']!r} declares bytes [{start}, {start + length}) "
+                    f"outside the {len(payload)}-byte payload"
+                )
+            chunk = payload[start : start + length]
+            if len(chunk) != length:
+                raise HandoffError(f"truncated payload for tensor {t['name']!r}")
+            expected = int(np.dtype(_np_dtype(t["dtype"])).itemsize)
+            for dim in t["shape"]:
+                expected *= int(dim)
+            if expected != length:
+                raise HandoffError(
+                    f"tensor {t['name']!r}: shape {tuple(t['shape'])} of {t['dtype']} needs "
+                    f"{expected} bytes, header declares {length}"
+                )
+            arr = np.frombuffer(chunk, dtype=_np_dtype(t["dtype"])).reshape(tuple(t["shape"]))
+            if t["aggregation"] not in SUPPORTED_AGGREGATIONS:
+                raise HandoffError(
+                    f"tensor {t['name']!r}: unsupported aggregation {t['aggregation']!r}; v1 supports "
+                    f"only {sorted(SUPPORTED_AGGREGATIONS)}. Accepting it would silently aggregate the "
+                    "tensor as a weighted average, which is not what the peer asked for."
+                )
+            if t["role"] not in SUPPORTED_ROLES:
+                raise HandoffError(
+                    f"tensor {t['name']!r}: unknown role {t['role']!r}; expected one of "
+                    f"{sorted(SUPPORTED_ROLES)} (#35 codec vocabulary)."
+                )
+            tensors.append(
+                FederatedTensor(t["name"], t["dtype"], tuple(t["shape"]), t["role"], t["aggregation"])
+            )
+            arrays.append(arr)
+
+        return cls(
+            base_model_id=header["baseModelId"],
+            peft_method=header["peftMethod"],
+            adapter_format_version=header["adapterFormatVersion"],
+            tensors=tensors,
+            arrays=arrays,
+            round=header.get("round", 0),
+            mobiletransformers_package_revision=header.get("mobiletransformersPackageRevision", ""),
+            metrics=header.get("metrics", {}),
+            schema_version=header.get("schemaVersion", "1.0"),
+            min_reader_version=header.get("minReaderVersion", "1.0"),
+        )
+
+    def comm_size_bytes(self) -> int:
+        """Serialized size of this record (per-round communication cost)."""
+        return len(self.serialize())
+
+
+__all__ = [
+    "FEDERATED_RECORD_READER_VERSION",
+    "FederatedTensor",
+    "FederatedAdapterRecord",
+    "codec_tensor_specs",
+]
diff --git a/src/mobiletransformers/federated/flower_client.py b/src/mobiletransformers/federated/flower_client.py
new file mode 100644
index 0000000..622c26c
--- /dev/null
+++ b/src/mobiletransformers/federated/flower_client.py
@@ -0,0 +1,393 @@
+"""Flower ``ClientApp``/``ServerApp`` builders over ORT-backed clients (#35) — manual workflow leg.
+
+Everything here imports ``flwr`` (and, for real training, the ORT-training runtime) lazily. It is exercised
+by the CHECKPOINT #35 workflow, not automated CI. The client ``train`` handler runs one local ORT training
+step reusing the ``CheckpointState``/``Module``/``Optimizer`` loop shape from
+``artifact/onnx_builder.py::onnx_checktrain`` (reuse, don't rewrite) and returns **only** the updated
+trainable tensors in codec order — the aggregation is the pure :func:`federated_average`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from mobiletransformers.exceptions import HandoffError
+
+if TYPE_CHECKING:
+    import numpy as np
+
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+
+
+#: Deterministic per-client corpus. Federated averaging over clients that all see the SAME batch is
+#: an average of identical updates — arithmetically a no-op, and it cannot show that aggregation does
+#: anything a single client does not. Each shard is a different topic so the clients genuinely
+#: disagree, and the HELD-OUT sentences below are what the aggregated adapter is scored on.
+CLIENT_SHARDS: tuple[tuple[str, ...], ...] = (
+    (
+        "The kettle boiled and the tea was poured.",
+        "She sliced the bread and buttered it warm.",
+        "Dinner simmered slowly on the back burner.",
+    ),
+    (
+        "The train pulled into the station on time.",
+        "He bought a ticket and found his seat.",
+        "The platform emptied as the doors closed.",
+    ),
+    (
+        "Rain fell steadily against the window.",
+        "The clouds broke and the sun came through.",
+        "A cold wind moved across the open field.",
+    ),
+    (
+        "The library was quiet all afternoon.",
+        "She returned the book she had borrowed.",
+        "Shelves of paperbacks lined the far wall.",
+    ),
+)
+
+#: Fixed evaluation batch, scored identically by every round. Held out from every shard so a falling
+#: number means the aggregate generalised, not that it memorised one client's rows.
+EVAL_SENTENCES: tuple[str, ...] = (
+    "The morning light came in through the window.",
+    "He closed the book and set it on the table.",
+)
+
+
+def _load_tokenizer(tokenizer_dir: str | Path) -> Any:  # pragma: no cover - env-gated
+    """Load the tokenizer the PACKAGE ships, never from the Hub.
+
+    This used to be `AutoTokenizer.from_pretrained(model_id, token=require_hf_token())`, which fails
+    with "HF_TOKEN is not set" inside a Ray actor (the actors do not inherit the driver's settings)
+    and, more importantly, makes a *federated client* reach out to a remote service to do local work.
+    A federated client that phones home for a tokenizer it already has on disk is the wrong shape.
+    """
+    from transformers import AutoTokenizer  # noqa: PLC0415
+
+    tokenizer = AutoTokenizer.from_pretrained(str(tokenizer_dir))
+    tokenizer.pad_token_id = 0
+    return tokenizer
+
+
+def _batch(
+    tokenizer: Any, sentences: Sequence[str], *, np: Any
+) -> tuple[Any, Any, Any, Any]:  # pragma: no cover - env-gated
+    """Tokenize to the (input_ids, attention_mask, position_ids, labels) tuple the graph expects."""
+    encoded = tokenizer(list(sentences), return_tensors="np", padding=True)
+    input_ids = np.asarray(encoded["input_ids"], dtype=np.int64)
+    attention_mask = np.asarray(encoded["attention_mask"], dtype=np.int64)
+    position_ids = np.arange(input_ids.shape[1], dtype=np.int64)[None, :]
+    labels = np.copy(input_ids)
+    labels[:, :-1] = input_ids[:, 1:]
+    labels[:, -1] = -100  # ignore the final position in the loss
+    return input_ids, attention_mask, position_ids, labels
+
+
+def evaluate_adapter(
+    train_dir: str | Path,
+    tokenizer_dir: str | Path,
+    arrays: list[np.ndarray],
+    handoff: HandoffMap,
+) -> float:  # pragma: no cover - env-gated (ORT-training runtime)
+    """Loss of ``arrays`` (a global adapter) on the fixed held-out batch.
+
+    This is the metric the #35 self-check asks about. It is deliberately measured on the SERVER over
+    the AGGREGATED tensors: a falling client-side training loss only says each client fitted its own
+    shard, which is true even when aggregation is broken.
+    """
+    import numpy as np  # noqa: PLC0415
+    from onnxruntime.training.api import CheckpointState, Module  # noqa: PLC0415
+
+    train_dir = Path(train_dir)
+    state = CheckpointState.load_checkpoint(str(train_dir / "checkpoint"))
+    model = Module(str(train_dir / "training_model.onnx"), state, str(train_dir / "eval_model.onnx"))
+
+    by_name = {name: param for name, param in state.parameters if param.requires_grad}
+    if arrays:
+        for name, array in zip(_codec_ordered_names(handoff, by_name), arrays, strict=True):
+            by_name[name].data = np.ascontiguousarray(array, dtype=by_name[name].data.dtype)
+
+    tokenizer = _load_tokenizer(tokenizer_dir)
+    inputs = _batch(tokenizer, EVAL_SENTENCES, np=np)
+
+    model.eval()
+    out = model(*inputs)
+    return float(np.asarray(out[0] if isinstance(out, (tuple, list)) else out).mean())
+
+
+def _codec_ordered_names(handoff: HandoffMap, available: dict[str, Any]) -> list[str]:
+    """The codec's adapter-factor names, in serialization order, checked against what exists.
+
+    Fails closed naming the first missing tensor: a checkpoint that cannot supply a declared factor is
+    a package/codec mismatch, and continuing would exchange a short, silently misaligned vector.
+    """
+    from mobiletransformers.federated.adapter_record import codec_tensor_specs  # noqa: PLC0415
+
+    names = [spec.name for spec in codec_tensor_specs(handoff)]
+    missing = [n for n in names if n not in available]
+    if missing:
+        raise HandoffError(
+            f"{len(missing)} codec-declared adapter factors are absent from the checkpoint "
+            f"(e.g. {missing[0]}); the package and the handoff map disagree"
+        )
+    return names
+
+
+def run_local_training_step(
+    train_dir: str | Path,
+    tokenizer_dir: str | Path,
+    incoming: list[np.ndarray],
+    handoff: HandoffMap,
+    *,
+    max_steps: int = 2,
+    shard_index: int = 0,
+) -> tuple[list[np.ndarray], dict[str, Any]]:  # pragma: no cover - env-gated (ORT-training runtime)
+    """Load the package's ``train/`` artifacts, apply the incoming global adapter, run ``max_steps`` ORT
+    optimizer steps on THIS client's shard, and return the updated trainable tensors (codec order) +
+    metrics.
+
+    Mirrors ``onnx_checktrain`` (``CheckpointState.load_checkpoint`` -> ``Module``/``Optimizer`` -> train
+    loop). Kept intentionally small; the numerical fidelity is validated in the manual leg.
+    """
+    import numpy as np  # noqa: PLC0415
+    from onnxruntime.training.api import CheckpointState, Module, Optimizer  # noqa: PLC0415
+
+    # The TRAIN STAGE dir, resolved by the caller from the manifest — NOT a package root with
+    # "train" appended. `<package>/train` is the on-device CACHE layout; a hub package puts the same
+    # stage at `variants/<variantId>/train`, which the manifest declares in `paths.train`. Appending
+    # blind produced ORT's opaque `Invalid fd was supplied: -1`, which names no file at all.
+    train_dir = Path(train_dir)
+    state = CheckpointState.load_checkpoint(str(train_dir / "checkpoint"))
+    model = Module(str(train_dir / "training_model.onnx"), state, str(train_dir / "eval_model.onnx"))
+    optimizer = Optimizer(str(train_dir / "optimizer_model.onnx"), model)
+
+    # Apply the incoming GLOBAL adapter before training. Skipping this made every round start from the
+    # client's own checkpoint, so aggregation had no effect whatsoever on the next round's clients.
+    #
+    # Matched BY NAME against the codec order, never by the checkpoint's own iteration order. The two
+    # need not agree — codec order is (entries sorted by canonical weight name) x adapter role, while
+    # `state.parameters` yields whatever order ORT stored — and a positional mismatch would quietly
+    # write layer 7's `lora_A` over layer 3's. Shapes differ per layer, so most such swaps would raise;
+    # "most" is not a guarantee, and the ones that did not raise would be silent corruption.
+    by_name = {name: param for name, param in state.parameters if param.requires_grad}
+    ordered = _codec_ordered_names(handoff, by_name)
+    if incoming:
+        if len(incoming) != len(ordered):
+            raise HandoffError(
+                f"incoming global adapter has {len(incoming)} tensors, "
+                f"but the codec declares {len(ordered)} adapter factors"
+            )
+        for name, array in zip(ordered, incoming, strict=True):
+            param = by_name[name]
+            if tuple(param.data.shape) != tuple(array.shape):
+                raise HandoffError(
+                    f"incoming tensor for {name!r} has shape {tuple(array.shape)}, "
+                    f"expected {tuple(param.data.shape)}"
+                )
+            param.data = np.ascontiguousarray(array, dtype=param.data.dtype)
+
+    # THIS client's shard. Every client used to train the same two hardcoded sentences, which makes
+    # FedAvg an average of identical updates — so "aggregation improves the metric" could not be
+    # shown even in principle.
+    tokenizer = _load_tokenizer(tokenizer_dir)
+    shard = CLIENT_SHARDS[shard_index % len(CLIENT_SHARDS)]
+    input_ids, attention_mask, position_ids, labels = _batch(tokenizer, shard, np=np)
+
+    model.train()
+    losses: list[float] = []
+    for _ in range(max_steps):
+        # The FORWARD pass was missing entirely: optimizer.step() ran against zero/stale gradients, so
+        # the "updated" tensors were not a function of any data and trainLoss was hardcoded 0.0.
+        forward = model(input_ids, attention_mask, position_ids, labels)
+        loss = float(np.asarray(forward[0] if isinstance(forward, (tuple, list)) else forward).mean())
+        losses.append(loss)
+        optimizer.step()
+        model.lazy_reset_grad()
+
+    # Returned in CODEC order, so the server's `federated_average` lines tensors up with the specs it
+    # aggregates against. Previously this returned raw `state.parameters` order and happened to work
+    # only because nothing checked.
+    updated = [by_name[name].data for name in ordered]
+    return updated, {
+        "numExamples": int(input_ids.shape[0]),
+        "trainLoss": losses[-1] if losses else 0.0,
+    }
+
+
+def build_client_app(
+    handoff: HandoffMap, *, base_model_id: str, local_max_steps: int
+) -> Any:  # pragma: no cover - manual workflow leg (needs flwr)
+    """Build a Flower ``ClientApp`` whose ``train`` handler exchanges only adapter ndarrays (codec order)."""
+    from flwr.app import ArrayRecord, Message, MetricRecord, RecordDict  # noqa: PLC0415
+    from flwr.clientapp import ClientApp  # noqa: PLC0415
+
+    from mobiletransformers.federated.adapter_record import codec_tensor_specs  # noqa: PLC0415
+
+    _ = codec_tensor_specs(handoff)  # validate the codec resolves before the run
+    app = ClientApp()
+
+    @app.train()
+    def train(msg: Message, ctx: Any) -> Message:  # noqa: ANN001
+        incoming = list(msg.content["arrays"].to_numpy_ndarrays()) if "arrays" in msg.content else []
+        # The package dir and shard index arrive in the MESSAGE, not in `ctx.node_config`.
+        # `ctx.node_config["package_dir"]` was unreachable: `flwr.simulation.run_simulation` takes
+        # only (server_app, client_app, num_supernodes, backend_config) — it has no node_config
+        # parameter at all, so nothing could ever populate that key and every client raised KeyError
+        # on its first round.
+        config = msg.content["config"]
+        train_dir = str(config["trainDir"])
+        tokenizer_dir = str(config["tokenizerDir"])
+        shard_index = int(config["shardIndex"])
+        updated, metrics = run_local_training_step(
+            train_dir,
+            tokenizer_dir,
+            incoming,
+            handoff,
+            max_steps=local_max_steps,
+            shard_index=shard_index,
+        )
+        return Message(
+            content=RecordDict({"arrays": ArrayRecord(updated), "metrics": MetricRecord(metrics)}),
+            reply_to=msg,
+        )
+
+    return app
+
+
+def build_server_app(
+    handoff: HandoffMap,
+    *,
+    base_model_id: str,
+    peft_method: str,
+    rounds: int,
+    output_dir: str | Path,
+    train_dir: str | Path,
+    tokenizer_dir: str | Path,
+    node_wait_seconds: float = 120.0,
+) -> Any:  # pragma: no cover - manual workflow leg (needs flwr)
+    """Build a Flower ``ServerApp`` running FedAvg over the codec-ordered adapter tensors.
+
+    This used to discard all five arguments and return a bare ``ServerApp()`` with no strategy and no
+    registered handler, so the docstring's claim was false, ``federated_average`` was wired to nothing,
+    and the CLI's ``--output`` was never written. The per-round aggregation + save is
+    :func:`~mobiletransformers.federated.flower_sim.aggregate_round`, which is pure and unit-tested;
+    only the Grid messaging below needs Flower.
+    """
+    import json  # noqa: PLC0415
+    import time  # noqa: PLC0415
+    from logging import INFO  # noqa: PLC0415
+
+    from flwr.app import ArrayRecord, ConfigRecord, Message, MessageType, RecordDict  # noqa: PLC0415
+    from flwr.common.logger import log  # noqa: PLC0415
+    from flwr.serverapp import Grid, ServerApp  # noqa: PLC0415
+
+    from mobiletransformers.federated.adapter_record import codec_tensor_specs  # noqa: PLC0415
+    from mobiletransformers.federated.flower_sim import ClientUpdate, aggregate_round  # noqa: PLC0415
+
+    specs = codec_tensor_specs(handoff)  # validate the codec resolves before the run
+    app = ServerApp()
+
+    def await_nodes(grid: Grid, round_index: int) -> list[int]:
+        """Supernodes register asynchronously; round 1 always arrives before they are up.
+
+        This used to read `grid.get_node_ids()` once and fail with "no client nodes available" on
+        every run — the first thing a real simulation does is wait.
+        """
+        deadline = time.monotonic() + node_wait_seconds
+        while True:
+            node_ids = list(grid.get_node_ids())
+            if node_ids:
+                return node_ids
+            if time.monotonic() >= deadline:
+                raise HandoffError(
+                    f"round {round_index}: no client nodes registered within {node_wait_seconds:.0f}s"
+                )
+            time.sleep(0.5)
+
+    @app.main()
+    def main(grid: Grid, ctx: Any) -> None:  # noqa: ANN001
+        global_arrays: list[np.ndarray] | None = None
+        eval_losses: list[float] = []
+
+        for round_index in range(1, rounds + 1):
+            node_ids = await_nodes(grid, round_index)
+
+            messages = []
+            for shard_index, node_id in enumerate(node_ids):
+                # Each client gets its OWN shard index, so the clients genuinely disagree and FedAvg
+                # has something to average. `packageDir` travels here because `run_simulation` has no
+                # node_config parameter to put it in.
+                content = RecordDict(
+                    {
+                        "config": ConfigRecord(
+                            {
+                                "trainDir": str(train_dir),
+                                "tokenizerDir": str(tokenizer_dir),
+                                "shardIndex": shard_index,
+                            },
+                        ),
+                    },
+                )
+                if global_arrays is not None:
+                    content["arrays"] = ArrayRecord(global_arrays)
+                messages.append(Message(content=content, message_type=MessageType.TRAIN, dst_node_id=node_id))
+            replies = grid.send_and_receive(messages)
+
+            updates: list[ClientUpdate | None] = []
+            for reply in replies:
+                # A dropped/failed client contributes None; federated_average skips it and the round
+                # still completes over the survivors.
+                if reply.has_error():
+                    updates.append(None)
+                    continue
+                metrics = reply.content["metrics"]
+                updates.append(
+                    ClientUpdate(
+                        arrays=list(reply.content["arrays"].to_numpy_ndarrays()),
+                        num_examples=int(metrics["numExamples"]),
+                    )
+                )
+
+            global_arrays, saved = aggregate_round(
+                handoff,
+                updates,
+                base_model_id=base_model_id,
+                peft_method=peft_method,
+                round_index=round_index,
+                output_dir=output_dir,
+                specs=specs,
+            )
+
+            # THE metric the #35 self-check asks about, measured on the AGGREGATED tensors over a
+            # held-out batch. Client-side training loss is not this: it falls whenever each client
+            # fits its own shard, which happens even if aggregation is broken.
+            eval_loss = evaluate_adapter(train_dir, tokenizer_dir, global_arrays, handoff)
+            eval_losses.append(eval_loss)
+            log(INFO, "round %d: global adapter eval loss %.6f -> %s", round_index, eval_loss, saved)
+
+        # Relative, self-calibrating: the last round must beat the first. No absolute threshold, which
+        # would encode one model and one fixture and silently measure the wrong thing when either
+        # changes.
+        if len(eval_losses) >= 2 and eval_losses[-1] >= eval_losses[0]:
+            raise HandoffError(
+                "aggregation did not improve the held-out metric: "
+                f"round 1 loss {eval_losses[0]:.6f} -> round {len(eval_losses)} loss "
+                f"{eval_losses[-1]:.6f}. Rounds are aggregating, but the aggregate is not learning."
+            )
+        (Path(output_dir) / "eval_losses.json").write_text(
+            json.dumps({"evalLossPerRound": eval_losses}, indent=2),
+        )
+
+    return app
+
+
+__all__ = [
+    "run_local_training_step",
+    "evaluate_adapter",
+    "build_client_app",
+    "build_server_app",
+    "CLIENT_SHARDS",
+    "EVAL_SENTENCES",
+]
diff --git a/src/mobiletransformers/federated/flower_sim.py b/src/mobiletransformers/federated/flower_sim.py
new file mode 100644
index 0000000..4bca3b3
--- /dev/null
+++ b/src/mobiletransformers/federated/flower_sim.py
@@ -0,0 +1,197 @@
+"""FedAvg aggregation + the Option-A in-process simulation driver (#35).
+
+The aggregation math (:func:`federated_average`) and artifact save (:func:`save_global_adapter`) are pure
+numpy + stdlib — testable with canned client updates, no Flower and no ORT-training runtime. The
+:func:`run_simulation` driver imports ``flwr`` lazily and is the manual workflow leg.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from mobiletransformers.exceptions import HandoffError
+
+if TYPE_CHECKING:
+    import numpy as np
+
+    from mobiletransformers.artifacts.handoff_map import HandoffMap
+    from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+
+
+@dataclass
+class ClientUpdate:
+    """One client's contribution to a round: updated tensors (codec order) weighted by ``num_examples``."""
+
+    arrays: list[np.ndarray]
+    num_examples: int
+
+
+def federated_average(updates: Sequence[ClientUpdate | None]) -> list[np.ndarray]:
+    """Weighted (by ``num_examples``) mean of per-client tensor lists, in codec order.
+
+    Dropped clients (``None`` entries) are skipped — aggregation still completes over the survivors.
+    Fails closed if no client survived, if survivors disagree on tensor count, or if total weight is zero.
+    """
+    import numpy as np
+
+    survivors = [u for u in updates if u is not None]
+    if not survivors:
+        raise HandoffError("no surviving client updates to aggregate")
+
+    n_tensors = len(survivors[0].arrays)
+    for u in survivors:
+        if len(u.arrays) != n_tensors:
+            raise HandoffError(f"client tensor-count mismatch: expected {n_tensors}, got {len(u.arrays)}")
+    total = sum(u.num_examples for u in survivors)
+    if total <= 0:
+        raise HandoffError("total num_examples across surviving clients is zero")
+
+    aggregated: list[np.ndarray] = []
+    for i in range(n_tensors):
+        acc = None
+        for u in survivors:
+            contrib = np.asarray(u.arrays[i], dtype=np.float64) * (u.num_examples / total)
+            acc = contrib if acc is None else acc + contrib
+        # cast back to the survivors' dtype for a stable global artifact
+        aggregated.append(np.asarray(acc, dtype=survivors[0].arrays[i].dtype))
+    return aggregated
+
+
+def save_global_adapter(record: FederatedAdapterRecord, output_dir: str | Path) -> Path:
+    """Write a round's global adapter record to ``<output_dir>/global_adapter_round<N>.mtfed``."""
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    path = out / f"global_adapter_round{record.round}.mtfed"
+    path.write_bytes(record.serialize())
+    return path
+
+
+def aggregate_round(
+    handoff: HandoffMap,
+    updates: Sequence[ClientUpdate | None],
+    *,
+    base_model_id: str,
+    peft_method: str,
+    round_index: int,
+    output_dir: str | Path,
+    specs: Sequence[Any] | None = None,
+) -> tuple[list[np.ndarray], Path]:
+    """FedAvg one round's client updates, wrap them in a record, and persist it.
+
+    The whole server side of a round, minus the Flower messaging: aggregate -> build the
+    :class:`FederatedAdapterRecord` in codec order -> :func:`save_global_adapter`. Pure (no ``flwr``,
+    no ORT), so the round semantics are unit-tested rather than only exercised in the manual sim.
+
+    Returns ``(aggregated arrays, saved artifact path)``. The arrays are fed back to the clients as the
+    next round's global adapter.
+    """
+    from mobiletransformers.federated.adapter_record import (  # noqa: PLC0415
+        FederatedAdapterRecord,
+        codec_tensor_specs,
+    )
+
+    aggregated = federated_average(updates)
+    tensor_specs = list(specs) if specs is not None else codec_tensor_specs(handoff)
+    if len(tensor_specs) != len(aggregated):
+        # Naming the counts is not enough here: the two numbers come from two different tensor
+        # VOCABULARIES, and the next person needs to know which. The codec describes the inference
+        # initializers (one merged weight per adapted layer); an ORT training checkpoint holds the
+        # rank-r factors (lora_A + lora_B per adapted layer), i.e. exactly twice as many, of a
+        # different shape. See the `merged_base_plus_adapter` note in docs/FEDERATED.md.
+        raise HandoffError(
+            f"codec declares {len(tensor_specs)} tensors but the round aggregated {len(aggregated)}. "
+            "The codec's vocabulary is MERGED inference initializers (one per adapted layer, full "
+            "weight shape); a client returning raw ORT checkpoint trainables sends rank-r LoRA "
+            "factors (lora_A + lora_B per layer) instead. v1 declares the merged shape "
+            "(aggregation_role='merged_base_plus_adapter'), so a client must merge locally before "
+            "exchanging — switching the record to rank-r adapters is the open v2 decision and would "
+            "break the cross-language byte golden."
+        )
+
+    survivors = [u for u in updates if u is not None]
+    record = FederatedAdapterRecord.from_handoff(
+        handoff,
+        aggregated,
+        base_model_id=base_model_id,
+        peft_method=peft_method,
+        round=round_index,
+        metrics={
+            "clients": float(len(survivors)),
+            "dropped": float(len(updates) - len(survivors)),
+            "numExamples": float(sum(u.num_examples for u in survivors)),
+        },
+    )
+    return aggregated, save_global_adapter(record, output_dir)
+
+
+def run_simulation(
+    handoff: HandoffMap,
+    *,
+    base_model_id: str,
+    peft_method: str,
+    clients: int,
+    rounds: int,
+    local_max_steps: int,
+    output_dir: str | Path,
+    train_dir: str | Path,
+    tokenizer_dir: str | Path,
+    strategy: str = "fedavg",
+    **backend_config: Any,
+) -> Path:  # pragma: no cover - manual workflow leg (needs flwr + ORT-training)
+    """Option-A in-process Flower simulation. Manual/user-run leg — imports ``flwr`` lazily.
+
+    Automated coverage lives in :func:`federated_average` (aggregation) and the record round-trip tests;
+    this driver wires them into Flower's ``run_simulation`` over ORT-backed clients.
+    """
+    if strategy != "fedavg":
+        raise HandoffError(f"unsupported strategy {strategy!r} (v1 supports 'fedavg')")
+    try:
+        from flwr.simulation import run_simulation as flwr_run_simulation  # noqa: F401,PLC0415
+    except ImportError as exc:
+        raise HandoffError(
+            "running the Flower simulation requires flwr (install out-of-band: "
+            'pip install "flwr[simulation]"), plus the ORT-training runtime for real client fit'
+        ) from exc
+    from mobiletransformers.federated.flower_client import build_client_app, build_server_app  # noqa: PLC0415
+
+    client_app = build_client_app(handoff, base_model_id=base_model_id, local_max_steps=local_max_steps)
+    server_app = build_server_app(
+        handoff,
+        base_model_id=base_model_id,
+        peft_method=peft_method,
+        rounds=rounds,
+        output_dir=output_dir,
+        # The clients need this and `run_simulation` has no node_config to carry it, so the server
+        # puts it in each round's message. ABSOLUTE: each client runs inside its own Ray actor with
+        # its own working directory, so a relative path resolves somewhere else entirely — which
+        # surfaces as ORT's opaque `Invalid fd was supplied: -1`, naming nothing.
+        train_dir=Path(train_dir).resolve(),
+        tokenizer_dir=Path(tokenizer_dir).resolve(),
+    )
+    flwr_run_simulation(
+        server_app=server_app,
+        client_app=client_app,
+        num_supernodes=clients,
+        backend_config=backend_config or {"client_resources": {"num_cpus": 1}},
+    )
+    # The ServerApp saves one artifact per round via aggregate_round; fail closed if none appeared,
+    # rather than reporting success for an empty --output (which is what used to happen).
+    out = Path(output_dir)
+    produced = sorted(out.glob("global_adapter_round*.mtfed"))
+    if not produced:
+        raise HandoffError(
+            f"simulation finished but wrote no global adapter to {out} — no round completed aggregation"
+        )
+    return out
+
+
+__all__ = [
+    "ClientUpdate",
+    "federated_average",
+    "aggregate_round",
+    "save_global_adapter",
+    "run_simulation",
+]
diff --git a/src/mobiletransformers/federated/gateway.py b/src/mobiletransformers/federated/gateway.py
new file mode 100644
index 0000000..9a9bdc7
--- /dev/null
+++ b/src/mobiletransformers/federated/gateway.py
@@ -0,0 +1,193 @@
+"""Server side of a federated round: collect device records, aggregate, hand back a global record.
+
+## What this is, and what it is not
+
+This is the **round state machine**, not a web server. It takes serialized
+:class:`FederatedAdapterRecord` blobs, validates each against the package the server holds, aggregates
+the survivors with :func:`federated_average`, and returns a serialized global record. Whether those
+blobs arrive over HTTP, gRPC or a Flower ``ServerApp`` is the transport's problem — keeping the two
+apart is what lets the aggregation logic be tested without a socket, and what lets the same logic sit
+behind the Flower strategy that ``flower_sim.py`` already drives.
+
+## The rules it enforces, and why each exists
+
+Every one of these corresponds to a defect that already happened, either in the #35 simulation or in
+the class of bug this project keeps hitting:
+
+* **Tensors are matched by NAME, never by position.** The simulation paired them by checkpoint
+  iteration order, which would write one layer's ``lora_A`` over another's; differing shapes caught it
+  "mostly", and "mostly" is not a guarantee.
+* **A client whose record disagrees with the package is dropped, not coerced.** A record naming an
+  unknown tensor, or the right tensor at the wrong shape, is a client running a different package —
+  averaging it in would silently corrupt the global adapter.
+* **Dropout is normal.** Devices go offline mid-round; the round completes over the survivors and says
+  how many there were. What is *not* tolerated is completing with too few to be meaningful, hence
+  ``min_clients``.
+* **The global record is built through the same codec** the clients use, so the bytes the server hands
+  back are the bytes a client can read — pinned by the same cross-language golden.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.adapter_record import (
+    FederatedAdapterRecord,
+    codec_tensor_specs,
+)
+from mobiletransformers.federated.flower_sim import ClientUpdate, federated_average
+from mobiletransformers.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    import numpy as np
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RoundResult:
+    """Outcome of one aggregation round."""
+
+    round: int
+    #: The serialized global record, ready to hand back to clients.
+    blob: bytes
+    #: Clients whose record was accepted and averaged in.
+    accepted: int
+    #: Clients rejected, with the reason — kept rather than discarded so a systematically broken
+    #: client population is visible instead of looking like light dropout.
+    rejected: list[tuple[str, str]]
+    #: Total examples behind the aggregate, the weight FedAvg used.
+    total_examples: int
+
+    def describe(self) -> str:
+        return (
+            f"round {self.round}: {self.accepted} accepted, {len(self.rejected)} rejected, "
+            f"{self.total_examples} examples, {len(self.blob)} B global record"
+        )
+
+
+class FederatedGateway:
+    """Aggregates one round at a time against a fixed package.
+
+    :param handoff: the server's copy of ``weight_handoff_map.json``. This is the authority on tensor
+        identity, order and shape — a client's record is checked against it rather than against the
+        other clients, so a cohort that is uniformly wrong is still caught.
+    :param min_clients: fewest accepted clients for a round to be considered meaningful. Below this the
+        round FAILS rather than publishing an aggregate a couple of devices decided.
+    """
+
+    def __init__(
+        self,
+        handoff: HandoffMap,
+        *,
+        base_model_id: str,
+        peft_method: str = "lora",
+        package_revision: str = "",
+        min_clients: int = 2,
+    ) -> None:
+        if min_clients < 1:
+            raise HandoffError(f"min_clients must be >= 1, got {min_clients}")
+        self.handoff = handoff
+        self.base_model_id = base_model_id
+        self.peft_method = peft_method
+        self.package_revision = package_revision
+        self.min_clients = min_clients
+        #: Declared tensor order — computed once, so every round agrees with the package and with itself.
+        self.specs = codec_tensor_specs(handoff)
+        self._expected = {spec.name: tuple(spec.shape) for spec in self.specs}
+
+    def aggregate(
+        self,
+        submissions: list[tuple[str, bytes, int]],
+        *,
+        round_number: int = 0,
+    ) -> RoundResult:
+        """Aggregate one round.
+
+        :param submissions: ``(client_id, serialized_record, num_examples)`` per client.
+        :raises HandoffError: when fewer than :attr:`min_clients` records survive validation.
+        """
+
+        accepted: list[ClientUpdate] = []
+        rejected: list[tuple[str, str]] = []
+
+        for client_id, blob, num_examples in submissions:
+            try:
+                arrays = self._validated_arrays(blob)
+            except HandoffError as exc:
+                # A rejection is data, not an exception to propagate: one broken client must not end
+                # the round for everyone else.
+                logger.warning("round %s: dropping client %s (%s)", round_number, client_id, exc)
+                rejected.append((client_id, str(exc)))
+                continue
+            if num_examples <= 0:
+                rejected.append((client_id, f"num_examples must be > 0, got {num_examples}"))
+                continue
+            accepted.append(ClientUpdate(arrays=arrays, num_examples=num_examples))
+
+        if len(accepted) < self.min_clients:
+            raise HandoffError(
+                f"round {round_number} had {len(accepted)} usable client update(s), below the "
+                f"min_clients={self.min_clients} floor; refusing to publish an aggregate. "
+                f"Rejections: {rejected or 'none'}"
+            )
+
+        averaged = federated_average(list(accepted))
+        blob = self._build_global_record(averaged, round_number=round_number)
+
+        return RoundResult(
+            round=round_number,
+            blob=blob,
+            accepted=len(accepted),
+            rejected=rejected,
+            total_examples=sum(u.num_examples for u in accepted),
+        )
+
+    def _validated_arrays(self, blob: bytes) -> list[np.ndarray]:
+        """Decode one client record into arrays **in the package's declared order**.
+
+        Matching by name is the whole point; the record's own ordering is not trusted, so a client that
+        serialized in a different order still contributes correctly rather than corrupting a layer.
+        """
+        import numpy as np
+
+        record = FederatedAdapterRecord.deserialize(blob)
+        record.check_format(self.handoff)
+
+        # `tensors` and `arrays` are parallel lists (the record's own invariant, enforced in its
+        # __post_init__), so this is where the two are joined into a name-keyed view.
+        by_name = dict(zip([t.name for t in record.tensors], record.arrays, strict=True))
+        unknown = set(by_name) - set(self._expected)
+        if unknown:
+            raise HandoffError(f"record carries tensor(s) this package does not declare: {sorted(unknown)}")
+
+        arrays: list[np.ndarray] = []
+        for spec in self.specs:
+            if spec.name not in by_name:
+                raise HandoffError(f"record is missing declared tensor {spec.name!r}")
+            array = np.asarray(by_name[spec.name])
+            if tuple(array.shape) != self._expected[spec.name]:
+                raise HandoffError(
+                    f"tensor {spec.name!r} has shape {tuple(array.shape)}, package declares "
+                    f"{self._expected[spec.name]}"
+                )
+            arrays.append(array)
+        return arrays
+
+    def _build_global_record(self, arrays: list[np.ndarray], *, round_number: int) -> bytes:
+        """Serialize the aggregate through the SAME codec clients read, so the bytes round-trip."""
+        record = FederatedAdapterRecord.from_handoff(
+            self.handoff,
+            arrays,
+            base_model_id=self.base_model_id,
+            peft_method=self.peft_method,
+            round=round_number,
+            package_revision=self.package_revision,
+        )
+        return record.serialize()
+
+
+__all__ = ["FederatedGateway", "RoundResult"]
diff --git a/tools/__init__.py b/src/mobiletransformers/hub/__init__.py
similarity index 100%
rename from tools/__init__.py
rename to src/mobiletransformers/hub/__init__.py
diff --git a/src/mobiletransformers/hub/package_format.py b/src/mobiletransformers/hub/package_format.py
new file mode 100644
index 0000000..bd07bfa
--- /dev/null
+++ b/src/mobiletransformers/hub/package_format.py
@@ -0,0 +1,240 @@
+"""Hub model-package format (#14) — the on-Hub repo shape + ``mobiletransformers_manifest.json`` schema.
+
+This module OWNS the manifest field list and the package layout. A consumer (Python CLI, Android
+downloader, sample app) fetches the small manifest first, then resolves which files to pull from
+``downloadPlan`` before touching large ONNX blobs. One shared package, dual engine (native ORT + ONNX
+Runtime GenAI both read the same folder); per-tensor external initializers live flat in ``inference/``
+beside ``model.onnx``, the frozen quantized base is the immutable ``inference/frozen_base.onnx.data``.
+
+Scope boundary: the manifest *validator*, variant-selection, and cache-install semantics are owned by
+#13 (``artifacts/manifest.py``); the ``weight_handoff_map.json`` schema by #8; the per-tensor merge
+contract by #9. This module pins the schema + shape and provides ``build_manifest`` (the emit helper the
+export CLI #15 calls) and ``sanitize_repo_id`` (byte-identical to the Kotlin cache-bridge sanitizer).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_VERSION = "1.0"
+MIN_READER_VERSION = "1.0"
+ARTIFACT_FORMAT_VERSION = 1
+MANIFEST_FILENAME = "mobiletransformers_manifest.json"
+
+#: Feature groups a downloader can request; each maps to repo-relative glob patterns in ``downloadPlan``.
+FEATURE_GROUPS = ("core", "inference", "train", "rag", "genai", "checksums")
+
+#: Per-variant subdirectories.
+VARIANT_SUBDIRS = ("train", "inference", "embedding")
+
+#: Files that must exist regardless of which features are requested (validation floor).
+REQUIRED_TOP_LEVEL_FILES = (MANIFEST_FILENAME, "shared/tokenizer/tokenizer.json")
+
+_SAFE_CHARS = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-")
+
+
+def sanitize_repo_id(repo_id: str) -> str:
+    """Map an HF repo id to a filesystem-safe cache directory name.
+
+    Canonical algorithm (mirrored byte-for-byte in the Kotlin cache bridge, #13):
+      1. every ``/`` becomes ``__`` (double underscore);
+      2. every remaining char not in ``[A-Za-z0-9._-]`` becomes a single ``_``;
+      3. no trimming, no case-folding, no length cap.
+
+    Example: ``mobiletransformers/Qwen2-0.5B`` -> ``mobiletransformers__Qwen2-0.5B``.
+    """
+    out: list[str] = []
+    for ch in repo_id:
+        if ch == "/":
+            out.append("__")
+        elif ch in _SAFE_CHARS:
+            out.append(ch)
+        else:
+            out.append("_")
+    return "".join(out)
+
+
+def _download_plan_for(variant_id: str, features: tuple[str, ...]) -> dict[str, list[str]]:
+    """Build the per-variant ``{group: [glob patterns]}`` map. Groups whose feature the variant does
+    not declare are present but empty (a downloader still keys off them deterministically)."""
+    has = set(features)
+    plan: dict[str, list[str]] = {
+        "core": [
+            MANIFEST_FILENAME,
+            "shared/tokenizer/**",
+            "shared/chat_template.jinja",
+            "shared/config.json",
+            "shared/generation_config.json",
+        ],
+        "inference": [f"variants/{variant_id}/inference/**"] if "inference" in has else [],
+        "train": [f"variants/{variant_id}/train/**"] if "train" in has else [],
+        "rag": [f"variants/{variant_id}/embedding/**"] if "rag" in has else [],
+        "genai": [f"variants/{variant_id}/inference/genai_config.json"] if "genai" in has else [],
+        "checksums": [f"variants/{variant_id}/checksums.json"],
+    }
+    return plan
+
+
+def _variant_paths(package_dir: Path, variant_id: str) -> dict[str, str]:
+    """Resolve the ``paths`` map for a variant from the subdirs that actually exist on disk."""
+    paths: dict[str, str] = {"tokenizer": "shared/tokenizer"}
+    for sub in VARIANT_SUBDIRS:
+        rel = f"variants/{variant_id}/{sub}"
+        if (package_dir / rel).is_dir():
+            paths[sub] = rel
+    return paths
+
+
+def _sha256_of(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _walk_files(package_dir: Path) -> list[str]:
+    """Repo-relative POSIX paths of every file under ``package_dir`` (excluding the manifest itself)."""
+    rels: list[str] = []
+    for p in sorted(package_dir.rglob("*")):
+        if p.is_file() and p.name != MANIFEST_FILENAME:
+            rels.append(p.relative_to(package_dir).as_posix())
+    return rels
+
+
+def build_manifest(
+    package_dir: str | Path,
+    variants: list[dict[str, Any]],
+    base_model_id: str,
+    report: dict[str, Any],
+    *,
+    default_variant: str | None = None,
+    exported_at: str | None = None,
+) -> dict[str, Any]:
+    """Assemble the full ``mobiletransformers_manifest.json`` dict from the on-disk package tree.
+
+    ``variants`` — list of descriptors, each with at least ``id``, ``executionProvider``,
+    ``quantization``, ``supportedEngines``, ``abi``, ``features``, ``minimumAndroidApi``,
+    ``recommendedDeviceMemoryMb``. ``paths``/``weightHandoff``/``downloadPlan`` are computed here.
+    ``report`` — provenance (architectures, supportedTasks, selectedTask, trustRemoteCode, version pins,
+    peftMethods, quantization, mobiletransformersVersion, license, androidRuntime). Integrity
+    (``fileSizes``/``sha256``) is stream-hashed from disk. Deterministic given the same tree + inputs.
+    """
+    package_dir = Path(package_dir)
+    if not variants:
+        raise ValueError("build_manifest requires at least one variant")
+    default_variant = default_variant or variants[0]["id"]
+    variant_ids = {v["id"] for v in variants}
+    if default_variant not in variant_ids:
+        raise ValueError(f"defaultVariant {default_variant!r} not among variants {sorted(variant_ids)}")
+
+    rels = _walk_files(package_dir)
+    file_sizes = {rel: (package_dir / rel).stat().st_size for rel in rels}
+    sha256 = {rel: _sha256_of(package_dir / rel) for rel in rels}
+
+    manifest_variants: list[dict[str, Any]] = []
+    download_plan: dict[str, dict[str, list[str]]] = {}
+    for v in variants:
+        vid = v["id"]
+        features = tuple(v.get("features", ()))
+        handoff = f"variants/{vid}/inference/weight_handoff_map.json"
+        manifest_variants.append(
+            {
+                "id": vid,
+                "executionProvider": v["executionProvider"],
+                "quantization": v["quantization"],
+                "supportedEngines": list(v.get("supportedEngines", ["native"])),
+                "abi": v.get("abi"),
+                "features": list(features),
+                "minimumAndroidApi": v.get("minimumAndroidApi"),
+                "recommendedDeviceMemoryMb": v.get("recommendedDeviceMemoryMb"),
+                "weightHandoff": handoff,
+                "paths": _variant_paths(package_dir, vid),
+            }
+        )
+        download_plan[vid] = _download_plan_for(vid, features)
+
+    default_handoff = f"variants/{default_variant}/inference/weight_handoff_map.json"
+    required = [f for f in REQUIRED_TOP_LEVEL_FILES if f != MANIFEST_FILENAME]
+    required = [MANIFEST_FILENAME, *required, f"variants/{default_variant}/inference/model.onnx"]
+
+    return {
+        "schemaVersion": SCHEMA_VERSION,
+        "minReaderVersion": MIN_READER_VERSION,
+        "baseModelId": base_model_id,
+        "exportedAt": exported_at or "",
+        "mobiletransformersVersion": report.get("mobiletransformersVersion", ""),
+        "artifactFormatVersion": ARTIFACT_FORMAT_VERSION,
+        "architectures": list(report.get("architectures", [])),
+        "supportedTasks": list(report.get("supportedTasks", [])),
+        "selectedTask": report.get("selectedTask"),
+        "trustRemoteCode": bool(report.get("trustRemoteCode", False)),
+        "optimumOnnxVersion": report.get("optimumOnnxVersion"),
+        "transformersVersion": report.get("transformersVersion"),
+        "onnxRuntimeTrainingVersion": report.get("onnxRuntimeTrainingVersion"),
+        "onnxRuntimeGenAIVersion": report.get("onnxRuntimeGenAIVersion"),
+        "peftMethods": list(report.get("peftMethods", [])),
+        "quantization": list(report.get("quantization", [])),
+        # The training stage reports both of these (`export/pipeline.py`), and this field list used to
+        # drop them — every shipped package read `null` while `train/trainable_parameters.json` carried
+        # the real number. `None` on an inference-only package is correct, not a hole.
+        "trainableParameterCount": report.get("trainableParameterCount"),
+        "trainingParameterCount": report.get("trainingParameterCount"),
+        "defaultVariant": default_variant,
+        "variants": manifest_variants,
+        "downloadPlan": download_plan,
+        "requiredFiles": required,
+        "fileSizes": file_sizes,
+        "sha256": sha256,
+        "weightHandoff": default_handoff,
+        "androidRuntime": report.get(
+            "androidRuntime",
+            {"minimumAndroidApi": None, "recommendedDeviceMemoryMb": None, "requiredAbis": []},
+        ),
+        "license": report.get(
+            "license", {"framework": "Apache-2.0", "baseModelWeights": None, "noticeFile": None}
+        ),
+    }
+
+
+def write_manifest(package_dir: str | Path, manifest: dict[str, Any]) -> Path:
+    """Write the manifest deterministically (sorted keys, trailing newline) to the package root."""
+    package_dir = Path(package_dir)
+    path = package_dir / MANIFEST_FILENAME
+    path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path
+
+
+def write_variant_checksums(package_dir: str | Path, manifest: dict[str, Any]) -> list[Path]:
+    """Emit each variant's ``checksums.json`` (the subset of ``sha256`` under its subtree) so a
+    downloaded variant subtree is independently verifiable."""
+    package_dir = Path(package_dir)
+    sha = manifest["sha256"]
+    written: list[Path] = []
+    for v in manifest["variants"]:
+        vid = v["id"]
+        prefix = f"variants/{vid}/"
+        subset = {rel: digest for rel, digest in sha.items() if rel.startswith(prefix)}
+        out = package_dir / "variants" / vid / "checksums.json"
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(json.dumps(subset, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        written.append(out)
+    return written
+
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "MIN_READER_VERSION",
+    "ARTIFACT_FORMAT_VERSION",
+    "MANIFEST_FILENAME",
+    "FEATURE_GROUPS",
+    "VARIANT_SUBDIRS",
+    "REQUIRED_TOP_LEVEL_FILES",
+    "sanitize_repo_id",
+    "build_manifest",
+    "write_manifest",
+    "write_variant_checksums",
+]
diff --git a/src/mobiletransformers/hub/pull.py b/src/mobiletransformers/hub/pull.py
new file mode 100644
index 0000000..aa23788
--- /dev/null
+++ b/src/mobiletransformers/hub/pull.py
@@ -0,0 +1,178 @@
+"""Hub pull + install (#21, Python-first) — download a package and materialize it into the cache shape.
+
+``pull_package`` fetches the manifest first, selects a variant, downloads only the files its
+``downloadPlan`` names (sha256-verified), and ``install_package`` materializes the selected variant into
+the exact ``<cacheDir>/<sanitizedRepoId>/{train,inference,embedding,tokenizer}`` layout `LLMRepository`
+probes (the Python mirror of #13's Kotlin ``ModelPackageInstaller``). The Android downloader is a
+separate device leg (deferred).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.exceptions import HubError
+from mobiletransformers.hub.package_format import MANIFEST_FILENAME, VARIANT_SUBDIRS, sanitize_repo_id
+from mobiletransformers.hub.variant_select import (
+    Constraints,
+    default_desktop_constraints,
+    select_variant,
+)
+
+Downloader = Callable[..., str]
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _default_downloader(**kwargs: object) -> str:
+    from huggingface_hub import snapshot_download  # core dep, imported lazily to keep import light
+
+    return snapshot_download(**kwargs)  # type: ignore[arg-type]
+
+
+def _allow_patterns(manifest: MobileTransformersManifest, variant_id: str, features: set[str]) -> list[str]:
+    plan = manifest.to_dict().get("downloadPlan", {}).get(variant_id, {})
+    groups = set(features) | {"core", "checksums"}
+    patterns: list[str] = []
+    for group in sorted(groups):
+        patterns.extend(plan.get(group, []))
+    return patterns
+
+
+def pull_package(
+    repo_id: str,
+    *,
+    revision: str = "main",
+    variant: str | None = None,
+    features: tuple[str, ...] = ("inference",),
+    token: str | None = None,
+    dest: str | Path | None = None,
+    constraints: Constraints | None = None,
+    downloader: Downloader | None = None,
+) -> Path:
+    """Download the selected variant's files for ``features`` into a staging dir; verify sha256.
+
+    ``downloader`` is injectable (defaults to ``huggingface_hub.snapshot_download``) so tests/offline
+    runs can serve the fixture. Returns the staging directory (a full package subtree).
+    """
+    downloader = downloader or _default_downloader
+    staging = Path(dest) if dest is not None else Path(f"./.mt-pull/{sanitize_repo_id(repo_id)}")
+    staging.mkdir(parents=True, exist_ok=True)
+
+    # 1. Manifest first.
+    downloader(
+        repo_id=repo_id,
+        revision=revision,
+        token=token,
+        local_dir=str(staging),
+        allow_patterns=[MANIFEST_FILENAME],
+    )
+    manifest_path = staging / MANIFEST_FILENAME
+    if not manifest_path.is_file():
+        raise HubError(f"manifest {MANIFEST_FILENAME} not present after pull of {repo_id!r}")
+    manifest = MobileTransformersManifest.load(manifest_path)
+
+    # 2. Select variant.
+    feature_set = set(features) | {"core", "inference"}
+    variant_id = variant or select_variant(manifest, constraints or default_desktop_constraints())
+
+    # 3+4. Download the file set for the requested features.
+    patterns = _allow_patterns(manifest, variant_id, feature_set)
+    downloader(
+        repo_id=repo_id,
+        revision=revision,
+        token=token,
+        local_dir=str(staging),
+        allow_patterns=patterns,
+    )
+
+    # 5. Verify sha256 of every downloaded file we have a digest for.
+    sha_map: dict[str, str] = manifest.to_dict().get("sha256", {})
+    for rel, expected in sha_map.items():
+        f = staging / rel
+        if f.is_file() and _sha256(f) != expected:
+            raise HubError(f"sha256 mismatch for {rel} in {repo_id!r} (corrupt download)")
+    return staging
+
+
+def install_package(
+    staging_dir: str | Path, cache_root: str | Path, repo_id: str, *, variant: str | None = None
+) -> Path:
+    """Materialize a staged package into ``<cache_root>/<sanitizedRepoId>/`` (the LLMRepository shape).
+
+    Atomic: builds under ``<cache_root>/.partial/<sanitized>`` then ``os.replace``. Flattens
+    ``shared/tokenizer`` -> ``tokenizer/`` and ``shared/chat_template.jinja`` alongside it. Validates the
+    manifest before publishing.
+    """
+    staging_dir = Path(staging_dir)
+    cache_root = Path(cache_root)
+    manifest = MobileTransformersManifest.load(staging_dir / MANIFEST_FILENAME)
+    variant_id = variant or manifest.default_variant
+
+    # A feature-partial pull only downloaded ONE variant's files, so the whole-package validate()
+    # (which checks every variant's handoff) is inappropriate here — check just the selected variant.
+    selected = next((v for v in manifest.variants if v.get("id") == variant_id), None)
+    if selected is None:
+        raise HubError(f"variant {variant_id!r} not in manifest for install")
+    handoff_rel = selected.get("weightHandoff")
+    if handoff_rel and not (staging_dir / handoff_rel).is_file():
+        raise HubError(f"selected variant {variant_id!r} weightHandoff missing in staging: {handoff_rel}")
+
+    sanitized = sanitize_repo_id(repo_id)
+    partial = cache_root / ".partial" / sanitized
+    if partial.exists():
+        shutil.rmtree(partial)
+    partial.mkdir(parents=True, exist_ok=True)
+
+    variant_root = staging_dir / "variants" / variant_id
+    for sub in VARIANT_SUBDIRS:
+        src = variant_root / sub
+        if src.is_dir():
+            shutil.copytree(src, partial / sub, dirs_exist_ok=True)
+    # Flatten shared/ tokenizer + chat template into the conventional cache layout.
+    shared_tok = staging_dir / "shared" / "tokenizer"
+    if shared_tok.is_dir():
+        shutil.copytree(shared_tok, partial / "tokenizer", dirs_exist_ok=True)
+    chat_template = staging_dir / "shared" / "chat_template.jinja"
+    if chat_template.is_file():
+        shutil.copy2(chat_template, partial / "tokenizer" / "chat_template.jinja")
+    # Manifest + per-variant checksums at the cache root.
+    shutil.copy2(staging_dir / MANIFEST_FILENAME, partial / MANIFEST_FILENAME)
+    checksums = variant_root / "checksums.json"
+    if checksums.is_file():
+        shutil.copy2(checksums, partial / "checksums.json")
+
+    # #21 crash safety (mirrors the Kotlin ModelPackageInstaller): move the OLD install aside, put the
+    # new one in place, and only then delete the old. Deleting first opened a window where a crash or
+    # a failed replace left no package at all — including any locally trained checkpoint.
+    target = cache_root / sanitized
+    retired = cache_root / f".retired-{sanitized}-{os.getpid()}"
+    had_previous = target.exists()
+    if had_previous:
+        if retired.exists():
+            shutil.rmtree(retired)
+        os.replace(target, retired)
+    try:
+        os.replace(partial, target)
+    except OSError:
+        # Roll the previous install back so a failed update is a no-op, not data loss.
+        if had_previous:
+            os.replace(retired, target)
+        raise
+    if had_previous:
+        shutil.rmtree(retired, ignore_errors=True)
+    return target
+
+
+__all__ = ["pull_package", "install_package"]
diff --git a/src/mobiletransformers/hub/variant_select.py b/src/mobiletransformers/hub/variant_select.py
new file mode 100644
index 0000000..6f81d10
--- /dev/null
+++ b/src/mobiletransformers/hub/variant_select.py
@@ -0,0 +1,116 @@
+"""Constraint-based variant selection for hub pull (#21).
+
+Layers the #21 download-time policy — soft quantization preference, download-size tie-break, and a
+storage-budget ceiling — over #13's hard-filter :meth:`MobileTransformersManifest.select_variant`
+(ABI / engine / features / memory). The algorithm is deterministic and mirrored by the Android
+`VariantSelector.kt` (device leg, deferred).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.exceptions import NoCompatibleVariant
+from mobiletransformers.hub.package_format import FEATURE_GROUPS
+
+#: Fraction of free storage a package may occupy before selection fails closed.
+_STORAGE_BUDGET_FRACTION = 0.9
+
+
+@dataclass(frozen=True)
+class Constraints:
+    """Device/desktop capabilities + requests that drive variant selection."""
+
+    abi: tuple[str, ...] = ("arm64-v8a",)
+    preferred_quantization: str = "int4"
+    engine: str = "native"
+    requested_features: tuple[str, ...] = ("core", "inference")
+    available_storage_bytes: int | None = None
+    device_memory_mb: int | None = None
+    extra_abis_any: bool = False  # if True, an abi=null variant always matches (desktop pull)
+
+
+def default_desktop_constraints() -> Constraints:
+    """Permissive constraints for a desktop `mobiletransformers pull` (any ABI, no memory ceiling)."""
+    return Constraints(abi=("arm64-v8a", "x86_64"), available_storage_bytes=None, device_memory_mb=None)
+
+
+def _variant_download_bytes(manifest: MobileTransformersManifest, variant_id: str, features: set[str]) -> int:
+    """Sum ``fileSizes`` over the files the variant's ``downloadPlan`` would pull for ``features``."""
+    data = manifest.to_dict()
+    file_sizes: dict[str, int] = data.get("fileSizes", {})
+    plan = data.get("downloadPlan", {}).get(variant_id, {})
+    groups = set(features) | {"core", "checksums"}
+    total = 0
+    seen: set[str] = set()
+    for group in groups:
+        for pattern in plan.get(group, []):
+            prefix = pattern[:-3] if pattern.endswith("/**") else None
+            for rel, size in file_sizes.items():
+                if rel in seen:
+                    continue
+                if (prefix is not None and rel.startswith(prefix)) or rel == pattern:
+                    seen.add(rel)
+                    total += size
+    return total
+
+
+def select_variant(manifest: MobileTransformersManifest, constraints: Constraints) -> str:
+    """Return the chosen variant id, or raise ``NoCompatibleVariant``.
+
+    Hard filters (ABI / engine / features / memory) come from #13's ``select_variant``; among the
+    survivors this prefers ``preferred_quantization``, then smallest download size, then the
+    ``defaultVariant``. Fails closed if the estimated download exceeds
+    ``available_storage_bytes * _STORAGE_BUDGET_FRACTION``.
+    """
+    features = set(constraints.requested_features) | {"core", "inference"}
+    # Reuse #13's hard-filter selector to get *a* compatible variant + prove compatibility exists.
+    #: (#13 raises NoCompatibleVariant if nothing passes the hard filters.)
+    manifest.select_variant(
+        abis=list(constraints.abi),
+        total_mem_mb=constraints.device_memory_mb,
+        requested_features=list(features),
+        requested_engine=constraints.engine,
+    )
+
+    # Re-derive the full candidate set here so we can apply the soft preference + size tie-break.
+    abi_set = set(constraints.abi)
+    candidates = [
+        v
+        for v in manifest.variants
+        if (v.get("abi") is None or set(v.get("abi") or []) & abi_set)
+        and features.issubset(set(v.get("features", ())))
+        and constraints.engine in set(v.get("supportedEngines", ()))
+        and (
+            constraints.device_memory_mb is None
+            or v.get("recommendedDeviceMemoryMb") is None
+            or v["recommendedDeviceMemoryMb"] <= constraints.device_memory_mb
+        )
+    ]
+    if not candidates:  # pragma: no cover - #13 selector already guarantees non-empty
+        raise NoCompatibleVariant("no compatible variant after hard filters")
+
+    def _key(v: dict) -> tuple[int, int, int, str]:
+        return (
+            0 if v.get("quantization") == constraints.preferred_quantization else 1,
+            _variant_download_bytes(manifest, v["id"], features),
+            0 if v["id"] == manifest.default_variant else 1,
+            str(v["id"]),
+        )
+
+    chosen = min(candidates, key=_key)
+    chosen_id = chosen["id"]
+
+    if constraints.available_storage_bytes is not None:
+        need = _variant_download_bytes(manifest, chosen_id, features)
+        budget = int(constraints.available_storage_bytes * _STORAGE_BUDGET_FRACTION)
+        if need > budget:
+            raise NoCompatibleVariant(
+                f"variant {chosen_id!r} needs ~{need} bytes but budget is {budget} "
+                f"({_STORAGE_BUDGET_FRACTION:.0%} of {constraints.available_storage_bytes})"
+            )
+    return chosen_id
+
+
+__all__ = ["Constraints", "default_desktop_constraints", "select_variant", "FEATURE_GROUPS"]
diff --git a/trainer/__init__.py b/src/mobiletransformers/inference/__init__.py
similarity index 100%
rename from trainer/__init__.py
rename to src/mobiletransformers/inference/__init__.py
diff --git a/inference/builder.py b/src/mobiletransformers/inference/builder.py
similarity index 65%
rename from inference/builder.py
rename to src/mobiletransformers/inference/builder.py
index a2b73fd..eff151e 100644
--- a/inference/builder.py
+++ b/src/mobiletransformers/inference/builder.py
@@ -1,3 +1,6 @@
+# DECOMPOSE(#5): split into inference/graph/<arch>.py per-architecture builders resolved via the
+# architecture registry (#6); the Gemma/Gemma2 inference-model branch becomes registry entries (also
+# unblocks Gemma-3 in #37). ~200 KB monolith — largest file in the repo.
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation.  All rights reserved.
 # Licensed under the MIT License.  See License.txt in the project root for
@@ -9,47 +12,89 @@
 This uses optimizations prepared by ONNX GenAI framework and exposes the needed adapters for on-device loading of newly updated parameters.
 """
 
-from onnx import helper, numpy_helper, TensorProto, external_data_helper, save_model
-from onnx.external_data_helper import convert_model_to_external_data
-from onnxruntime.quantization.matmul_4bits_quantizer import MatMul4BitsQuantizer, QuantFormat
-from onnxruntime.quantization import QuantFormat, QuantType, quantize_dynamic, quantize_static
-from onnxruntime.quantization.onnx_quantizer import ONNXQuantizer, QuantizationMode
-from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, GenerationConfig
-import numpy as np
-import torch
+from onnx import TensorProto, external_data_helper, helper, numpy_helper, save_model
 
+# ORT renamed this module/class when the quantizer was generalised to N-bit, deleting the old
+# names outright. Resolved at call time so BOTH ORT lines this repo pins keep working; this one
+# import is what made the whole file unimportable, blocking Migration S6. See quantizer_compat.
+from mobiletransformers.export.quantizer_compat import load_weight_only_matmul_quantizer
+
+MatMul4BitsQuantizer = load_weight_only_matmul_quantizer()
 import argparse
 import gc
 import json
 import os
 import textwrap
-import yaml
 
+import numpy as np
+import torch
+import yaml
 from dotenv import load_dotenv
+from onnxruntime.quantization import QuantFormat, QuantType, quantize_dynamic
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+from mobiletransformers.config.settings import get_settings
+
 load_dotenv()
 
 TRAIN_CONFIG = "TRAIN_BUILDER"
 INFERENCE_CONFIG = "INFERENCE_BUILDER"
 
+
 class Model:
-    def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options): 
-        self.context_length = config.seq_length if hasattr(config, "seq_length") else config.max_position_embeddings
-        self.original_context_length = config.original_max_position_embeddings if hasattr(config, "original_max_position_embeddings") else config.rope_scaling["original_max_position_embeddings"] if hasattr(config, "rope_scaling") and hasattr(config.rope_scaling, "original_max_position_embeddings") else self.context_length
-        self.window_size = config.sliding_window if hasattr(config, "sliding_window") else -1  # default is -1 in GroupQueryAttention kernel
-        self.intermediate_size = config.ffn_hidden_size if hasattr(config, "ffn_hidden_size") else config.intermediate_size
+    def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
+        self.context_length = (
+            config.seq_length if hasattr(config, "seq_length") else config.max_position_embeddings
+        )
+        self.original_context_length = (
+            config.original_max_position_embeddings
+            if hasattr(config, "original_max_position_embeddings")
+            else config.rope_scaling["original_max_position_embeddings"]
+            if hasattr(config, "rope_scaling")
+            and hasattr(config.rope_scaling, "original_max_position_embeddings")
+            else self.context_length
+        )
+        self.window_size = (
+            config.sliding_window if hasattr(config, "sliding_window") else -1
+        )  # default is -1 in GroupQueryAttention kernel
+        self.intermediate_size = (
+            config.ffn_hidden_size if hasattr(config, "ffn_hidden_size") else config.intermediate_size
+        )
         self.hidden_size = config.hidden_size
-        self.num_kv_heads = config.num_key_value_heads if hasattr(config, "num_key_value_heads") else config.multi_query_group_num if hasattr(config, "multi_query_group_num") else config.num_attention_heads
+        self.num_kv_heads = (
+            config.num_key_value_heads
+            if hasattr(config, "num_key_value_heads")
+            else config.multi_query_group_num
+            if hasattr(config, "multi_query_group_num")
+            else config.num_attention_heads
+        )
         self.num_attn_heads = config.num_attention_heads
-        self.head_size = config.head_dim if hasattr(config, "head_dim") else config.hidden_size // config.num_attention_heads
-        self.num_layers = int(extra_options["num_hidden_layers"]) if "num_hidden_layers" in extra_options else config.num_hidden_layers if hasattr(config, "num_hidden_layers") else config.num_layers
+        self.head_size = (
+            config.head_dim
+            if hasattr(config, "head_dim")
+            else config.hidden_size // config.num_attention_heads
+        )
+        self.num_layers = (
+            int(extra_options["num_hidden_layers"])
+            if "num_hidden_layers" in extra_options
+            else config.num_hidden_layers
+            if hasattr(config, "num_hidden_layers")
+            else config.num_layers
+        )
         self.vocab_size = config.vocab_size
-        self.activation = config.hidden_activation if hasattr(config, "hidden_activation") and config.hidden_activation is not None else config.hidden_act
+        self.activation = (
+            config.hidden_activation
+            if hasattr(config, "hidden_activation") and config.hidden_activation is not None
+            else config.hidden_act
+        )
 
         self.model_name_or_path = config._name_or_path
         self.model_type = config.architectures[0]
-        self.io_dtype = io_dtype      # {'fp16', 'fp32'}
+        self.io_dtype = io_dtype  # {'fp16', 'fp32'}
         self.onnx_dtype = onnx_dtype  # {"int4", "fp16", "fp32"}
-        self.quant_type = config.quantization_config["quant_method"] if hasattr(config, "quantization_config") else None
+        self.quant_type = (
+            config.quantization_config["quant_method"] if hasattr(config, "quantization_config") else None
+        )
         self.adapter_path = extra_options.get("adapter_path", None)
 
         self.cache_dir = cache_dir
@@ -69,7 +114,7 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         self.ep_attrs = {
             "cpu": {},
             "cuda": {
-                "enable_cuda_graph": enable_cuda_graph,        # "1" if the the model is able to enable cuda graph, "0" otherwise
+                "enable_cuda_graph": enable_cuda_graph,  # "1" if the the model is able to enable cuda graph, "0" otherwise
             },
             "rocm": {
                 "tunable_op_enable": "1",
@@ -82,20 +127,34 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         # Map input names to their types and shapes
         self.input_names = ["input_ids", "attention_mask", "position_ids"]
         self.input_types = {
-            "input_ids": TensorProto.INT64,                                                                      # For standard models
-            "attention_mask": TensorProto.INT64,                                                                 # For standard models
-            "position_ids": TensorProto.INT64,                                                                   # For standard models
-            "inputs_embeds": self.io_dtype,                                                                      # For standard models where you want to remove the embedding layer from the model (note that `inputs_embeds` is written this way to match Hugging Face format)
-            "past_key_values.key": self.io_dtype,                                                                # For standard models (note that `past_key_values.key` is written this way to match Hugging Face format)
-            "past_key_values.value": self.io_dtype,                                                              # For standard models (note that `past_key_values.value` is written this way to match Hugging Face format)
+            "input_ids": TensorProto.INT64,  # For standard models
+            "attention_mask": TensorProto.INT64,  # For standard models
+            "position_ids": TensorProto.INT64,  # For standard models
+            "inputs_embeds": self.io_dtype,  # For standard models where you want to remove the embedding layer from the model (note that `inputs_embeds` is written this way to match Hugging Face format)
+            "past_key_values.key": self.io_dtype,  # For standard models (note that `past_key_values.key` is written this way to match Hugging Face format)
+            "past_key_values.value": self.io_dtype,  # For standard models (note that `past_key_values.value` is written this way to match Hugging Face format)
         }
         self.input_shapes = {
-            "input_ids": ["batch_size", "sequence_length"],                                                      # For standard models
-            "attention_mask": ["batch_size", "total_sequence_length"],                                           # For standard models
-            "position_ids": ["batch_size", "sequence_length"],                                                   # For standard models
-            "inputs_embeds": ["batch_size", "sequence_length", self.hidden_size],                                # For standard models where you want to remove the embedding layer from the model (note that `inputs_embeds` is written this way to match Hugging Face format)
-            "past_key_values.key": ["batch_size", self.num_kv_heads, "past_sequence_length", self.head_size],    # For standard models (note that `past_key_values.key` is written this way to match Hugging Face format)
-            "past_key_values.value": ["batch_size", self.num_kv_heads, "past_sequence_length", self.head_size],  # For standard models (note that `past_key_values.value` is written this way to match Hugging Face format)
+            "input_ids": ["batch_size", "sequence_length"],  # For standard models
+            "attention_mask": ["batch_size", "total_sequence_length"],  # For standard models
+            "position_ids": ["batch_size", "sequence_length"],  # For standard models
+            "inputs_embeds": [
+                "batch_size",
+                "sequence_length",
+                self.hidden_size,
+            ],  # For standard models where you want to remove the embedding layer from the model (note that `inputs_embeds` is written this way to match Hugging Face format)
+            "past_key_values.key": [
+                "batch_size",
+                self.num_kv_heads,
+                "past_sequence_length",
+                self.head_size,
+            ],  # For standard models (note that `past_key_values.key` is written this way to match Hugging Face format)
+            "past_key_values.value": [
+                "batch_size",
+                self.num_kv_heads,
+                "past_sequence_length",
+                self.head_size,
+            ],  # For standard models (note that `past_key_values.value` is written this way to match Hugging Face format)
         }
         self.exclude_embeds = "exclude_embeds" in extra_options
         if self.exclude_embeds:
@@ -104,16 +163,30 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         # Map output names to their types and shapes
         self.output_names = ["logits"]
         self.output_types = {
-            "hidden_states": self.io_dtype,                                                                      # For standard models where you want to remove the language modeling head from the model (note that `hidden_states` is written this way to match Hugging Face format)
-            "logits": self.io_dtype,                                                                             # For standard models
-            "present.key": self.io_dtype,                                                                        # For standard models (note that `present.key` is written this way to match Hugging Face format)
-            "present.value": self.io_dtype,                                                                      # For standard models (note that `present.value` is written this way to match Hugging Face format)
+            "hidden_states": self.io_dtype,  # For standard models where you want to remove the language modeling head from the model (note that `hidden_states` is written this way to match Hugging Face format)
+            "logits": self.io_dtype,  # For standard models
+            "present.key": self.io_dtype,  # For standard models (note that `present.key` is written this way to match Hugging Face format)
+            "present.value": self.io_dtype,  # For standard models (note that `present.value` is written this way to match Hugging Face format)
         }
         self.output_shapes = {
-            "hidden_states": ["batch_size", "sequence_length", self.hidden_size],                                # For standard models where you want to remove the language modeling head from the model (note that `hidden_states` is written this way to match Hugging Face format)
-            "logits": ["batch_size", "sequence_length", self.vocab_size],                                        # For standard models
-            "present.key": ["batch_size", self.num_kv_heads, "total_sequence_length", self.head_size],           # For standard models (note that `present.key` is written this way to match Hugging Face format)
-            "present.value": ["batch_size", self.num_kv_heads, "total_sequence_length", self.head_size],         # For standard models (note that `present.value` is written this way to match Hugging Face format)
+            "hidden_states": [
+                "batch_size",
+                "sequence_length",
+                self.hidden_size,
+            ],  # For standard models where you want to remove the language modeling head from the model (note that `hidden_states` is written this way to match Hugging Face format)
+            "logits": ["batch_size", "sequence_length", self.vocab_size],  # For standard models
+            "present.key": [
+                "batch_size",
+                self.num_kv_heads,
+                "total_sequence_length",
+                self.head_size,
+            ],  # For standard models (note that `present.key` is written this way to match Hugging Face format)
+            "present.value": [
+                "batch_size",
+                self.num_kv_heads,
+                "total_sequence_length",
+                self.head_size,
+            ],  # For standard models (note that `present.value` is written this way to match Hugging Face format)
         }
         self.exclude_lm_head = "exclude_lm_head" in extra_options
         if self.exclude_lm_head:
@@ -143,56 +216,64 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         # Mask-specific variables
         # TODO: Reconcile differences between `seqlens_k` and `key_total_seq_lens` in the GroupQueryAttention and SparseAttention implementations. Ideally the same subgraph can be shared for both.
         self.mask_attrs = {
-            "mask_name": "",            # Name of node that outputs 4D causal attention mask (used as add_qk in MultiHeadAttention)
-            "seqlens_k": "",            # Sum of each row in attention mask - 1 (used as input to GroupQueryAttention)
-            "total_seq_len": "",        # Size of total sequence length in attention mask (used as input to GroupQueryAttention and SparseAttention)
-            "block_row_indices": "",    # Row indices of CSR format of block mask (used as input to SparseAttention)
-            "block_col_indices": "",    # Col indices of CSR format of block mask (used as input to SparseAttention)
-            "key_total_seq_lens": "",   # Sum of each row in attention mask (used as input to SparseAttention)
+            "mask_name": "",  # Name of node that outputs 4D causal attention mask (used as add_qk in MultiHeadAttention)
+            "seqlens_k": "",  # Sum of each row in attention mask - 1 (used as input to GroupQueryAttention)
+            "total_seq_len": "",  # Size of total sequence length in attention mask (used as input to GroupQueryAttention and SparseAttention)
+            "block_row_indices": "",  # Row indices of CSR format of block mask (used as input to SparseAttention)
+            "block_col_indices": "",  # Col indices of CSR format of block mask (used as input to SparseAttention)
+            "key_total_seq_lens": "",  # Sum of each row in attention mask (used as input to SparseAttention)
         }
 
         # Embedding-specific variables
         self.embed_attrs = {
-            "scale": 1,                 # Scale value to multiply output of Embedding layer by
+            "scale": 1,  # Scale value to multiply output of Embedding layer by
         }
 
         # LayerNorm-specific variables
         epsilon = config.rms_norm_eps if hasattr(config, "rms_norm_eps") else 1e-06
         self.layernorm_attrs = {
-            "simple": True,             # Use SimplifiedLayerNorm/SkipSimplifiedLayerNorm vs. LayerNorm/SkipLayerNorm
-            "first_layernorm": True,    # 1st LayerNorm = LayerNorm, then SkipLayerNorm for all subsequent LayerNorms
-            "last_layernorm": False,    # Last LayerNorm = SkipLayerNorm with only output 0 (no output 3)
-            "root_input": "",           # Root input from parent node for LayerNorm and SkipLayerNorm
-            "skip_input": "",           # Skip input from parent node for SkipLayerNorm
-            "output_0": "",             # Output 0 for LayerNorm and SkipLayerNorm
-            "output_3": "",             # Output 3 for SkipLayerNorm
-            "add_offset": 0,            # Offset value for LayerNorm weight
-            "epsilon": epsilon,         # Epsilon value to avoid `sqrt(0)` in LayerNorm
+            "simple": True,  # Use SimplifiedLayerNorm/SkipSimplifiedLayerNorm vs. LayerNorm/SkipLayerNorm
+            "first_layernorm": True,  # 1st LayerNorm = LayerNorm, then SkipLayerNorm for all subsequent LayerNorms
+            "last_layernorm": False,  # Last LayerNorm = SkipLayerNorm with only output 0 (no output 3)
+            "root_input": "",  # Root input from parent node for LayerNorm and SkipLayerNorm
+            "skip_input": "",  # Skip input from parent node for SkipLayerNorm
+            "output_0": "",  # Output 0 for LayerNorm and SkipLayerNorm
+            "output_3": "",  # Output 3 for SkipLayerNorm
+            "add_offset": 0,  # Offset value for LayerNorm weight
+            "epsilon": epsilon,  # Epsilon value to avoid `sqrt(0)` in LayerNorm
         }
 
         # MatMul-specific variables
         is_lora = hasattr(config, "peft_type") and config.peft_type == "LORA"
         self.matmul_attrs = {
-            "use_lora": is_lora,        # Use LoRA/QLoRA format
+            "use_lora": is_lora,  # Use LoRA/QLoRA format
         }
 
         # RotaryEmbedding-specific variables
         position_scale = config.rope_position_scale if hasattr(config, "rope_position_scale") else 1
-        partial_rotary_factor = config.partial_rotary_factor if hasattr(config, "partial_rotary_factor") else 1.0
-        rope_theta = config.rope_theta if hasattr(config, "rope_theta") else config.rope_embedding_base if hasattr(config, "rope_embedding_base") else 10000
+        partial_rotary_factor = (
+            config.partial_rotary_factor if hasattr(config, "partial_rotary_factor") else 1.0
+        )
+        rope_theta = (
+            config.rope_theta
+            if hasattr(config, "rope_theta")
+            else config.rope_embedding_base
+            if hasattr(config, "rope_embedding_base")
+            else 10000
+        )
         self.rotemb_attrs = {
-            "create_rotary_embedding_caches": True,          # Create cos/sin caches for rotary embeddings
-            "cache_length": self.context_length,             # Cache length to use when creating cos/sin caches for rotary embeddings
-            "theta": rope_theta,                             # Base value if calculating cos/sin caches from scratch
+            "create_rotary_embedding_caches": True,  # Create cos/sin caches for rotary embeddings
+            "cache_length": self.context_length,  # Cache length to use when creating cos/sin caches for rotary embeddings
+            "theta": rope_theta,  # Base value if calculating cos/sin caches from scratch
             "partial_rotary_factor": partial_rotary_factor,  # Factor for partial rotary embeddings
-            "interleaved": 0,                                # Interleave the rotary embeddings (e.g. [0, 0, 0, 1, 1, 1] to [0, 1, 0, 1, 0, 1], RotaryEmbedding kernel expects a default value of 0)
-            "num_heads": 0,                                  # For partial rotary embeddings (RotaryEmbedding kernel expects a default value of 0)
-            "rotary_embedding_dim": 0,                       # For partial rotary embeddings (RotaryEmbedding kernel expects a default value of 0)
-            "rescale_factors": 1,                            # Rescale factors when calculating `inv_freq` in rotary embeddings
-            "t_dtype": torch.int64,                          # Torch dtype when calculating `t` in rotary embeddings
-            "position_scale": position_scale,                # Scale value when calculating `t` in rotary embeddings
-            "mscale": 1,                                     # Magnitude scaling factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
-            "mscale_policy": "",                             # Magnitude scaling policy when scaling `emb.cos()/emb.sin()` in rotary embeddings
+            "interleaved": 0,  # Interleave the rotary embeddings (e.g. [0, 0, 0, 1, 1, 1] to [0, 1, 0, 1, 0, 1], RotaryEmbedding kernel expects a default value of 0)
+            "num_heads": 0,  # For partial rotary embeddings (RotaryEmbedding kernel expects a default value of 0)
+            "rotary_embedding_dim": 0,  # For partial rotary embeddings (RotaryEmbedding kernel expects a default value of 0)
+            "rescale_factors": 1,  # Rescale factors when calculating `inv_freq` in rotary embeddings
+            "t_dtype": torch.int64,  # Torch dtype when calculating `t` in rotary embeddings
+            "position_scale": position_scale,  # Scale value when calculating `t` in rotary embeddings
+            "mscale": 1,  # Magnitude scaling factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
+            "mscale_policy": "",  # Magnitude scaling policy when scaling `emb.cos()/emb.sin()` in rotary embeddings
         }
         if hasattr(config, "rope_scaling") and config.rope_scaling is not None:
             if "short_factor" in config.rope_scaling:
@@ -201,54 +282,88 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
                 short_factor = torch.tensor(config.rope_scaling["short_factor"], dtype=torch.float32)
                 long_factor = torch.tensor(config.rope_scaling["long_factor"], dtype=torch.float32)
 
-                short_mscale = config.rope_scaling["short_mscale"] if "short_mscale" in config.rope_scaling else 0
-                long_mscale = config.rope_scaling["long_mscale"] if "long_mscale" in config.rope_scaling else 0
-                short_mscale = short_mscale if short_mscale > 0 else self.make_mscale(self.context_length / self.original_context_length)
-                long_mscale = long_mscale if long_mscale > 0 else self.make_mscale(self.context_length / self.original_context_length)
+                short_mscale = (
+                    config.rope_scaling["short_mscale"] if "short_mscale" in config.rope_scaling else 0
+                )
+                long_mscale = (
+                    config.rope_scaling["long_mscale"] if "long_mscale" in config.rope_scaling else 0
+                )
+                short_mscale = (
+                    short_mscale
+                    if short_mscale > 0
+                    else self.make_mscale(self.context_length / self.original_context_length)
+                )
+                long_mscale = (
+                    long_mscale
+                    if long_mscale > 0
+                    else self.make_mscale(self.context_length / self.original_context_length)
+                )
 
                 self.rotemb_attrs["multi_cache"] = {
-                    "short_factor": short_factor,                # Short factor when calculating `inv_freq` in rotary embeddings
-                    "long_factor": long_factor,                  # Long factor when calculating `inv_freq` in rotary embeddings
-                    "short_mscale": short_mscale,                # Magnitude scaling for short factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
-                    "long_mscale": long_mscale,                  # Magnitude scaling for long factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
+                    "short_factor": short_factor,  # Short factor when calculating `inv_freq` in rotary embeddings
+                    "long_factor": long_factor,  # Long factor when calculating `inv_freq` in rotary embeddings
+                    "short_mscale": short_mscale,  # Magnitude scaling for short factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
+                    "long_mscale": long_mscale,  # Magnitude scaling for long factor when scaling `emb.cos()/emb.sin()` in rotary embeddings
                 }
             elif "low_freq_factor" in config.rope_scaling:
                 # For models that rescale `inv_freq` using `low_freq_factor` and `high_freq_factor` (e.g. LLaMA-3.1)
                 factor = config.rope_scaling["factor"] if "factor" in config.rope_scaling else 0
-                low_freq_factor = config.rope_scaling["low_freq_factor"] if "low_freq_factor" in config.rope_scaling else 0
-                high_freq_factor = config.rope_scaling["high_freq_factor"] if "high_freq_factor" in config.rope_scaling else 0
+                low_freq_factor = (
+                    config.rope_scaling["low_freq_factor"] if "low_freq_factor" in config.rope_scaling else 0
+                )
+                high_freq_factor = (
+                    config.rope_scaling["high_freq_factor"]
+                    if "high_freq_factor" in config.rope_scaling
+                    else 0
+                )
                 self.rotemb_attrs["rescale_inv_freq"] = {
-                    "factor": factor,                            # Scale factor when calculating `new_freq` in rotary embeddings
-                    "low_freq_factor": low_freq_factor,          # Low freq factor when calculating `low_freq_wavelen` in rotary embeddings
-                    "high_freq_factor": high_freq_factor,        # High freq factor when calculating `high_freq_wavelen` in rotary embeddings
+                    "factor": factor,  # Scale factor when calculating `new_freq` in rotary embeddings
+                    "low_freq_factor": low_freq_factor,  # Low freq factor when calculating `low_freq_wavelen` in rotary embeddings
+                    "high_freq_factor": high_freq_factor,  # High freq factor when calculating `high_freq_wavelen` in rotary embeddings
                 }
 
         # Attention-specific variables (MHA, GQA, GQA + Rot.Emb., etc.)
-        softcap = config.attn_logit_softcapping if hasattr(config, "attn_logit_softcapping") else 0.0  # default is 0.0 in GroupQueryAttention kernel
+        softcap = (
+            config.attn_logit_softcapping if hasattr(config, "attn_logit_softcapping") else 0.0
+        )  # default is 0.0 in GroupQueryAttention kernel
 
         # Block-sparse attention-specific variables
         sparse_block_size = config.blocksparse_block_size if hasattr(config, "blocksparse_block_size") else 0
-        kernel_block_size = config.blocksparse_triton_kernel_block_size if hasattr(config, "blocksparse_triton_kernel_block_size") else 0
-        local_blocks = config.blocksparse_num_local_blocks if hasattr(config, "blocksparse_num_local_blocks") else 0
-        vert_block_stride = config.blocksparse_vert_stride if hasattr(config, "blocksparse_vert_stride") else 0
-        homo_head = config.blocksparse_homo_head_pattern if hasattr(config, "blocksparse_homo_head_pattern") else False
+        kernel_block_size = (
+            config.blocksparse_triton_kernel_block_size
+            if hasattr(config, "blocksparse_triton_kernel_block_size")
+            else 0
+        )
+        local_blocks = (
+            config.blocksparse_num_local_blocks if hasattr(config, "blocksparse_num_local_blocks") else 0
+        )
+        vert_block_stride = (
+            config.blocksparse_vert_stride if hasattr(config, "blocksparse_vert_stride") else 0
+        )
+        homo_head = (
+            config.blocksparse_homo_head_pattern
+            if hasattr(config, "blocksparse_homo_head_pattern")
+            else False
+        )
         self.attention_attrs = {
-            "q_path": "",                                    # Q path to attention
-            "k_path": "",                                    # K path to attention
-            "v_path": "",                                    # V path to attention
-            "op_type": "MultiHeadAttention",                 # Attention op to use
-            "scale": 1 / np.sqrt(self.head_size),            # Scale value after calculating Q x K' in attention
-            "softcap": softcap,                              # Softcap value to prevent values from exploding in attention
-            "use_rotemb_in_attn": False,                     # Use rotary embeddings within attention (instead of a separate RotaryEmbedding op)
-            "force_unpacked_matmul": extra_options["force_unpacked_matmul"],                   # Force the matmul of attention to be unpacked (for importing LoRA merged adapters)
-            "use_packed_matmul": False,                      # Use packed MatMul (instead of 3 separate MatMuls for Q/K/V)
-            "block_sparse": {                                # Block-sparse attention-specific variables
-                "sparse_block_size": sparse_block_size,      # Sparse block size for SparseAttention op
-                "kernel_block_size": kernel_block_size,      # Kernel block size for sparse attention
-                "local_blocks": local_blocks,                # Number of local blocks for sparse attention
-                "vert_stride": vert_block_stride,            # Vertical stride to use for sparse attention
-                "homo_head": homo_head,                      # Use homo head pattern for sparse attention
-            }
+            "q_path": "",  # Q path to attention
+            "k_path": "",  # K path to attention
+            "v_path": "",  # V path to attention
+            "op_type": "MultiHeadAttention",  # Attention op to use
+            "scale": 1 / np.sqrt(self.head_size),  # Scale value after calculating Q x K' in attention
+            "softcap": softcap,  # Softcap value to prevent values from exploding in attention
+            "use_rotemb_in_attn": False,  # Use rotary embeddings within attention (instead of a separate RotaryEmbedding op)
+            "force_unpacked_matmul": extra_options[
+                "force_unpacked_matmul"
+            ],  # Force the matmul of attention to be unpacked (for importing LoRA merged adapters)
+            "use_packed_matmul": False,  # Use packed MatMul (instead of 3 separate MatMuls for Q/K/V)
+            "block_sparse": {  # Block-sparse attention-specific variables
+                "sparse_block_size": sparse_block_size,  # Sparse block size for SparseAttention op
+                "kernel_block_size": kernel_block_size,  # Kernel block size for sparse attention
+                "local_blocks": local_blocks,  # Number of local blocks for sparse attention
+                "vert_stride": vert_block_stride,  # Vertical stride to use for sparse attention
+                "homo_head": homo_head,  # Use homo head pattern for sparse attention
+            },
         }
         valid_gqa_configurations = [
             ("cpu", TensorProto.FLOAT),
@@ -263,7 +378,7 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
 
             # DML doesn't support packed Q/K/V for GQA yet
             # Packed MatMul with LoRA/QLoRA is not currently supported
-            self.attention_attrs["use_packed_matmul"] = (self.ep != "dml" and not self.matmul_attrs["use_lora"])
+            self.attention_attrs["use_packed_matmul"] = self.ep != "dml" and not self.matmul_attrs["use_lora"]
             if self.attention_attrs["force_unpacked_matmul"]:
                 self.attention_attrs["use_packed_matmul"] = False
 
@@ -276,26 +391,26 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
 
         # MLP-specific variables
         self.mlp_attrs = {
-            "use_proj": True,           # Use projection style for MLP (GateProj/UpProj/DownProj)
-            "use_fc": False,            # Use fully-connected style for MLP (FC1/FC2)
-            "output_0": "",             # Output 0 for MLP layer
+            "use_proj": True,  # Use projection style for MLP (GateProj/UpProj/DownProj)
+            "use_fc": False,  # Use fully-connected style for MLP (FC1/FC2)
+            "output_0": "",  # Output 0 for MLP layer
         }
 
         # MoE-specific variables
         num_experts = config.num_experts if hasattr(config, "num_experts") else 1
         self.moe_attrs = {
-            "num_experts": num_experts,                       # Number of experts in MoE layer
-            "top_k": 1,                                       # Number of experts to select in MoE layer
-            "activation_type": "relu",                        # Activation function for MoE layer
-            "normalize_routing_weights": False,               # Normalize routing weights in MoE layer
-            "use_sparse_mixer": False,                        # Use SparseMixer in MoE layer. Used in Phi3 MoE
-            "use_int4": True,                                 # Use INT4 quantization in MoE layer, otherwise use INT8
+            "num_experts": num_experts,  # Number of experts in MoE layer
+            "top_k": 1,  # Number of experts to select in MoE layer
+            "activation_type": "relu",  # Activation function for MoE layer
+            "normalize_routing_weights": False,  # Normalize routing weights in MoE layer
+            "use_sparse_mixer": False,  # Use SparseMixer in MoE layer. Used in Phi3 MoE
+            "use_int4": True,  # Use INT4 quantization in MoE layer, otherwise use INT8
         }
 
         # LM head-specific variables
         self.lm_head_attrs = {
-            "scale": 1,                 # Scale value to multiply output of LM head by
-            "mask": None,               # LM head mask for tokens in the vocabulary
+            "scale": 1,  # Scale value to multiply output of LM head by
+            "mask": None,  # LM head mask for tokens in the vocabulary
         }
         if hasattr(config, "dummy_token_indices"):
             # Create LM head mask for tokens in the vocabulary
@@ -306,12 +421,14 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         # Quantization-specific variables (INT4, INT8, etc.)
         self.quant_attrs = {
             "int4": {
-                "accuracy_level": int(extra_options.get("int4_accuracy_level", 0)),   # Default is 0 for non-QDQ formats, default is 4 for QDQ formats
+                "accuracy_level": int(
+                    extra_options.get("int4_accuracy_level", 0)
+                ),  # Default is 0 for non-QDQ formats, default is 4 for QDQ formats
                 "block_size": int(extra_options.get("int4_block_size", 32)),
-                "op_types_to_quantize": extra_options.get("int4_op_types_to_quantize", ("MatMul", )),
-                "non_quant_nodes_keywords": extra_options.get("non_quant_nodes", ())
+                "op_types_to_quantize": extra_options.get("int4_op_types_to_quantize", ("MatMul",)),
+                "non_quant_nodes_keywords": extra_options.get("non_quant_nodes", ()),
             },
-            "use_qdq": extra_options.get("use_qdq", False),           # Use QDQ format
+            "use_qdq": extra_options.get("use_qdq", False),  # Use QDQ format
             "dynamic_quantize": extra_options.get("dynamic_quantize", False),
             "force_transpose_inputs": extra_options.get("force_transpose_inputs", False),
         }
@@ -320,26 +437,36 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
             # Create quantized attributes from quantization config
             self.quant_attrs["bits"] = config.quantization_config["bits"]
             self.quant_attrs["group_size"] = config.quantization_config["group_size"]
-            self.quant_attrs["use_g_idx"] = config.quantization_config["desc_act"] if "desc_act" in config.quantization_config else False
+            self.quant_attrs["use_g_idx"] = (
+                config.quantization_config["desc_act"] if "desc_act" in config.quantization_config else False
+            )
 
     def make_genai_config(self, model_name_or_path, extra_kwargs, out_dir):
         try:
-            config = GenerationConfig.from_pretrained(model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs)
+            config = GenerationConfig.from_pretrained(
+                model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs
+            )
         except:
-            config = AutoConfig.from_pretrained(model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs)
+            config = AutoConfig.from_pretrained(
+                model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs
+            )
         inputs = dict(zip(self.input_names, self.input_names))
-        inputs.update({
-            "past_key_names": "past_key_values.%d.key",
-            "past_value_names": "past_key_values.%d.value",
-        })
+        inputs.update(
+            {
+                "past_key_names": "past_key_values.%d.key",
+                "past_value_names": "past_key_values.%d.value",
+            }
+        )
         genai_config = {
             "model": {
-                "bos_token_id": config.bos_token_id if hasattr(config, "bos_token_id") else 1,  # config.bos_token_id not present in ChatGLM model configs.
+                "bos_token_id": config.bos_token_id
+                if hasattr(config, "bos_token_id")
+                else 1,  # config.bos_token_id not present in ChatGLM model configs.
                 "context_length": self.context_length,
                 "decoder": {
-                    "session_options" : {
+                    "session_options": {
                         "log_id": "onnxruntime-genai",
-                        "provider_options" : [],
+                        "provider_options": [],
                     },
                     "filename": self.filename,
                     "head_size": self.head_size,
@@ -355,22 +482,36 @@ def make_genai_config(self, model_name_or_path, extra_kwargs, out_dir):
                     "num_key_value_heads": self.num_kv_heads,
                 },
                 "eos_token_id": config.eos_token_id,
-                "pad_token_id": config.pad_token_id if hasattr(config, "pad_token_id") and config.pad_token_id is not None else config.eos_token_id[0] if isinstance(config.eos_token_id, list) else config.eos_token_id,
-                "type": self.model_type[ : self.model_type.find("For")].lower(),
+                "pad_token_id": config.pad_token_id
+                if hasattr(config, "pad_token_id") and config.pad_token_id is not None
+                else config.eos_token_id[0]
+                if isinstance(config.eos_token_id, list)
+                else config.eos_token_id,
+                "type": self.model_type[: self.model_type.find("For")].lower(),
                 "vocab_size": self.vocab_size,
             },
             "search": {
-                "diversity_penalty": config.diversity_penalty if hasattr(config, "diversity_penalty") else 0.0,
+                "diversity_penalty": config.diversity_penalty
+                if hasattr(config, "diversity_penalty")
+                else 0.0,
                 "do_sample": config.do_sample if hasattr(config, "do_sample") else False,
                 "early_stopping": True,
                 "length_penalty": config.length_penalty if hasattr(config, "length_penalty") else 1.0,
                 "max_length": self.context_length,
                 "min_length": 0,
-                "no_repeat_ngram_size": config.no_repeat_ngram_size if hasattr(config, "no_repeat_ngram_size") else 0,
+                "no_repeat_ngram_size": config.no_repeat_ngram_size
+                if hasattr(config, "no_repeat_ngram_size")
+                else 0,
                 "num_beams": config.num_beams if hasattr(config, "num_beams") else 1,
-                "num_return_sequences": config.num_return_sequences if hasattr(config, "num_return_sequences") else 1,
-                "past_present_share_buffer": False if "config_only" in self.extra_options else self.past_present_share_buffer,
-                "repetition_penalty": config.repetition_penalty if hasattr(config, "repetition_penalty") else 1.0,
+                "num_return_sequences": config.num_return_sequences
+                if hasattr(config, "num_return_sequences")
+                else 1,
+                "past_present_share_buffer": False
+                if "config_only" in self.extra_options
+                else self.past_present_share_buffer,
+                "repetition_penalty": config.repetition_penalty
+                if hasattr(config, "repetition_penalty")
+                else 1.0,
                 "temperature": config.temperature if hasattr(config, "temperature") else 1.0,
                 "top_k": 1,
                 "top_p": config.top_p if hasattr(config, "top_p") else 1.0,
@@ -378,7 +519,7 @@ def make_genai_config(self, model_name_or_path, extra_kwargs, out_dir):
         }
 
         if self.ep != "cpu":
-            ep_options = { self.ep : self.ep_attrs[self.ep] }
+            ep_options = {self.ep: self.ep_attrs[self.ep]}
             genai_config["model"]["decoder"]["session_options"]["provider_options"].append(ep_options)
 
         if self.extra_options.get("prompt_templates", "0") == "1":
@@ -387,45 +528,70 @@ def make_genai_config(self, model_name_or_path, extra_kwargs, out_dir):
                 genai_config["model"]["prompt_templates"] = prompt_templates
 
         print(f"Saving GenAI config in {out_dir}")
-        with open(os.path.join(out_dir,"genai_config.json"), "w") as f:
+        with open(os.path.join(out_dir, "genai_config.json"), "w") as f:
             json.dump(genai_config, f, indent=4)
 
     def save_processing(self, model_name_or_path, extra_kwargs, out_dir):
-        tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs)
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name_or_path, token=self.hf_token, trust_remote_code=True, **extra_kwargs
+        )
         print(f"Saving processing files in {out_dir} for GenAI")
         tokenizer.save_pretrained(out_dir)
 
     def _get_prompt_templates(self, hf_name, extra_kwargs):
         try:
             # disable end of sentence padding with eos_token=None
-            tokenizer = AutoTokenizer.from_pretrained(hf_name, token=self.hf_token, trust_remote_code=True, eos_token=None, **extra_kwargs)
-            system_template = tokenizer.apply_chat_template([{'role': 'system', 'content': '{Content}'}], tokenize=False)
-            system_user_template = tokenizer.apply_chat_template([{'role': 'system', 'content': '{Content}'}, {'role': 'user', 'content': '{Content}'}], tokenize=False)
-            system_user_assistant_template = tokenizer.apply_chat_template([{'role': 'system', 'content': '{Content}'}, {'role': 'user', 'content': '{Content}'}, {'role': 'assistant', 'content': '{Content}'}], tokenize=False)
-            assert system_user_template.startswith(system_template), "Chat templates may contain padding tokens, leading to incorrect prompt templates"
-            assert system_user_assistant_template.startswith(system_user_template), "Chat templates may contain padding tokens, leading to incorrect prompt templates"
-            user_template = system_user_template[len(system_template):]
-            assistant_template = system_user_assistant_template[len(system_user_template):]
-            prompt_template = system_user_assistant_template[len(system_template):]
-            prompt_template = prompt_template[:prompt_template.rfind('{Content}')]
+            tokenizer = AutoTokenizer.from_pretrained(
+                hf_name, token=self.hf_token, trust_remote_code=True, eos_token=None, **extra_kwargs
+            )
+            system_template = tokenizer.apply_chat_template(
+                [{"role": "system", "content": "{Content}"}], tokenize=False
+            )
+            system_user_template = tokenizer.apply_chat_template(
+                [{"role": "system", "content": "{Content}"}, {"role": "user", "content": "{Content}"}],
+                tokenize=False,
+            )
+            system_user_assistant_template = tokenizer.apply_chat_template(
+                [
+                    {"role": "system", "content": "{Content}"},
+                    {"role": "user", "content": "{Content}"},
+                    {"role": "assistant", "content": "{Content}"},
+                ],
+                tokenize=False,
+            )
+            assert system_user_template.startswith(system_template), (
+                "Chat templates may contain padding tokens, leading to incorrect prompt templates"
+            )
+            assert system_user_assistant_template.startswith(system_user_template), (
+                "Chat templates may contain padding tokens, leading to incorrect prompt templates"
+            )
+            user_template = system_user_template[len(system_template) :]
+            assistant_template = system_user_assistant_template[len(system_user_template) :]
+            prompt_template = system_user_assistant_template[len(system_template) :]
+            prompt_template = prompt_template[: prompt_template.rfind("{Content}")]
             templates = {
                 "system": system_template,
                 "user": user_template,
                 "assistant": assistant_template,
-                "prompt": prompt_template
+                "prompt": prompt_template,
             }
-            return templates 
+            return templates
         except Exception as e:
             print(f"Failed to get prompt templates. Error: {e}")
             return None
-        
+
     def save_model(self, out_dir):
         print(f"Saving ONNX model in {out_dir}")
         gc.collect()
 
         # Create ONNX model
         model = helper.make_model(
-            opset_imports=[self.clear_field(helper.make_operatorsetid('', 21 if self.quant_attrs["use_qdq"] else 14), 'domain'), helper.make_operatorsetid('com.microsoft', 1)],
+            opset_imports=[
+                self.clear_field(
+                    helper.make_operatorsetid("", 21 if self.quant_attrs["use_qdq"] else 14), "domain"
+                ),
+                helper.make_operatorsetid("com.microsoft", 1),
+            ],
             ir_version=7,
             producer_name="onnxruntime-genai",
             producer_version="0.0.0",
@@ -436,7 +602,7 @@ def save_model(self, out_dir):
                 initializer=self.initializers,
                 value_info=self.value_infos,
                 nodes=self.nodes,
-            )
+            ),
         )
 
         # Load external data into ONNX model
@@ -452,7 +618,9 @@ def save_model(self, out_dir):
             os.rmdir(self.cache_dir)
 
         # Quantize ONNX model to desired precision
-        already_quantized_in_qdq_format = self.quant_type is not None and self.quant_attrs["use_qdq"]  # Skip quantizing `MatMul` in `DequantizeLinear --> Transpose --> MatMul` path
+        already_quantized_in_qdq_format = (
+            self.quant_type is not None and self.quant_attrs["use_qdq"]
+        )  # Skip quantizing `MatMul` in `DequantizeLinear --> Transpose --> MatMul` path
         if self.onnx_dtype == "int4" and not already_quantized_in_qdq_format:
             # Save the model beforehand, because it's easier to quantize dynamically afterwards
             if self.quant_attrs["dynamic_quantize"]:
@@ -477,7 +645,7 @@ def save_model(self, out_dir):
                 )
                 model = self.to_int4(model, dynamic_quantize=True)
                 return
-            
+
             model = self.to_int4(model)
 
         # Save ONNX model with only one external data file and delete any existing duplicate copies
@@ -513,26 +681,25 @@ def to_int4(self, model, dynamic_quantize=False):
         print(excluding)
 
         if dynamic_quantize:
-
             quantize_dynamic(
                 extra_options={
-                        'ActivationSymmetric': True,         # True for inference speed. False may keep more accuracy.
-                        'WeightSymmetric': True,                 # True for inference speed. False may keep more accuracy.
-                        'EnableSubgraph': True,                   # True for more quant.
-                        'ForceQuantizeNoInputCheck': True,       # True for more quant.
-                        'MatMulConstBOnly': True                 # False for more quant. Sometime, the inference speed may get worse. Keep this True in case of training graph.
+                    "ActivationSymmetric": True,  # True for inference speed. False may keep more accuracy.
+                    "WeightSymmetric": True,  # True for inference speed. False may keep more accuracy.
+                    "EnableSubgraph": True,  # True for more quant.
+                    "ForceQuantizeNoInputCheck": True,  # True for more quant.
+                    "MatMulConstBOnly": True,  # False for more quant. Sometime, the inference speed may get worse. Keep this True in case of training graph.
                 },
                 nodes_to_exclude=excluding,
-                model_input='build/inference_models/model.onnx',
-                model_output='build/inference_models/quant_model.onnx',
+                model_input="build/inference_models/model.onnx",
+                model_output="build/inference_models/quant_model.onnx",
                 per_channel=True,
-                #use_external_data_format=True,
+                # use_external_data_format=True,
                 weight_type=QuantType.QUInt8,
-                reduce_range=False
+                reduce_range=False,
             )
 
             return model
-        
+
         print("Quantizing with MatMul4BitsQuantizer...")
 
         quant = MatMul4BitsQuantizer(
@@ -567,7 +734,7 @@ def make_external_tensor(self, np_data, name, unpack_int4=False, **kwargs):
         tensor.ClearField("raw_data")
         tensor.data_location = TensorProto.EXTERNAL
 
-        if unpack_int4 and self.onnx_dtype == 'int4':
+        if unpack_int4 and self.onnx_dtype == "int4":
             tensor.data_type = TensorProto.UINT4
             tensor.dims[-1] *= 2
 
@@ -582,9 +749,9 @@ def make_node(self, op_type, inputs, outputs, name=None, doc_string=None, domain
         # Make node only if it does not already exist
         if name not in self.node_names:
             node = helper.make_node(op_type, inputs, outputs, name, doc_string, domain, **kwargs)
-            if doc_string == '':
-                node.doc_string = ''
-            self.order_repeated_field(node.attribute, 'name', kwargs.keys())
+            if doc_string == "":
+                node.doc_string = ""
+            self.order_repeated_field(node.attribute, "name", kwargs.keys())
             self.nodes.append(node)
             self.node_names.add(name)
 
@@ -604,8 +771,8 @@ def make_value_info(self, name, dtype, shape):
 
     def make_graph(self, *args, doc_string=None, **kwargs):
         graph = helper.make_graph(*args, doc_string=doc_string, **kwargs)
-        if doc_string == '':
-            graph.doc_string = ''
+        if doc_string == "":
+            graph.doc_string = ""
         return graph
 
     def make_inputs_and_outputs(self):
@@ -627,15 +794,35 @@ def make_inputs_and_outputs(self):
         for i in range(self.num_layers):
             # Add KV cache to inputs
             key_name = f"past_key_values.{i}.key"
-            inputs.append(helper.make_tensor_value_info(key_name, self.input_types["past_key_values.key"], shape=self.input_shapes["past_key_values.key"]))
+            inputs.append(
+                helper.make_tensor_value_info(
+                    key_name,
+                    self.input_types["past_key_values.key"],
+                    shape=self.input_shapes["past_key_values.key"],
+                )
+            )
             value_name = f"past_key_values.{i}.value"
-            inputs.append(helper.make_tensor_value_info(value_name, self.input_types["past_key_values.value"], shape=self.input_shapes["past_key_values.value"]))
+            inputs.append(
+                helper.make_tensor_value_info(
+                    value_name,
+                    self.input_types["past_key_values.value"],
+                    shape=self.input_shapes["past_key_values.value"],
+                )
+            )
 
             # Add KV cache to outputs
             key_name = f"present.{i}.key"
-            outputs.append(helper.make_tensor_value_info(key_name, self.output_types["present.key"], shape=self.output_shapes["present.key"]))
+            outputs.append(
+                helper.make_tensor_value_info(
+                    key_name, self.output_types["present.key"], shape=self.output_shapes["present.key"]
+                )
+            )
             value_name = f"present.{i}.value"
-            outputs.append(helper.make_tensor_value_info(value_name, self.output_types["present.value"], shape=self.output_shapes["present.value"]))
+            outputs.append(
+                helper.make_tensor_value_info(
+                    value_name, self.output_types["present.value"], shape=self.output_shapes["present.value"]
+                )
+            )
 
         self.inputs = inputs
         self.outputs = outputs
@@ -646,7 +833,10 @@ def make_constant(self, name):
         path = name.split("/")
         onnx_dtype, dims, num = eval(path[-3]), path[-2], eval(path[-1])
         np_dtype = self.to_numpy_dtype[onnx_dtype]
-        value = numpy_helper.from_array(np.array(num if dims == "0D" else list(num) if type(num) == tuple else [num], dtype=np_dtype), name=name.replace("constants", "numpy_helper"))
+        value = numpy_helper.from_array(
+            np.array(num if dims == "0D" else list(num) if type(num) == tuple else [num], dtype=np_dtype),
+            name=name.replace("constants", "numpy_helper"),
+        )
 
         node_name = name.replace("constants", "constant_nodes")
         self.make_node("Constant", inputs=[], outputs=[name], name=node_name, value=value)
@@ -702,7 +892,7 @@ def make_greater(self, name, inputs, shape):
         output = f"{name}/output_0"
         self.make_node("Greater", inputs=inputs, outputs=[output], name=name)
         self.make_value_info(output, TensorProto.BOOL, shape=shape)
-    
+
     def make_greater_or_equal(self, name, inputs, shape):
         output = f"{name}/output_0"
         self.make_node("GreaterOrEqual", inputs=inputs, outputs=[output], name=name)
@@ -795,7 +985,7 @@ def make_matmul(self, matmul, basename, root_input, **kwargs):
         else:
             # For regular `MatMul`
             return self.make_matmul_op(matmul, basename, root_input, **kwargs)
-    
+
     def make_matmul_op(self, matmul, basename, root_input, **kwargs):
         if self.onnx_dtype in {"fp16", "fp32"}:
             return self.make_matmul_fp16_or_fp32(matmul, basename, root_input, **kwargs)
@@ -807,41 +997,48 @@ def make_matmul_op(self, matmul, basename, root_input, **kwargs):
         else:
             raise NotImplementedError(f"The {self.onnx_dtype} precision is not currently supported.")
 
-    
     def make_matmul_fp16_or_fp32(self, matmul, name, root_input, **kwargs):
 
         if self.quant_attrs["force_transpose_inputs"]:
             weight = name[1:].replace("/", ".") + ".weight"
             # Store the original weight data without transposing
-            self.make_external_tensor(matmul.weight.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), weight)
+            self.make_external_tensor(
+                matmul.weight.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), weight
+            )
 
             # Create transpose node to transpose the weight
             weight_transpose_name = f"{name}/weight_transpose"
             original_weight_shape = matmul.weight.shape  # [out_features, in_features]
-            transposed_weight_shape = [original_weight_shape[1], original_weight_shape[0]]  # [in_features, out_features]
-            
+            transposed_weight_shape = [
+                original_weight_shape[1],
+                original_weight_shape[0],
+            ]  # [in_features, out_features]
+
             self.make_transpose(
                 name=weight_transpose_name,
                 root_input=weight,
                 dtype=self.io_dtype,
                 shape=transposed_weight_shape,
-                perm=[1, 0]  # Transpose dimensions 0 and 1
+                perm=[1, 0],  # Transpose dimensions 0 and 1
             )
 
             last_dim = matmul.weight.shape[0]
             output = "logits" if kwargs.get("logits", False) else f"{name}/output_0"
-            
+
             # Use the transposed weight output in MatMul
             transposed_weight_output = f"{weight_transpose_name}/output_0"
-            self.make_node("MatMul", inputs=[root_input, transposed_weight_output], outputs=[output], name=name)
-            self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', last_dim])
+            self.make_node(
+                "MatMul", inputs=[root_input, transposed_weight_output], outputs=[output], name=name
+            )
+            self.make_value_info(output, self.io_dtype, shape=["batch_size", "sequence_length", last_dim])
 
             return name
         else:
-
             weight = name[1:].replace("/", ".") + ".weight"
 
-            self.make_external_tensor(matmul.weight.detach().numpy().transpose().astype(self.to_numpy_dtype[self.io_dtype]), weight)
+            self.make_external_tensor(
+                matmul.weight.detach().numpy().transpose().astype(self.to_numpy_dtype[self.io_dtype]), weight
+            )
 
             last_dim = matmul.weight.shape[0]
 
@@ -849,10 +1046,10 @@ def make_matmul_fp16_or_fp32(self, matmul, name, root_input, **kwargs):
 
             self.make_node("MatMul", inputs=[root_input, weight], outputs=[output], name=name)
 
-            self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', last_dim])
+            self.make_value_info(output, self.io_dtype, shape=["batch_size", "sequence_length", last_dim])
 
         return name
-    
+
     def make_matmul_int4(self, matmul, basename, root_input, **kwargs):
         if not hasattr(matmul, "qweight"):
             # TODO: quantize weights, then save new MatMul numpy weights for onnx model
@@ -866,7 +1063,9 @@ def make_matmul_int4(self, matmul, basename, root_input, **kwargs):
         weight = name[1:].replace("/", ".") + ".qweight"
         self.make_external_tensor(matmul.qweight.detach().numpy(), weight)
         scales = name[1:].replace("/", ".") + ".scales"
-        self.make_external_tensor(matmul.scales.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), scales)
+        self.make_external_tensor(
+            matmul.scales.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), scales
+        )
 
         inputs = [root_input, weight, scales]
 
@@ -882,11 +1081,20 @@ def make_matmul_int4(self, matmul, basename, root_input, **kwargs):
 
         output = "logits" if kwargs.get("logits", False) else f"{name}/output_0"
         self.make_node(
-            "MatMulNBits", inputs=inputs, outputs=[output], name=name, domain="com.microsoft",
+            "MatMulNBits",
+            inputs=inputs,
+            outputs=[output],
+            name=name,
+            domain="com.microsoft",
             accuracy_level=self.quant_attrs["int4"]["accuracy_level"],
-            bits=matmul.bits, block_size=matmul.group_size, K=matmul.in_features, N=matmul.out_features,
+            bits=matmul.bits,
+            block_size=matmul.group_size,
+            K=matmul.in_features,
+            N=matmul.out_features,
+        )
+        self.make_value_info(
+            output, self.io_dtype, shape=["batch_size", "sequence_length", matmul.out_features]
         )
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', matmul.out_features])
 
         return name
 
@@ -894,12 +1102,16 @@ def make_dequantize_linear(self, dequantize_name, quantized_op):
         # Input weights are quantized, save quantized MatMul numpy weights for onnx model
         qweight = dequantize_name[1:].replace("/", ".") + ".qweight"
         qweight_npy = quantized_op.qweight.detach().numpy()
-        qweight_npy = qweight_npy.reshape(*qweight_npy.shape[:-2], qweight_npy.shape[-2] * qweight_npy.shape[-1])
+        qweight_npy = qweight_npy.reshape(
+            *qweight_npy.shape[:-2], qweight_npy.shape[-2] * qweight_npy.shape[-1]
+        )
         self.make_external_tensor(qweight_npy, qweight, True)
 
         scales = dequantize_name[1:].replace("/", ".") + ".scales"
         scales_npy = quantized_op.scales.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype])
-        scales_npy = scales_npy.reshape(*qweight_npy.shape[:-1], qweight_npy.shape[-1] * 2 // quantized_op.group_size)
+        scales_npy = scales_npy.reshape(
+            *qweight_npy.shape[:-1], qweight_npy.shape[-1] * 2 // quantized_op.group_size
+        )
         self.make_external_tensor(scales_npy, scales)
 
         dequantize_inputs = [qweight, scales]
@@ -907,13 +1119,26 @@ def make_dequantize_linear(self, dequantize_name, quantized_op):
         if hasattr(quantized_op, "qzeros") and quantized_op.qzeros is not None:
             zeros = dequantize_name[1:].replace("/", ".") + ".qzeros"
             zeros_npy = quantized_op.qzeros.detach().numpy()
-            zeros_npy = zeros_npy.reshape(*qweight_npy.shape[:-1], qweight_npy.shape[-1] // quantized_op.group_size)
+            zeros_npy = zeros_npy.reshape(
+                *qweight_npy.shape[:-1], qweight_npy.shape[-1] // quantized_op.group_size
+            )
             self.make_external_tensor(zeros_npy, zeros, True)
             dequantize_inputs.append(zeros)
 
         dequantize_output = f"{dequantize_name}/output_0"
-        self.make_node("DequantizeLinear", inputs=dequantize_inputs, outputs=[dequantize_output], name=dequantize_name, block_size=quantized_op.group_size, axis=-1)
-        self.make_value_info(dequantize_output, self.io_dtype, shape=[*scales_npy.shape[:-1], scales_npy.shape[-1] * quantized_op.group_size])
+        self.make_node(
+            "DequantizeLinear",
+            inputs=dequantize_inputs,
+            outputs=[dequantize_output],
+            name=dequantize_name,
+            block_size=quantized_op.group_size,
+            axis=-1,
+        )
+        self.make_value_info(
+            dequantize_output,
+            self.io_dtype,
+            shape=[*scales_npy.shape[:-1], scales_npy.shape[-1] * quantized_op.group_size],
+        )
 
         return dequantize_output
 
@@ -938,8 +1163,15 @@ def make_matmul_int4_qdq(self, matmul, matmul_name, root_input, **kwargs):
         self.make_transpose(transpose_name, dequantize_output, self.io_dtype, transposed_shape, [1, 0])
 
         matmul_output = "logits" if kwargs.get("logits", False) else f"{matmul_name}/output_0"
-        self.make_node("MatMul", inputs=[root_input, f"{transpose_name}/output_0"], outputs=[matmul_output], name=matmul_name)
-        self.make_value_info(matmul_output, self.io_dtype, shape=['batch_size', 'sequence_length', matmul.out_features])
+        self.make_node(
+            "MatMul",
+            inputs=[root_input, f"{transpose_name}/output_0"],
+            outputs=[matmul_output],
+            name=matmul_name,
+        )
+        self.make_value_info(
+            matmul_output, self.io_dtype, shape=["batch_size", "sequence_length", matmul.out_features]
+        )
 
         return matmul_name
 
@@ -986,7 +1218,9 @@ def make_matmul_lora(self, matmul, basename, root_input, **kwargs):
 
     def make_packed_matmul(self, q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs):
         if self.onnx_dtype in {"fp16", "fp32"}:
-            return self.make_packed_matmul_fp16_or_fp32(q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs)
+            return self.make_packed_matmul_fp16_or_fp32(
+                q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs
+            )
         elif self.onnx_dtype == "int4":
             return self.make_packed_matmul_int4(q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs)
         else:
@@ -1003,7 +1237,15 @@ def make_packed_matmul_fp16_or_fp32(self, q_matmul, k_matmul, v_matmul, name, ro
         # Create dummy PackedMatMul class
         class PackedMatMul:
             def __init__(self):
-                self.weight = torch.concatenate([q_matmul.weight.detach().cpu(), k_matmul.weight.detach().cpu(), v_matmul.weight.detach().cpu()], dim=0).reshape(N_q + N_kv + N_kv, H)
+                self.weight = torch.concatenate(
+                    [
+                        q_matmul.weight.detach().cpu(),
+                        k_matmul.weight.detach().cpu(),
+                        v_matmul.weight.detach().cpu(),
+                    ],
+                    dim=0,
+                ).reshape(N_q + N_kv + N_kv, H)
+
         matmul = PackedMatMul()
         new_name = self.make_matmul(matmul, name, root_input, **kwargs)
 
@@ -1014,29 +1256,55 @@ def make_packed_matmul_int4(self, q_matmul, k_matmul, v_matmul, basename, root_i
             # TODO: quantize weights, then save new MatMul numpy weights for onnx model
             # print(f"Quantizing to {self.onnx_dtype} on-the-fly is not currently supported.")
             # print(f"Saving as {self.io_dtype} on-the-fly and quantizing to {self.onnx_dtype} at the end.")
-            return self.make_packed_matmul_fp16_or_fp32(q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs)
+            return self.make_packed_matmul_fp16_or_fp32(
+                q_matmul, k_matmul, v_matmul, basename, root_input, **kwargs
+            )
 
         name = f"{basename}NBits"
 
         # Create dummy PackedMatMul class
         class PackedMatMul:
             def __init__(self):
-                self.qweight = torch.concatenate([q_matmul.qweight.detach().cpu(), k_matmul.qweight.detach().cpu(), v_matmul.qweight.detach().cpu()], dim=0)
-                self.scales = torch.concatenate([q_matmul.scales.detach().cpu(), k_matmul.scales.detach().cpu(), v_matmul.scales.detach().cpu()], dim=0)
-                self.qzeros = torch.concatenate([q_matmul.qzeros.detach().cpu(), k_matmul.qzeros.detach().cpu(), v_matmul.qzeros.detach().cpu()], dim=0)
+                self.qweight = torch.concatenate(
+                    [
+                        q_matmul.qweight.detach().cpu(),
+                        k_matmul.qweight.detach().cpu(),
+                        v_matmul.qweight.detach().cpu(),
+                    ],
+                    dim=0,
+                )
+                self.scales = torch.concatenate(
+                    [
+                        q_matmul.scales.detach().cpu(),
+                        k_matmul.scales.detach().cpu(),
+                        v_matmul.scales.detach().cpu(),
+                    ],
+                    dim=0,
+                )
+                self.qzeros = torch.concatenate(
+                    [
+                        q_matmul.qzeros.detach().cpu(),
+                        k_matmul.qzeros.detach().cpu(),
+                        v_matmul.qzeros.detach().cpu(),
+                    ],
+                    dim=0,
+                )
                 self.g_idx = q_matmul.g_idx
 
                 self.in_features = q_matmul.in_features
                 self.out_features = q_matmul.out_features + k_matmul.out_features + v_matmul.out_features
                 self.bits = q_matmul.bits
                 self.group_size = q_matmul.group_size
+
         matmul = PackedMatMul()
 
         # Input weights are quantized, save quantized MatMul numpy weights for onnx model
         weight = name[1:].replace("/", ".") + ".qweight"
         self.make_external_tensor(matmul.qweight.detach().numpy(), weight)
         scales = name[1:].replace("/", ".") + ".scales"
-        self.make_external_tensor(matmul.scales.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), scales)
+        self.make_external_tensor(
+            matmul.scales.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), scales
+        )
 
         inputs = [root_input, weight, scales]
 
@@ -1052,11 +1320,20 @@ def __init__(self):
 
         output = "logits" if kwargs.get("logits", False) else f"{name}/output_0"
         self.make_node(
-            "MatMulNBits", inputs=inputs, outputs=[output], name=name, domain="com.microsoft",
+            "MatMulNBits",
+            inputs=inputs,
+            outputs=[output],
+            name=name,
+            domain="com.microsoft",
             accuracy_level=self.quant_attrs["int4"]["accuracy_level"],
-            bits=matmul.bits, block_size=matmul.group_size, K=matmul.in_features, N=matmul.out_features,
+            bits=matmul.bits,
+            block_size=matmul.group_size,
+            K=matmul.in_features,
+            N=matmul.out_features,
+        )
+        self.make_value_info(
+            output, self.io_dtype, shape=["batch_size", "sequence_length", matmul.out_features]
         )
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', matmul.out_features])
 
         return name
 
@@ -1065,7 +1342,7 @@ def make_add_bias(self, add, name, root_input, **kwargs):
         self.make_external_tensor(add.astype(self.to_numpy_dtype[self.io_dtype]), bias)
 
         add_bias_inputs = [root_input, bias]
-        shape = ['batch_size', 'sequence_length', add.shape[0]]
+        shape = ["batch_size", "sequence_length", add.shape[0]]
 
         if "logits" in kwargs:
             output = "logits"
@@ -1086,16 +1363,23 @@ def make_embedding(self, embedding):
         basename = "/model/embed_tokens"
         gather_name = f"{basename}/Gather"
         gather_output = f"{gather_name}/output_0"
-        self.make_node('Gather', inputs=[weight, 'input_ids'], outputs=[gather_output], name=gather_name)
-        self.make_value_info(gather_output, self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+        self.make_node("Gather", inputs=[weight, "input_ids"], outputs=[gather_output], name=gather_name)
+        self.make_value_info(
+            gather_output, self.io_dtype, shape=["batch_size", "sequence_length", self.hidden_size]
+        )
 
         if self.embed_attrs["scale"] != 1:
             # Scale the embeddings
             mul_name = f"{basename}/Mul"
-            mul_inputs = [gather_output, f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.embed_attrs['scale']}"]
+            mul_inputs = [
+                gather_output,
+                f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.embed_attrs['scale']}",
+            ]
             mul_output = f"{mul_name}/output_0"
-            self.make_node('Mul', inputs=mul_inputs, outputs=[mul_output], name=mul_name)
-            self.make_value_info(mul_output, self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+            self.make_node("Mul", inputs=mul_inputs, outputs=[mul_output], name=mul_name)
+            self.make_value_info(
+                mul_output, self.io_dtype, shape=["batch_size", "sequence_length", self.hidden_size]
+            )
 
             layernorm_attrs_value = mul_output
         else:
@@ -1109,10 +1393,16 @@ def make_layernorm(self, layer_id, layernorm, skip, simple, location):
         skip_input = self.layernorm_attrs["skip_input"]
 
         weight = f"model.layers.{layer_id}.{location}_layernorm.weight"
-        self.make_external_tensor(layernorm.weight.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]) + self.layernorm_attrs["add_offset"], weight)
+        self.make_external_tensor(
+            layernorm.weight.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype])
+            + self.layernorm_attrs["add_offset"],
+            weight,
+        )
         bias = f"model.layers.{layer_id}.{location}_layernorm.bias"
         if not simple:
-            self.make_external_tensor(layernorm.bias.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), bias)
+            self.make_external_tensor(
+                layernorm.bias.detach().numpy().astype(self.to_numpy_dtype[self.io_dtype]), bias
+            )
 
         inputs = [root_input, skip_input, weight] if skip else [root_input, weight]
         if not simple:
@@ -1128,12 +1418,27 @@ def make_layernorm(self, layer_id, layernorm, skip, simple, location):
         output_3 = f"/model/layers.{layer_id}/{location}_layernorm/output_3"
         if self.layernorm_attrs["last_layernorm"] and self.exclude_lm_head:
             output_0 = "hidden_states"
-        outputs = [output_0, "", "", output_3] if skip and not self.layernorm_attrs["last_layernorm"] else [output_0]
+        outputs = (
+            [output_0, "", "", output_3]
+            if skip and not self.layernorm_attrs["last_layernorm"]
+            else [output_0]
+        )
 
-        self.make_node(op_type, inputs=inputs, outputs=outputs, name=name, domain=("com.microsoft" if skip else None), **kwargs)
-        self.make_value_info(output_0, self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+        self.make_node(
+            op_type,
+            inputs=inputs,
+            outputs=outputs,
+            name=name,
+            domain=("com.microsoft" if skip else None),
+            **kwargs,
+        )
+        self.make_value_info(
+            output_0, self.io_dtype, shape=["batch_size", "sequence_length", self.hidden_size]
+        )
         if skip and not self.layernorm_attrs["last_layernorm"]:
-            self.make_value_info(output_3, self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+            self.make_value_info(
+                output_3, self.io_dtype, shape=["batch_size", "sequence_length", self.hidden_size]
+            )
 
         # Update LayerNorm attributes
         self.layernorm_attrs["output_0"] = output_0
@@ -1186,16 +1491,27 @@ def make_inv_freq_rescaled(self, inv_freq):
 
     def make_rotary_embedding_caches_from_scratch(self):
         dim = int(self.rotemb_attrs["partial_rotary_factor"] * self.head_size)
-        inv_freq = 1.0 / (self.rotemb_attrs["rescale_factors"] * (self.rotemb_attrs["theta"] ** (torch.arange(0, dim, 2, dtype=torch.int64).float() / dim)))
+        inv_freq = 1.0 / (
+            self.rotemb_attrs["rescale_factors"]
+            * (self.rotemb_attrs["theta"] ** (torch.arange(0, dim, 2, dtype=torch.int64).float() / dim))
+        )
         if "rescale_inv_freq" in self.rotemb_attrs:
             inv_freq = self.make_inv_freq_rescaled(inv_freq)
 
-        position_scale = self.rotemb_attrs["position_scale"] if self.context_length == self.original_context_length else 1
-        t = (torch.arange(self.rotemb_attrs["cache_length"], dtype=self.rotemb_attrs["t_dtype"]) * position_scale).type_as(inv_freq)
+        position_scale = (
+            self.rotemb_attrs["position_scale"] if self.context_length == self.original_context_length else 1
+        )
+        t = (
+            torch.arange(self.rotemb_attrs["cache_length"], dtype=self.rotemb_attrs["t_dtype"])
+            * position_scale
+        ).type_as(inv_freq)
 
         freqs = torch.outer(t, inv_freq)
         emb = torch.cat((freqs, freqs), dim=-1)
-        cos_cache, sin_cache = emb.cos() * self.rotemb_attrs["mscale"], emb.sin() * self.rotemb_attrs["mscale"]
+        cos_cache, sin_cache = (
+            emb.cos() * self.rotemb_attrs["mscale"],
+            emb.sin() * self.rotemb_attrs["mscale"],
+        )
         return cos_cache, sin_cache
 
     def make_rotary_embedding_caches(self, rotemb, **kwargs):
@@ -1233,12 +1549,28 @@ def make_rotary_embedding(self, rotemb, name, root_input, **kwargs):
 
         inputs = [root_input, kwargs.pop("position_ids"), cos_cache_name, sin_cache_name]
         output = f"{name}/output_0"
-        self.make_node("RotaryEmbedding", inputs=inputs, outputs=[output], name=name, domain="com.microsoft", interleaved=self.rotemb_attrs["interleaved"], **kwargs)
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.head_size * (self.num_kv_heads if "k_rotary" in name else self.num_attn_heads)])
+        self.make_node(
+            "RotaryEmbedding",
+            inputs=inputs,
+            outputs=[output],
+            name=name,
+            domain="com.microsoft",
+            interleaved=self.rotemb_attrs["interleaved"],
+            **kwargs,
+        )
+        self.make_value_info(
+            output,
+            self.io_dtype,
+            shape=[
+                "batch_size",
+                "sequence_length",
+                self.head_size * (self.num_kv_heads if "k_rotary" in name else self.num_attn_heads),
+            ],
+        )
 
     def make_rotary_embedding_multi_cache(self):
         # Create dummy rotary embedding class
-        rotemb = type("RotaryEmbedding", (object,), {'content':{}})()
+        rotemb = type("RotaryEmbedding", (object,), {"content": {}})()
         if_cos_cache_output, if_sin_cache_output = "cos_cache", "sin_cache"
 
         # Create caches for when sequence_length > self.original_context_length
@@ -1249,19 +1581,27 @@ def make_rotary_embedding_multi_cache(self):
         # DML doesn't support dynamic selection of the cos/sin cache, so we always use the biggest one
         if self.ep == "dml":
             self.make_rotary_embedding_caches(rotemb)
-            self.make_value_info(if_cos_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"])
-            self.make_value_info(if_sin_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"])
+            self.make_value_info(
+                if_cos_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"]
+            )
+            self.make_value_info(
+                if_sin_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"]
+            )
             return
 
         cos_cache_large_name, sin_cache_large_name = "cos_cache_large", "sin_cache_large"
-        cos_cache_large, sin_cache_large = self.make_rotary_embedding_caches(rotemb, cos_cache_name=cos_cache_large_name, sin_cache_name=sin_cache_large_name)
+        cos_cache_large, sin_cache_large = self.make_rotary_embedding_caches(
+            rotemb, cos_cache_name=cos_cache_large_name, sin_cache_name=sin_cache_large_name
+        )
 
         # Create caches for when sequence_length <= self.original_context_length
         self.rotemb_attrs["rescale_factors"] = self.rotemb_attrs["multi_cache"]["short_factor"]
         self.rotemb_attrs["cache_length"] = self.original_context_length
         self.rotemb_attrs["mscale"] = self.rotemb_attrs["multi_cache"]["short_mscale"]
         cos_cache_small_name, sin_cache_small_name = "cos_cache_small", "sin_cache_small"
-        cos_cache_small, sin_cache_small = self.make_rotary_embedding_caches(rotemb, cos_cache_name=cos_cache_small_name, sin_cache_name=sin_cache_small_name)
+        cos_cache_small, sin_cache_small = self.make_rotary_embedding_caches(
+            rotemb, cos_cache_name=cos_cache_small_name, sin_cache_name=sin_cache_small_name
+        )
 
         self.rotemb_attrs["create_rotary_embedding_caches"] = False
 
@@ -1279,42 +1619,84 @@ def make_rotary_embedding_multi_cache(self):
             gather_name = "/model/attn_mask_reformat/attn_mask_subgraph/Gather_2"
 
         greater_name = f"{basename}/Greater"
-        greater_inputs = [f"{gather_name}/output_0", f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}"]
+        greater_inputs = [
+            f"{gather_name}/output_0",
+            f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}",
+        ]
         self.make_greater(greater_name, greater_inputs, shape=[])
         if_name = f"{basename}/If"
         self.make_node(
-            "If", inputs=[f"{greater_name}/output_0"], outputs=[if_cos_cache_output, if_sin_cache_output], name=if_name,
+            "If",
+            inputs=[f"{greater_name}/output_0"],
+            outputs=[if_cos_cache_output, if_sin_cache_output],
+            name=if_name,
             then_branch=self.make_graph(
                 name="large_rotemb_caches_graph",
                 inputs=[],
                 outputs=[
-                    helper.make_tensor_value_info(cos_cache_large_name, self.io_dtype, shape=cos_cache_large.shape),
-                    helper.make_tensor_value_info(sin_cache_large_name, self.io_dtype, shape=sin_cache_large.shape),
+                    helper.make_tensor_value_info(
+                        cos_cache_large_name, self.io_dtype, shape=cos_cache_large.shape
+                    ),
+                    helper.make_tensor_value_info(
+                        sin_cache_large_name, self.io_dtype, shape=sin_cache_large.shape
+                    ),
                 ],
                 initializer=[],
                 value_info=[],
                 nodes=[
-                    helper.make_node("Constant", inputs=[], outputs=[cos_cache_large_name], name="/large/cos_cache/Constant", value=numpy_helper.from_array(cos_cache_large)),
-                    helper.make_node("Constant", inputs=[], outputs=[sin_cache_large_name], name="/large/sin_cache/Constant", value=numpy_helper.from_array(sin_cache_large)),
+                    helper.make_node(
+                        "Constant",
+                        inputs=[],
+                        outputs=[cos_cache_large_name],
+                        name="/large/cos_cache/Constant",
+                        value=numpy_helper.from_array(cos_cache_large),
+                    ),
+                    helper.make_node(
+                        "Constant",
+                        inputs=[],
+                        outputs=[sin_cache_large_name],
+                        name="/large/sin_cache/Constant",
+                        value=numpy_helper.from_array(sin_cache_large),
+                    ),
                 ],
             ),
             else_branch=self.make_graph(
                 name="small_rotemb_caches_graph",
                 inputs=[],
                 outputs=[
-                    helper.make_tensor_value_info(cos_cache_small_name, self.io_dtype, shape=cos_cache_small.shape),
-                    helper.make_tensor_value_info(sin_cache_small_name, self.io_dtype, shape=sin_cache_small.shape),
+                    helper.make_tensor_value_info(
+                        cos_cache_small_name, self.io_dtype, shape=cos_cache_small.shape
+                    ),
+                    helper.make_tensor_value_info(
+                        sin_cache_small_name, self.io_dtype, shape=sin_cache_small.shape
+                    ),
                 ],
                 initializer=[],
                 value_info=[],
                 nodes=[
-                    helper.make_node("Constant", inputs=[], outputs=[cos_cache_small_name], name="/small/cos_cache/Constant", value=numpy_helper.from_array(cos_cache_small)),
-                    helper.make_node("Constant", inputs=[], outputs=[sin_cache_small_name], name="/small/sin_cache/Constant", value=numpy_helper.from_array(sin_cache_small)),
+                    helper.make_node(
+                        "Constant",
+                        inputs=[],
+                        outputs=[cos_cache_small_name],
+                        name="/small/cos_cache/Constant",
+                        value=numpy_helper.from_array(cos_cache_small),
+                    ),
+                    helper.make_node(
+                        "Constant",
+                        inputs=[],
+                        outputs=[sin_cache_small_name],
+                        name="/small/sin_cache/Constant",
+                        value=numpy_helper.from_array(sin_cache_small),
+                    ),
                 ],
             ),
         )
-        self.make_value_info(if_cos_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"])
-        self.make_value_info(if_sin_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"])
+        self.make_value_info(
+            if_cos_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"]
+        )
+        self.make_value_info(
+            if_sin_cache_output, self.io_dtype, shape=["max_sequence_length", "head_dim / 2"]
+        )
 
     def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         # Make subgraph that repeats tensor of shape (batch_size, sequence_length, num_kv_heads, head_size)
@@ -1387,7 +1769,9 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         #                Transpose
         #                    |
         #                 Reshape
-        basename = f"/model/layers.{layer_id}/attn/{'k_proj' if past_kv.endswith('key') else 'v_proj'}/repeat_kv"
+        basename = (
+            f"/model/layers.{layer_id}/attn/{'k_proj' if past_kv.endswith('key') else 'v_proj'}/repeat_kv"
+        )
 
         # Make the initial subgraph
         #
@@ -1399,11 +1783,25 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         #                                            |          |                                  |
         #                                        present_kv     +------> Gather --> Unsqueeze -----+
         reshape_1_name = f"{basename}/Reshape_1"
-        reshape_1_inputs = [root_input, f"/model/constants/TensorProto.INT64/1D/0, 0, {self.num_kv_heads}, -1"]
-        self.make_reshape(reshape_1_name, reshape_1_inputs, dtype=self.io_dtype, shape=['batch_size', 'sequence_length', self.num_kv_heads, self.head_size])
+        reshape_1_inputs = [
+            root_input,
+            f"/model/constants/TensorProto.INT64/1D/0, 0, {self.num_kv_heads}, -1",
+        ]
+        self.make_reshape(
+            reshape_1_name,
+            reshape_1_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.num_kv_heads, self.head_size],
+        )
         transpose_1_name = f"{basename}/Transpose_1"
         transpose_1_input = f"{reshape_1_name}/output_0"
-        self.make_transpose(transpose_1_name, transpose_1_input, dtype=self.io_dtype, shape=['batch_size', self.num_kv_heads, 'sequence_length', self.head_size], perm=[0,2,1,3])
+        self.make_transpose(
+            transpose_1_name,
+            transpose_1_input,
+            dtype=self.io_dtype,
+            shape=["batch_size", self.num_kv_heads, "sequence_length", self.head_size],
+            perm=[0, 2, 1, 3],
+        )
         concat_1_name = f"{basename}/Concat_1"
         concat_1_inputs = [past_kv, f"{transpose_1_name}/output_0"]
         self.make_node("Concat", inputs=concat_1_inputs, outputs=[present_kv], name=concat_1_name, axis=2)
@@ -1435,14 +1833,28 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         unsqueeze_4_inputs = [f"{gather_4_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"]
         self.make_unsqueeze(unsqueeze_4_name, unsqueeze_4_inputs, dtype=TensorProto.INT64, shape=[1])
         concat_2_name = f"{basename}/Concat_2"
-        concat_2_inputs = [f"{unsqueeze_1_name}/output_0", f"{unsqueeze_2_name}/output_0", f"/model/constants/TensorProto.INT64/1D/{self.num_attn_heads // self.num_kv_heads}", f"{unsqueeze_3_name}/output_0", f"{unsqueeze_4_name}/output_0"]
+        concat_2_inputs = [
+            f"{unsqueeze_1_name}/output_0",
+            f"{unsqueeze_2_name}/output_0",
+            f"/model/constants/TensorProto.INT64/1D/{self.num_attn_heads // self.num_kv_heads}",
+            f"{unsqueeze_3_name}/output_0",
+            f"{unsqueeze_4_name}/output_0",
+        ]
         self.make_concat(concat_2_name, concat_2_inputs, dtype=TensorProto.INT64, shape=[5], axis=0)
 
         mul_1_name = f"{basename}/Mul_1"
-        mul_1_inputs = [f"{unsqueeze_2_name}/output_0", f"/model/constants/TensorProto.INT64/0D/{self.num_attn_heads // self.num_kv_heads}"]
+        mul_1_inputs = [
+            f"{unsqueeze_2_name}/output_0",
+            f"/model/constants/TensorProto.INT64/0D/{self.num_attn_heads // self.num_kv_heads}",
+        ]
         self.make_mul(mul_1_name, mul_1_inputs, dtype=TensorProto.INT64, shape=None)
         concat_3_name = f"{basename}/Concat_3"
-        concat_3_inputs = [f"{unsqueeze_1_name}/output_0", f"{mul_1_name}/output_0", f"{unsqueeze_3_name}/output_0", f"{unsqueeze_4_name}/output_0"]
+        concat_3_inputs = [
+            f"{unsqueeze_1_name}/output_0",
+            f"{mul_1_name}/output_0",
+            f"{unsqueeze_3_name}/output_0",
+            f"{unsqueeze_4_name}/output_0",
+        ]
         self.make_concat(concat_3_name, concat_3_inputs, dtype=TensorProto.INT64, shape=[4], axis=0)
 
         # Make the subgraph that follows the initial subgraph
@@ -1459,7 +1871,13 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         self.make_shape(shape_2_name, f"{reshape_2_name}/output_0", shape=[1])
         constant_shape_name = f"{basename}/ConstantOfShape"
         constant_shape_value = numpy_helper.from_array(np.array([1], dtype="int64"))
-        self.make_constant_of_shape(constant_shape_name, f"{shape_2_name}/output_0", value=constant_shape_value, dtype=TensorProto.INT64, shape=[5])
+        self.make_constant_of_shape(
+            constant_shape_name,
+            f"{shape_2_name}/output_0",
+            value=constant_shape_value,
+            dtype=TensorProto.INT64,
+            shape=[5],
+        )
         mul_2_name = f"{basename}/Mul"
         mul_2_inputs = [f"{constant_shape_name}/output_0", "/model/constants/TensorProto.INT64/0D/-1"]
         self.make_mul(mul_2_name, mul_2_inputs, dtype=TensorProto.INT64, shape=[5])
@@ -1467,7 +1885,11 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         equal_inputs = [f"{reshape_2_name}/output_0", f"{mul_2_name}/output_0"]
         self.make_equal(equal_name, equal_inputs, shape=[5])
         where_name = f"{basename}/Where"
-        where_inputs = [f"{equal_name}/output_0", f"{constant_shape_name}/output_0", f"{reshape_2_name}/output_0"]
+        where_inputs = [
+            f"{equal_name}/output_0",
+            f"{constant_shape_name}/output_0",
+            f"{reshape_2_name}/output_0",
+        ]
         self.make_where(where_name, where_inputs, dtype=TensorProto.INT64, shape=[5])
 
         # Make the final nodes
@@ -1477,19 +1899,54 @@ def make_repeat_kv(self, layer_id, root_input, past_kv, present_kv, **kwargs):
         # Unsqueeze --> Expand --> Reshape --> Transpose --> Reshape
         unsqueeze_5_name = f"{basename}/Unsqueeze_5"
         unsqueeze_5_inputs = [present_kv, "/model/constants/TensorProto.INT64/1D/2"]
-        self.make_unsqueeze(unsqueeze_5_name, unsqueeze_5_inputs, dtype=self.io_dtype, shape=['batch_size', self.num_kv_heads, 1, 'sequence_length', self.head_size])
+        self.make_unsqueeze(
+            unsqueeze_5_name,
+            unsqueeze_5_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", self.num_kv_heads, 1, "sequence_length", self.head_size],
+        )
         expand_name = f"{basename}/Expand"
         expand_inputs = [f"{unsqueeze_5_name}/output_0", f"{where_name}/output_0"]
-        self.make_expand(expand_name, expand_inputs, dtype=self.io_dtype, shape=['batch_size', self.num_kv_heads, self.num_attn_heads // self.num_kv_heads, 'sequence_length', self.head_size])
+        self.make_expand(
+            expand_name,
+            expand_inputs,
+            dtype=self.io_dtype,
+            shape=[
+                "batch_size",
+                self.num_kv_heads,
+                self.num_attn_heads // self.num_kv_heads,
+                "sequence_length",
+                self.head_size,
+            ],
+        )
         reshape_3_name = f"{basename}/Reshape_3"
         reshape_3_inputs = [f"{expand_name}/output_0", f"{concat_3_name}/output_0"]
-        self.make_reshape(reshape_3_name, reshape_3_inputs, dtype=self.io_dtype, shape=['batch_size', self.num_attn_heads, 'sequence_length', self.head_size])
+        self.make_reshape(
+            reshape_3_name,
+            reshape_3_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", self.num_attn_heads, "sequence_length", self.head_size],
+        )
         transpose_2_name = f"{basename}/Transpose_2"
         transpose_2_input = f"{reshape_3_name}/output_0"
-        self.make_transpose(transpose_2_name, transpose_2_input, dtype=self.io_dtype, shape=['batch_size', 'sequence_length', self.num_attn_heads, self.head_size], perm=[0,2,1,3])
+        self.make_transpose(
+            transpose_2_name,
+            transpose_2_input,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.num_attn_heads, self.head_size],
+            perm=[0, 2, 1, 3],
+        )
         reshape_4_name = f"{basename}/Reshape_4"
-        reshape_4_inputs = [f"{transpose_2_name}/output_0", f"/model/constants/TensorProto.INT64/1D/0, 0, {self.num_attn_heads * self.head_size}"]
-        self.make_reshape(reshape_4_name, reshape_4_inputs, dtype=self.io_dtype, shape=['batch_size', 'sequence_length', self.num_attn_heads * self.head_size])
+        reshape_4_inputs = [
+            f"{transpose_2_name}/output_0",
+            f"/model/constants/TensorProto.INT64/1D/0, 0, {self.num_attn_heads * self.head_size}",
+        ]
+        self.make_reshape(
+            reshape_4_name,
+            reshape_4_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.num_attn_heads * self.head_size],
+        )
 
         input_to_attention = f"{reshape_4_name}/output_0"
         return input_to_attention
@@ -1500,56 +1957,115 @@ def make_attention_op(self, name, **kwargs):
         if op_type == "MultiHeadAttention":
             self.make_multi_head_attention(name, add_qk=f"{self.mask_attrs['mask_name']}/output_0", **kwargs)
         elif op_type == "GroupQueryAttention":
-            self.make_group_query_attention(name, seqlens_k=f"{self.mask_attrs['seqlens_k']}/output_0", total_seq_len=f"{self.mask_attrs['total_seq_len']}/output_0", **kwargs)
+            self.make_group_query_attention(
+                name,
+                seqlens_k=f"{self.mask_attrs['seqlens_k']}/output_0",
+                total_seq_len=f"{self.mask_attrs['total_seq_len']}/output_0",
+                **kwargs,
+            )
         elif op_type == "SparseAttention":
-            self.make_sparse_attention(name, block_row_indices=self.mask_attrs['block_row_indices'], block_col_indices=self.mask_attrs['block_col_indices'], key_total_seq_lens=f"{self.mask_attrs['key_total_seq_lens']}/output_0", total_seq_len=f"{self.mask_attrs['total_seq_len']}/output_0", **kwargs)
+            self.make_sparse_attention(
+                name,
+                block_row_indices=self.mask_attrs["block_row_indices"],
+                block_col_indices=self.mask_attrs["block_col_indices"],
+                key_total_seq_lens=f"{self.mask_attrs['key_total_seq_lens']}/output_0",
+                total_seq_len=f"{self.mask_attrs['total_seq_len']}/output_0",
+                **kwargs,
+            )
         else:
             raise NotImplementedError(f"The {op_type} op is not currently supported.")
 
     def make_multi_head_attention(self, name, **kwargs):
         inputs = [
-            kwargs["q_path"], kwargs["k_path"], kwargs["v_path"], kwargs.get("bias", ""),
-            kwargs.get("attn_mask", ""), kwargs.get("add_qk", ""),
-            kwargs.get("past_k", ""), kwargs.get("past_v", ""),
+            kwargs["q_path"],
+            kwargs["k_path"],
+            kwargs["v_path"],
+            kwargs.get("bias", ""),
+            kwargs.get("attn_mask", ""),
+            kwargs.get("add_qk", ""),
+            kwargs.get("past_k", ""),
+            kwargs.get("past_v", ""),
         ]
         output = f"{name}/output_0"
         outputs = [output, kwargs.get("present_k", ""), kwargs.get("present_v", "")]
         self.make_node(
-            "MultiHeadAttention", inputs=inputs, outputs=outputs, name=name, domain="com.microsoft",
-            num_heads=self.num_attn_heads, scale=self.attention_attrs["scale"],
+            "MultiHeadAttention",
+            inputs=inputs,
+            outputs=outputs,
+            name=name,
+            domain="com.microsoft",
+            num_heads=self.num_attn_heads,
+            scale=self.attention_attrs["scale"],
+        )
+        self.make_value_info(
+            output,
+            self.io_dtype,
+            shape=["batch_size", "sequence_length", self.head_size * self.num_attn_heads],
         )
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.head_size * self.num_attn_heads])
 
     def make_group_query_attention(self, name, **kwargs):
         inputs = [
-            kwargs["q_path"], kwargs["k_path"], kwargs["v_path"],
-            kwargs.get("past_k", ""), kwargs.get("past_v", ""),
-            kwargs.get("seqlens_k", ""), kwargs.get("total_seq_len", ""),
-            kwargs.get("cos_cache", ""), kwargs.get("sin_cache", ""),
+            kwargs["q_path"],
+            kwargs["k_path"],
+            kwargs["v_path"],
+            kwargs.get("past_k", ""),
+            kwargs.get("past_v", ""),
+            kwargs.get("seqlens_k", ""),
+            kwargs.get("total_seq_len", ""),
+            kwargs.get("cos_cache", ""),
+            kwargs.get("sin_cache", ""),
         ]
         output = f"{name}/output_0"
         outputs = [output, kwargs.get("present_k", ""), kwargs.get("present_v", "")]
         self.make_node(
-            "GroupQueryAttention", inputs=inputs, outputs=outputs, name=name, domain="com.microsoft",
-            num_heads=self.num_attn_heads, kv_num_heads=self.num_kv_heads, scale=self.attention_attrs["scale"], # local_window_size=self.window_size,  # Disable sliding window attribute temporarily
-            softcap=self.attention_attrs["softcap"], do_rotary=self.attention_attrs["use_rotemb_in_attn"], rotary_interleaved=self.rotemb_attrs["interleaved"],
+            "GroupQueryAttention",
+            inputs=inputs,
+            outputs=outputs,
+            name=name,
+            domain="com.microsoft",
+            num_heads=self.num_attn_heads,
+            kv_num_heads=self.num_kv_heads,
+            scale=self.attention_attrs[
+                "scale"
+            ],  # local_window_size=self.window_size,  # Disable sliding window attribute temporarily
+            softcap=self.attention_attrs["softcap"],
+            do_rotary=self.attention_attrs["use_rotemb_in_attn"],
+            rotary_interleaved=self.rotemb_attrs["interleaved"],
+        )
+        self.make_value_info(
+            output,
+            self.io_dtype,
+            shape=["batch_size", "sequence_length", self.head_size * self.num_attn_heads],
         )
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.head_size * self.num_attn_heads])
 
     def make_sparse_attention(self, name, **kwargs):
         inputs = [
-            kwargs["q_path"], kwargs["k_path"], kwargs["v_path"],
-            kwargs.get("past_k"), kwargs.get("past_v"),
-            kwargs.get("block_row_indices"), kwargs.get("block_col_indices"),
-            kwargs.get("total_seq_len"), kwargs.get("key_total_seq_lens"),
-            kwargs.get("cos_cache", ""), kwargs.get("sin_cache", ""),
+            kwargs["q_path"],
+            kwargs["k_path"],
+            kwargs["v_path"],
+            kwargs.get("past_k"),
+            kwargs.get("past_v"),
+            kwargs.get("block_row_indices"),
+            kwargs.get("block_col_indices"),
+            kwargs.get("total_seq_len"),
+            kwargs.get("key_total_seq_lens"),
+            kwargs.get("cos_cache", ""),
+            kwargs.get("sin_cache", ""),
         ]
         output = f"{name}/output_0"
         outputs = [output, kwargs.get("present_k", ""), kwargs.get("present_v", "")]
         self.make_node(
-            "SparseAttention", inputs=inputs, outputs=outputs, name=name, domain="com.microsoft",
-            num_heads=self.num_attn_heads, kv_num_heads=self.num_kv_heads, scale=self.attention_attrs["scale"], sparse_block_size=self.attention_attrs["block_sparse"]["sparse_block_size"],
-            do_rotary=self.attention_attrs["use_rotemb_in_attn"], rotary_interleaved=self.rotemb_attrs["interleaved"],
+            "SparseAttention",
+            inputs=inputs,
+            outputs=outputs,
+            name=name,
+            domain="com.microsoft",
+            num_heads=self.num_attn_heads,
+            kv_num_heads=self.num_kv_heads,
+            scale=self.attention_attrs["scale"],
+            sparse_block_size=self.attention_attrs["block_sparse"]["sparse_block_size"],
+            do_rotary=self.attention_attrs["use_rotemb_in_attn"],
+            rotary_interleaved=self.rotemb_attrs["interleaved"],
         )
 
     def make_attention(self, layer_id, attention, root_input, **kwargs):
@@ -1591,7 +2107,9 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
         if self.attention_attrs["use_packed_matmul"]:
             # Combine 3 MatMuls into 1 packed MatMul
             qkv_matmul_basename = f"/model/layers.{layer_id}/attn/qkv_proj/MatMul"
-            qkv_matmul_name = self.make_packed_matmul(attention.q_proj, attention.k_proj, attention.v_proj, qkv_matmul_basename, root_input)
+            qkv_matmul_name = self.make_packed_matmul(
+                attention.q_proj, attention.k_proj, attention.v_proj, qkv_matmul_basename, root_input
+            )
             self.attention_attrs["q_path"] = f"{qkv_matmul_name}/output_0"
         else:
             q_matmul_basename = f"/model/layers.{layer_id}/attn/q_proj/MatMul"
@@ -1613,20 +2131,38 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
         if all_bias_exists and self.attention_attrs["use_packed_matmul"]:
             # Combine 3 Adds into 1 packed Add
             qkv_add_name = f"/model/layers.{layer_id}/attn/qkv_proj/Add"
-            self.make_packed_add(attention.q_proj.bias.detach().numpy(), attention.k_proj.bias.detach().numpy(), attention.v_proj.bias.detach().numpy(), qkv_add_name, root_input=self.attention_attrs["q_path"])
+            self.make_packed_add(
+                attention.q_proj.bias.detach().numpy(),
+                attention.k_proj.bias.detach().numpy(),
+                attention.v_proj.bias.detach().numpy(),
+                qkv_add_name,
+                root_input=self.attention_attrs["q_path"],
+            )
             self.attention_attrs["q_path"] = f"{qkv_add_name}/output_0"
         else:
             if q_bias_exists:
                 q_add_name = f"/model/layers.{layer_id}/attn/q_proj/Add"
-                self.make_add_bias(attention.q_proj.bias.detach().numpy(), q_add_name, root_input=self.attention_attrs["q_path"])
+                self.make_add_bias(
+                    attention.q_proj.bias.detach().numpy(),
+                    q_add_name,
+                    root_input=self.attention_attrs["q_path"],
+                )
                 self.attention_attrs["q_path"] = f"{q_add_name}/output_0"
             if k_bias_exists:
                 k_add_name = f"/model/layers.{layer_id}/attn/k_proj/Add"
-                self.make_add_bias(attention.k_proj.bias.detach().numpy(), k_add_name, root_input=self.attention_attrs["k_path"])
+                self.make_add_bias(
+                    attention.k_proj.bias.detach().numpy(),
+                    k_add_name,
+                    root_input=self.attention_attrs["k_path"],
+                )
                 self.attention_attrs["k_path"] = f"{k_add_name}/output_0"
             if v_bias_exists:
                 v_add_name = f"/model/layers.{layer_id}/attn/v_proj/Add"
-                self.make_add_bias(attention.v_proj.bias.detach().numpy(), v_add_name, root_input=self.attention_attrs["v_path"])
+                self.make_add_bias(
+                    attention.v_proj.bias.detach().numpy(),
+                    v_add_name,
+                    root_input=self.attention_attrs["v_path"],
+                )
                 self.attention_attrs["v_path"] = f"{v_add_name}/output_0"
 
         # Make RotaryEmbedding nodes
@@ -1635,10 +2171,20 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
             cos_cache_name, sin_cache_name = self.make_rotary_embedding_caches(attention.rotary_emb)
         else:
             q_rotary_name = f"/model/layers.{layer_id}/attn/q_rotary/RotaryEmbedding"
-            self.make_rotary_embedding(attention.rotary_emb, q_rotary_name, root_input=self.attention_attrs["q_path"], position_ids=kwargs.get("position_ids", "position_ids"))
+            self.make_rotary_embedding(
+                attention.rotary_emb,
+                q_rotary_name,
+                root_input=self.attention_attrs["q_path"],
+                position_ids=kwargs.get("position_ids", "position_ids"),
+            )
             self.attention_attrs["q_path"] = f"{q_rotary_name}/output_0"
             k_rotary_name = f"/model/layers.{layer_id}/attn/k_rotary/RotaryEmbedding"
-            self.make_rotary_embedding(attention.rotary_emb, k_rotary_name, root_input=self.attention_attrs["k_path"], position_ids=kwargs.get("position_ids", "position_ids"))
+            self.make_rotary_embedding(
+                attention.rotary_emb,
+                k_rotary_name,
+                root_input=self.attention_attrs["k_path"],
+                position_ids=kwargs.get("position_ids", "position_ids"),
+            )
             self.attention_attrs["k_path"] = f"{k_rotary_name}/output_0"
 
         # Make repeat KV nodes (Note: `repeat_kv` needs to be kept since GroupQueryAttention isn't supported for FP32 CUDA)
@@ -1646,21 +2192,36 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
         past_v = f"past_key_values.{layer_id}.value"
         present_k = f"present.{layer_id}.key"
         present_v = f"present.{layer_id}.value"
-        if self.num_attn_heads != self.num_kv_heads and self.attention_attrs["op_type"] == "MultiHeadAttention":
-            self.attention_attrs["k_path"] = self.make_repeat_kv(layer_id, root_input=self.attention_attrs["k_path"], past_kv=past_k, present_kv=present_k)
-            self.attention_attrs["v_path"] = self.make_repeat_kv(layer_id, root_input=self.attention_attrs["v_path"], past_kv=past_v, present_kv=present_v)
+        if (
+            self.num_attn_heads != self.num_kv_heads
+            and self.attention_attrs["op_type"] == "MultiHeadAttention"
+        ):
+            self.attention_attrs["k_path"] = self.make_repeat_kv(
+                layer_id, root_input=self.attention_attrs["k_path"], past_kv=past_k, present_kv=present_k
+            )
+            self.attention_attrs["v_path"] = self.make_repeat_kv(
+                layer_id, root_input=self.attention_attrs["v_path"], past_kv=past_v, present_kv=present_v
+            )
             past_k, past_v, present_k, present_v = "", "", "", ""
 
         # Make attention node (e.g. MultiHeadAttention, GroupQueryAttention, etc.)
         attn_name = f"/model/layers.{layer_id}/attn/{self.attention_attrs['op_type']}"
         self.make_attention_op(
-            attn_name, q_path=self.attention_attrs["q_path"], k_path=self.attention_attrs["k_path"], v_path=self.attention_attrs["v_path"],
-            past_k=past_k, past_v=past_v, present_k=present_k, present_v=present_v,
-            cos_cache=cos_cache_name, sin_cache=sin_cache_name, **kwargs,
+            attn_name,
+            q_path=self.attention_attrs["q_path"],
+            k_path=self.attention_attrs["k_path"],
+            v_path=self.attention_attrs["v_path"],
+            past_k=past_k,
+            past_v=past_v,
+            present_k=present_k,
+            present_v=present_v,
+            cos_cache=cos_cache_name,
+            sin_cache=sin_cache_name,
+            **kwargs,
         )
 
         # Make MatMul node (output projection weight node)
-        o_proj = 'o_proj' if hasattr(attention, 'o_proj') else 'dense'
+        o_proj = "o_proj" if hasattr(attention, "o_proj") else "dense"
         o_matmul_basename = f"/model/layers.{layer_id}/attn/o_proj/MatMul"
         o_weight = eval(f"attention.{o_proj}")
         o_matmul_name = self.make_matmul(o_weight, o_matmul_basename, f"{attn_name}/output_0")
@@ -1677,7 +2238,7 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
 
     def make_attention_unpacked(self, layer_id, attention, root_input, **kwargs):
 
-        qkv_proj = 'qkv_proj' if hasattr(attention, 'qkv_proj') else 'query_key_value'
+        qkv_proj = "qkv_proj" if hasattr(attention, "qkv_proj") else "query_key_value"
         qkv_linear = eval(f"attention.{qkv_proj}")
 
         if hasattr(qkv_linear, "base_layer"):
@@ -1689,7 +2250,7 @@ def make_attention_unpacked(self, layer_id, attention, root_input, **kwargs):
 
         # Delete original packed weights and any references to them (e.g. `del qkv_linear` isn't sufficient)
         del qkv_linear
-        if hasattr(attention, 'qkv_proj'):
+        if hasattr(attention, "qkv_proj"):
             del attention.qkv_proj
         else:
             del attention.query_key_value
@@ -1702,31 +2263,55 @@ def make_attention_unpacked_lora(self, layer_id, attention, qkv_linear, root_inp
 
         # Create Q/K/V base layers
         q_proj = torch.nn.Linear(in_features=q_size, out_features=q_size)
-        q_proj.weight = torch.nn.Parameter(qkv_linear.weight[: q_size, :], requires_grad=False)
-        q_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[: q_size], requires_grad=False)
+        q_proj.weight = torch.nn.Parameter(qkv_linear.weight[:q_size, :], requires_grad=False)
+        q_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[:q_size], requires_grad=False)
+        )
 
         k_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
-        k_proj.weight = torch.nn.Parameter(qkv_linear.weight[q_size : q_size + kv_size, :], requires_grad=False)
-        k_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[q_size : q_size + kv_size], requires_grad=False)
+        k_proj.weight = torch.nn.Parameter(
+            qkv_linear.weight[q_size : q_size + kv_size, :], requires_grad=False
+        )
+        k_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[q_size : q_size + kv_size], requires_grad=False)
+        )
 
         v_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
         v_proj.weight = torch.nn.Parameter(qkv_linear.weight[q_size + kv_size :, :], requires_grad=False)
-        v_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[q_size + kv_size :], requires_grad=False)
+        v_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[q_size + kv_size :], requires_grad=False)
+        )
 
         # Create Q/K/V lora_B layers
         lora_B = qkv_linear.lora_B.default
 
         q_lora_B = torch.nn.Linear(in_features=q_size, out_features=q_size)
-        q_lora_B.weight = torch.nn.Parameter(lora_B.weight[: q_size, :], requires_grad=False)
-        q_lora_B.bias = None if lora_B.bias is None else torch.nn.Parameter(lora_B.bias[: q_size], requires_grad=False)
+        q_lora_B.weight = torch.nn.Parameter(lora_B.weight[:q_size, :], requires_grad=False)
+        q_lora_B.bias = (
+            None if lora_B.bias is None else torch.nn.Parameter(lora_B.bias[:q_size], requires_grad=False)
+        )
 
         k_lora_B = torch.nn.Linear(in_features=q_size, out_features=kv_size)
         k_lora_B.weight = torch.nn.Parameter(lora_B.weight[q_size : q_size + kv_size, :], requires_grad=False)
-        k_lora_B.bias = None if lora_B.bias is None else torch.nn.Parameter(lora_B.bias[q_size : q_size + kv_size], requires_grad=False)
+        k_lora_B.bias = (
+            None
+            if lora_B.bias is None
+            else torch.nn.Parameter(lora_B.bias[q_size : q_size + kv_size], requires_grad=False)
+        )
 
         v_lora_B = torch.nn.Linear(in_features=q_size, out_features=kv_size)
         v_lora_B.weight = torch.nn.Parameter(lora_B.weight[q_size + kv_size :, :], requires_grad=False)
-        v_lora_B.bias = None if lora_B.bias is None else torch.nn.Parameter(lora_B.bias[q_size + kv_size :], requires_grad=False)
+        v_lora_B.bias = (
+            None
+            if lora_B.bias is None
+            else torch.nn.Parameter(lora_B.bias[q_size + kv_size :], requires_grad=False)
+        )
 
         # Create Q/K/V LoRA layers
         attention.q_proj = LoraLayer(q_proj)
@@ -1749,16 +2334,32 @@ def make_attention_unpacked_regular(self, layer_id, attention, qkv_linear, root_
         kv_size = self.num_kv_heads * self.head_size
 
         attention.q_proj = torch.nn.Linear(in_features=q_size, out_features=q_size)
-        attention.q_proj.weight = torch.nn.Parameter(qkv_linear.weight[: q_size, :], requires_grad=False)
-        attention.q_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[: q_size], requires_grad=False)
+        attention.q_proj.weight = torch.nn.Parameter(qkv_linear.weight[:q_size, :], requires_grad=False)
+        attention.q_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[:q_size], requires_grad=False)
+        )
 
         attention.k_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
-        attention.k_proj.weight = torch.nn.Parameter(qkv_linear.weight[q_size : q_size + kv_size, :], requires_grad=False)
-        attention.k_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[q_size : q_size + kv_size], requires_grad=False)
+        attention.k_proj.weight = torch.nn.Parameter(
+            qkv_linear.weight[q_size : q_size + kv_size, :], requires_grad=False
+        )
+        attention.k_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[q_size : q_size + kv_size], requires_grad=False)
+        )
 
         attention.v_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
-        attention.v_proj.weight = torch.nn.Parameter(qkv_linear.weight[q_size + kv_size :, :], requires_grad=False)
-        attention.v_proj.bias = None if qkv_linear.bias is None else torch.nn.Parameter(qkv_linear.bias[q_size + kv_size :], requires_grad=False)
+        attention.v_proj.weight = torch.nn.Parameter(
+            qkv_linear.weight[q_size + kv_size :, :], requires_grad=False
+        )
+        attention.v_proj.bias = (
+            None
+            if qkv_linear.bias is None
+            else torch.nn.Parameter(qkv_linear.bias[q_size + kv_size :], requires_grad=False)
+        )
 
     def make_mlp(self, layer_id, mlp, root_input):
         if self.mlp_attrs["use_proj"]:
@@ -1766,7 +2367,7 @@ def make_mlp(self, layer_id, mlp, root_input):
         elif self.mlp_attrs["use_fc"]:
             self.make_mlp_fc(layer_id, mlp, root_input)
         else:
-            raise NotImplementedError(f"The MLP layer type is not set.")
+            raise NotImplementedError("The MLP layer type is not set.")
 
     def make_mlp_unpacked(self, layer_id, mlp, root_input):
         if hasattr(mlp, "base_layer"):
@@ -1781,27 +2382,41 @@ def make_mlp_unpacked_lora(self, layer_id, mlp, root_input):
 
         # Create GateProj/UpProj base layers
         gate_proj = torch.nn.Linear(in_features=self.hidden_size, out_features=self.intermediate_size)
-        gate_proj.weight = torch.nn.Parameter(mlp.gate_up_proj.weight[ : self.intermediate_size, :], requires_grad=False)
+        gate_proj.weight = torch.nn.Parameter(
+            mlp.gate_up_proj.weight[: self.intermediate_size, :], requires_grad=False
+        )
 
         up_proj = torch.nn.Linear(in_features=self.hidden_size, out_features=self.intermediate_size)
-        up_proj.weight = torch.nn.Parameter(mlp.gate_up_proj.weight[self.intermediate_size :, :], requires_grad=False)
+        up_proj.weight = torch.nn.Parameter(
+            mlp.gate_up_proj.weight[self.intermediate_size :, :], requires_grad=False
+        )
 
         # Create GateProj/UpProj lora_B layers
         lora_B = mlp.lora_B.default
 
         gate_proj_lora_B = torch.nn.Linear(in_features=self.hidden_size, out_features=self.intermediate_size)
-        gate_proj_lora_B.weight = torch.nn.Parameter(lora_B.weight[ : self.intermediate_size, :], requires_grad=False)
+        gate_proj_lora_B.weight = torch.nn.Parameter(
+            lora_B.weight[: self.intermediate_size, :], requires_grad=False
+        )
 
         up_proj_lora_B = torch.nn.Linear(in_features=self.hidden_size, out_features=self.intermediate_size)
-        up_proj_lora_B.weight = torch.nn.Parameter(lora_B.weight[self.intermediate_size :, :], requires_grad=False)
+        up_proj_lora_B.weight = torch.nn.Parameter(
+            lora_B.weight[self.intermediate_size :, :], requires_grad=False
+        )
 
-        # Create GateProj/UpProj LoRA layers
-        mlp.gate_proj = LoraLayer(q_proj)
+        # Create GateProj/UpProj LoRA layers.
+        #
+        # These wrapped `q_proj`/`k_proj` — names that are never bound in this method. Copy-paste from
+        # `make_attention_unpacked_lora`, where `q_proj`/`k_proj` ARE the locals being wrapped. Here the
+        # bases are `gate_proj`/`up_proj`, built above and otherwise completely unused, which is what
+        # makes the intent unambiguous. As written this raised NameError the moment an unpacked-MLP LoRA
+        # model was exported; ruff F821 caught it when the file entered the lint gate in S6.
+        mlp.gate_proj = LoraLayer(gate_proj)
         mlp.gate_proj.lora_A = mlp.gate_up_proj.lora_A
         mlp.gate_proj.lora_B.default = gate_proj_lora_B
         mlp.gate_proj.scaling = mlp.gate_up_proj.scaling
 
-        mlp.up_proj = LoraLayer(k_proj)
+        mlp.up_proj = LoraLayer(up_proj)
         mlp.up_proj.lora_A = mlp.gate_up_proj.lora_A
         mlp.up_proj.lora_B.default = up_proj_lora_B
         mlp.up_proj.scaling = mlp.gate_up_proj.scaling
@@ -1841,7 +2456,12 @@ def make_mlp_proj(self, layer_id, mlp, root_input):
         # Make Mul node after activation
         mul_name = f"/model/layers.{layer_id}/mlp/Mul"
         mul_inputs = [f"{act_fn_name}/output_0", f"{up_name}/output_0"]
-        self.make_mul(mul_name, mul_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_mul(
+            mul_name,
+            mul_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
 
         # Make output MatMul node
         down_proj = getattr(mlp, "down_proj", None) or getattr(mlp, "dense_4h_to_h", None)
@@ -1870,7 +2490,9 @@ def make_mlp_fc(self, layer_id, mlp, root_input):
         fc1_matmul_basename = f"/model/layers.{layer_id}/mlp/fc1/MatMul"
         fc1_matmul_name = self.make_matmul(mlp.fc1, fc1_matmul_basename, root_input)
         fc1_add_name = f"/model/layers.{layer_id}/mlp/fc1/Add"
-        self.make_add_bias(mlp.fc1.bias.detach().numpy(), fc1_add_name, root_input=f"{fc1_matmul_name}/output_0")
+        self.make_add_bias(
+            mlp.fc1.bias.detach().numpy(), fc1_add_name, root_input=f"{fc1_matmul_name}/output_0"
+        )
 
         # Make activation function
         act_fn_name = self.make_activation(layer_id, root_input=f"{fc1_add_name}/output_0")
@@ -1879,7 +2501,9 @@ def make_mlp_fc(self, layer_id, mlp, root_input):
         fc2_matmul_basename = f"/model/layers.{layer_id}/mlp/fc2/MatMul"
         fc2_matmul_name = self.make_matmul(mlp.fc2, fc2_matmul_basename, root_input=f"{act_fn_name}/output_0")
         fc2_add_name = f"/model/layers.{layer_id}/mlp/fc2/Add"
-        self.make_add_bias(mlp.fc2.bias.detach().numpy(), fc2_add_name, root_input=f"{fc2_matmul_name}/output_0")
+        self.make_add_bias(
+            mlp.fc2.bias.detach().numpy(), fc2_add_name, root_input=f"{fc2_matmul_name}/output_0"
+        )
 
         # Assign output 0 of MLP layer as output of last layer
         self.mlp_attrs["output_0"] = f"{fc2_add_name}/output_0"
@@ -1922,29 +2546,49 @@ def make_block_sparse_moe(self, layer_id, bsm, root_input):
         self.make_shape(shape_name, f"{gate_name}/output_0", shape=[3])
 
         gather_name = f"{gate_ops_base}/Gather"
-        self.make_gather(gather_name, [f"{shape_name}/output_0", "/model/constants/TensorProto.INT64/0D/2"], axis=0)
+        self.make_gather(
+            gather_name, [f"{shape_name}/output_0", "/model/constants/TensorProto.INT64/0D/2"], axis=0
+        )
 
         unsqueeze_name = f"{gate_ops_base}/Unsqueeze"
-        self.make_unsqueeze(unsqueeze_name, [f"{gather_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"], dtype=TensorProto.INT64, shape=[1])
+        self.make_unsqueeze(
+            unsqueeze_name,
+            [f"{gather_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"],
+            dtype=TensorProto.INT64,
+            shape=[1],
+        )
 
         concat_name = f"{gate_ops_base}/Concat"
-        self.make_concat(concat_name, ["/model/constants/TensorProto.INT64/1D/-1", f"{unsqueeze_name}/output_0"], dtype=TensorProto.INT64, shape=[2], axis=0)
+        self.make_concat(
+            concat_name,
+            ["/model/constants/TensorProto.INT64/1D/-1", f"{unsqueeze_name}/output_0"],
+            dtype=TensorProto.INT64,
+            shape=[2],
+            axis=0,
+        )
 
         gate_reshape_name = f"{gate_ops_base}/Reshape"
-        self.make_reshape(gate_reshape_name, [f"{gate_name}/output_0", f"{concat_name}/output_0"], dtype=self.io_dtype, shape=['num_rows', num_experts])
+        self.make_reshape(
+            gate_reshape_name,
+            [f"{gate_name}/output_0", f"{concat_name}/output_0"],
+            dtype=self.io_dtype,
+            shape=["num_rows", num_experts],
+        )
 
         def quant_dequant(weights, quant_mode: bool = True):
             type = torch.quint4x2 if quant_mode else torch.int8
             processed_q_weight = None
             torch_weight_scales = None
             try:
-                import tensorrt_llm
-
                 _, processed_q_weight, torch_weight_scales = (
-                    torch.ops.trtllm._symmetric_quantize_last_axis_of_batched_matrix(weights.T.cpu().contiguous(), type)
+                    torch.ops.trtllm._symmetric_quantize_last_axis_of_batched_matrix(
+                        weights.T.cpu().contiguous(), type
+                    )
                 )
             except:
-                raise RuntimeError("tensorrt_llm is needed to use torch.ops.trtllm._symmetric_quantize_last_axis_of_batched_matrix()")
+                raise RuntimeError(
+                    "tensorrt_llm is needed to use torch.ops.trtllm._symmetric_quantize_last_axis_of_batched_matrix()"
+                )
 
             return torch_weight_scales.to(torch.float16), processed_q_weight
 
@@ -1957,9 +2601,9 @@ def quant_dequant(weights, quant_mode: bool = True):
 
         for i in range(num_experts):
             # Quantize the weights with uint8
-            w1_scale, pre_qweight1= quant_dequant(bsm.experts[i].w1.weight, use_int4)
-            w2_scale, pre_qweight2= quant_dequant(bsm.experts[i].w2.weight, use_int4)
-            w3_scale, pre_qweight3= quant_dequant(bsm.experts[i].w3.weight, use_int4)
+            w1_scale, pre_qweight1 = quant_dequant(bsm.experts[i].w1.weight, use_int4)
+            w2_scale, pre_qweight2 = quant_dequant(bsm.experts[i].w2.weight, use_int4)
+            w3_scale, pre_qweight3 = quant_dequant(bsm.experts[i].w3.weight, use_int4)
 
             w1_list.append(pre_qweight1)
             w2_list.append(pre_qweight2)
@@ -1990,19 +2634,36 @@ def make_moe_external_tensor(w_list, moe_expert_name, numpy_type):
         make_moe_external_tensor(w2_scale_list, moe_expert_scales_2_name, self.to_numpy_dtype[self.io_dtype])
         make_moe_external_tensor(w3_scale_list, moe_expert_scales_3_name, self.to_numpy_dtype[self.io_dtype])
 
-        bias_ph = "" # Placeholder for bias
-        inputs = [root_input, f"{gate_reshape_name}/output_0", \
-                  moe_expert_weight_1_name, moe_expert_scales_1_name, bias_ph, \
-                  moe_expert_weight_2_name, moe_expert_scales_2_name, bias_ph, \
-                  moe_expert_weight_3_name, moe_expert_scales_3_name]
+        bias_ph = ""  # Placeholder for bias
+        inputs = [
+            root_input,
+            f"{gate_reshape_name}/output_0",
+            moe_expert_weight_1_name,
+            moe_expert_scales_1_name,
+            bias_ph,
+            moe_expert_weight_2_name,
+            moe_expert_scales_2_name,
+            bias_ph,
+            moe_expert_weight_3_name,
+            moe_expert_scales_3_name,
+        ]
         output = f"{moe_name}/output_0"
 
         op_type = "QMoE"
-        self.make_node(op_type, inputs=inputs, outputs=[output], name=moe_name, domain="com.microsoft",
-                       k=top_k, activation_type=activation_type, normalize_routing_weights=normalize_routing_weights,
-                       use_sparse_mixer=use_sparse_mixer, expert_weight_bits=(4 if use_int4 else 8))
+        self.make_node(
+            op_type,
+            inputs=inputs,
+            outputs=[output],
+            name=moe_name,
+            domain="com.microsoft",
+            k=top_k,
+            activation_type=activation_type,
+            normalize_routing_weights=normalize_routing_weights,
+            use_sparse_mixer=use_sparse_mixer,
+            expert_weight_bits=(4 if use_int4 else 8),
+        )
 
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+        self.make_value_info(output, self.io_dtype, shape=["batch_size", "sequence_length", self.hidden_size])
 
         # Assign output 0 of previous MoE as root input to next SkipLayerNorm
         self.layernorm_attrs["skip_input"] = output
@@ -2018,11 +2679,18 @@ def make_activation_with_mul(self, layer_id, root_input, activation, domain):
         act_name = f"/model/layers.{layer_id}/mlp/act_fn/{activation}"
         act_output = f"{act_name}/output_0"
         self.make_node(activation, inputs=[root_input], outputs=[act_output], name=act_name, domain=domain)
-        self.make_value_info(act_output, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_value_info(
+            act_output, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size]
+        )
 
         mul_act_name = f"/model/layers.{layer_id}/mlp/act_fn/Mul"
         mul_act_inputs = [root_input, act_output]
-        self.make_mul(mul_act_name, mul_act_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_mul(
+            mul_act_name,
+            mul_act_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
 
         return mul_act_name
 
@@ -2034,8 +2702,12 @@ def make_gelu(self, layer_id, root_input, activation):
         #        GeluAct
         gelu_name = f"/model/layers.{layer_id}/mlp/act_fn/{activation}"
         output = f"{gelu_name}/output_0"
-        self.make_node(activation, inputs=[root_input], outputs=[output], name=gelu_name, domain="com.microsoft")
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.intermediate_size])
+        self.make_node(
+            activation, inputs=[root_input], outputs=[output], name=gelu_name, domain="com.microsoft"
+        )
+        self.make_value_info(
+            output, self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size]
+        )
 
         return gelu_name
 
@@ -2043,7 +2715,9 @@ def make_relu(self, layer_id, root_input, activation):
         relu_name = f"/model/layers.{layer_id}/mlp/act_fn/{activation}"
         output = f"{relu_name}/output_0"
         self.make_node(activation, inputs=[root_input], outputs=[output], name=relu_name, domain="")
-        self.make_value_info(output, self.io_dtype, shape=['batch_size', 'sequence_length', self.intermediate_size])
+        self.make_value_info(
+            output, self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size]
+        )
         return relu_name
 
     def make_relu_squared(self, layer_id, root_input, activation):
@@ -2052,12 +2726,18 @@ def make_relu_squared(self, layer_id, root_input, activation):
         pow_name = f"{basename}/pow"
         pow_inputs = [f"{relu_name}/output_0", "/model/constants/TensorProto.INT32/1D/2"]
         self.make_node("Pow", inputs=pow_inputs, outputs=[f"{pow_name}/output_0"], name=pow_name, domain="")
-        self.make_value_info(f"{pow_name}/output_0", self.io_dtype, shape=['batch_size', 'sequence_length', self.intermediate_size])
+        self.make_value_info(
+            f"{pow_name}/output_0",
+            self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         return pow_name
 
     def make_activation(self, layer_id, root_input):
         if self.activation in {"silu", "swish", "swiglu"}:
-            output_name = self.make_activation_with_mul(layer_id, root_input, activation="Sigmoid", domain=None)
+            output_name = self.make_activation_with_mul(
+                layer_id, root_input, activation="Sigmoid", domain=None
+            )
         elif self.activation in {"gelu_new", "gelu_fast", "gelu_pytorch_tanh"}:
             output_name = self.make_gelu(layer_id, root_input, activation="FastGelu")
         elif self.activation in {"gelu"}:
@@ -2069,7 +2749,9 @@ def make_activation(self, layer_id, root_input):
         elif self.activation in {"relu2"}:
             output_name = self.make_relu_squared(layer_id, root_input, activation="Relu2")
         else:
-            raise NotImplementedError(f"The {self.activation} activation function is not currently supported.")
+            raise NotImplementedError(
+                f"The {self.activation} activation function is not currently supported."
+            )
         return output_name
 
     def make_lm_head(self, lm_head):
@@ -2079,18 +2761,30 @@ def make_lm_head(self, lm_head):
 
         matmul_basename = "/lm_head/MatMul"
         root_input = self.layernorm_attrs["output_0"]
-        matmul_name = self.make_matmul(lm_head, matmul_basename, root_input, logits=not bias_exists and not scale_exists)
+        matmul_name = self.make_matmul(
+            lm_head, matmul_basename, root_input, logits=not bias_exists and not scale_exists
+        )
 
         if bias_exists:
             add_name = "/lm_head/Add"
-            self.make_add_bias(lm_head.bias.detach().numpy(), add_name, root_input=f"{matmul_name}/output_0", logits=not scale_exists)
+            self.make_add_bias(
+                lm_head.bias.detach().numpy(),
+                add_name,
+                root_input=f"{matmul_name}/output_0",
+                logits=not scale_exists,
+            )
 
         if scale_exists:
             mul_name = "/lm_head/Mul"
-            mul_inputs = [f"{matmul_name if not bias_exists else add_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}"]
+            mul_inputs = [
+                f"{matmul_name if not bias_exists else add_name}/output_0",
+                f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}",
+            ]
             mul_output = "logits" if not mask_exists else f"{mul_name}/output_0"
-            self.make_node('Mul', inputs=mul_inputs, outputs=[mul_output], name=mul_name)
-            self.make_value_info(mul_output, self.io_dtype, shape=['batch_size', 'sequence_length', self.vocab_size])
+            self.make_node("Mul", inputs=mul_inputs, outputs=[mul_output], name=mul_name)
+            self.make_value_info(
+                mul_output, self.io_dtype, shape=["batch_size", "sequence_length", self.vocab_size]
+            )
 
         if mask_exists:
             # Save logits mask as initializer
@@ -2098,17 +2792,35 @@ def make_lm_head(self, lm_head):
             self.make_external_tensor(self.lm_head_attrs["mask"].detach().numpy(), logits_mask_name)
 
             where_name = "/lm_head/Where"
-            where_inputs = [logits_mask_name, f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{np.finfo(self.to_numpy_dtype[self.io_dtype]).min}", f"{mul_name}/output_0"]
+            where_inputs = [
+                logits_mask_name,
+                f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{np.finfo(self.to_numpy_dtype[self.io_dtype]).min}",
+                f"{mul_name}/output_0",
+            ]
             where_output = "logits"
-            self.make_node('Where', inputs=where_inputs, outputs=[where_output], name=where_name)
-            self.make_value_info(where_output, self.io_dtype, shape=['batch_size', 'sequence_length', self.vocab_size])
+            self.make_node("Where", inputs=where_inputs, outputs=[where_output], name=where_name)
+            self.make_value_info(
+                where_output, self.io_dtype, shape=["batch_size", "sequence_length", self.vocab_size]
+            )
 
     def make_layer(self, layer_id, layer):
         # Each LLM decoder layer is typically defined as:
         # input_layernorm --> attention --> MLP --> output_layernorm
-        self.make_layernorm(layer_id, layer.input_layernorm, skip=not self.layernorm_attrs["first_layernorm"], simple=self.layernorm_attrs["simple"], location="input")
+        self.make_layernorm(
+            layer_id,
+            layer.input_layernorm,
+            skip=not self.layernorm_attrs["first_layernorm"],
+            simple=self.layernorm_attrs["simple"],
+            location="input",
+        )
         self.make_attention(layer_id, layer.self_attn, root_input=self.layernorm_attrs["output_0"])
-        self.make_layernorm(layer_id, layer.post_attention_layernorm, skip=True, simple=self.layernorm_attrs["simple"], location="post_attention")
+        self.make_layernorm(
+            layer_id,
+            layer.post_attention_layernorm,
+            skip=True,
+            simple=self.layernorm_attrs["simple"],
+            location="post_attention",
+        )
         self.make_mlp(layer_id, layer.mlp, root_input=self.layernorm_attrs["output_0"])
 
         self.layernorm_attrs["first_layernorm"] = False
@@ -2130,7 +2842,16 @@ def make_model(self, input_path):
                 from gguf_model import GGUFModel
             except:
                 from onnxruntime_genai.models.gguf_model import GGUFModel
-            model = GGUFModel.from_pretrained(self.model_type, input_path, self.head_size, self.hidden_size, self.intermediate_size, self.num_attn_heads, self.num_kv_heads, self.vocab_size)
+            model = GGUFModel.from_pretrained(
+                self.model_type,
+                input_path,
+                self.head_size,
+                self.hidden_size,
+                self.intermediate_size,
+                self.num_attn_heads,
+                self.num_kv_heads,
+                self.vocab_size,
+            )
             self.layernorm_attrs["add_offset"] = 0  # add offset already done for GGUF models
         elif self.quant_type is not None:
             # Load quantized PyTorch model
@@ -2153,13 +2874,24 @@ def make_model(self, input_path):
             )
         else:
             # Load PyTorch model
-            extra_kwargs = {"num_hidden_layers": self.num_layers} if "num_hidden_layers" in self.extra_options else {}
-            model = AutoModelForCausalLM.from_pretrained(self.model_name_or_path, cache_dir=self.cache_dir, token=self.hf_token, trust_remote_code=True, **extra_kwargs)
+            extra_kwargs = (
+                {"num_hidden_layers": self.num_layers} if "num_hidden_layers" in self.extra_options else {}
+            )
+            model = AutoModelForCausalLM.from_pretrained(
+                self.model_name_or_path,
+                cache_dir=self.cache_dir,
+                token=self.hf_token,
+                trust_remote_code=True,
+                **extra_kwargs,
+            )
 
         if "adapter_path" in self.extra_options:
             from peft import PeftModel
-            model = PeftModel.from_pretrained(model, self.extra_options["adapter_path"], cache_dir=self.cache_dir, token=self.hf_token)
-            
+
+            model = PeftModel.from_pretrained(
+                model, self.extra_options["adapter_path"], cache_dir=self.cache_dir, token=self.hf_token
+            )
+
             if hasattr(model, "peft_config"):
                 self.lora_layers_keywords = ["lora"]
                 self.lora_layers_keywords = model.peft_config["default"].target_modules
@@ -2167,8 +2899,9 @@ def make_model(self, input_path):
         # Loop through model and map each module to ONNX/ORT ops
         self.layer_id = 0
         for module in model.modules():
-
-            if isinstance(module, torch.nn.Embedding) or (hasattr(model, "embedding") and module == model.embedding):
+            if isinstance(module, torch.nn.Embedding) or (
+                hasattr(model, "embedding") and module == model.embedding
+            ):
                 # Checks (Hugging Face logic) or (GGUF logic)
                 if not self.exclude_embeds:
                     # Embedding layer
@@ -2179,7 +2912,10 @@ def make_model(self, input_path):
                     self.layernorm_attrs["root_input"] = "inputs_embeds"
                     self.layernorm_attrs["skip_input"] = "inputs_embeds"
 
-            elif (module.__class__.__name__.endswith("DecoderLayer") or module.__class__.__name__.endswith("GLMBlock")) and self.layer_id < self.num_layers:
+            elif (
+                module.__class__.__name__.endswith("DecoderLayer")
+                or module.__class__.__name__.endswith("GLMBlock")
+            ) and self.layer_id < self.num_layers:
                 # Each decoder layer of model
                 print(f"Reading decoder layer {self.layer_id}")
                 self.make_layer(self.layer_id, module)
@@ -2188,9 +2924,17 @@ def make_model(self, input_path):
             elif self.layer_id == self.num_layers and self.has_final_norm(module, model):
                 # SkipLayerNorm after last decoder layer (MatMul --> SkipLayerNorm)
                 print("Reading final norm")
-                self.make_layernorm(self.layer_id, module, skip=True, simple=self.layernorm_attrs["simple"], location="final_norm")
-            
-            elif (isinstance(module, torch.nn.Linear) and module.out_features == self.vocab_size) or (hasattr(model, "lm_head") and module == model.lm_head):
+                self.make_layernorm(
+                    self.layer_id,
+                    module,
+                    skip=True,
+                    simple=self.layernorm_attrs["simple"],
+                    location="final_norm",
+                )
+
+            elif (isinstance(module, torch.nn.Linear) and module.out_features == self.vocab_size) or (
+                hasattr(model, "lm_head") and module == model.lm_head
+            ):
                 # Checks (Hugging Face logic) or (GGUF logic)
                 if not self.exclude_lm_head:
                     # Language modeling head (SkipLayerNorm --> logits)
@@ -2200,13 +2944,22 @@ def make_model(self, input_path):
         del model
 
     def has_final_norm(self, module, model):
-       # Hugging Face names
-       hf_norm = hasattr(model, "model") and hasattr(model.model, "norm") and module == model.model.norm
-       hf_final_layernorm = hasattr(model, "model") and hasattr(model.model, "final_layernorm") and module == model.model.final_layernorm
-       hf_transformer_final_layernorm = hasattr(model, "transformer") and hasattr(model.transformer, "encoder") and hasattr(model.transformer.encoder, "final_layernorm") and module == model.transformer.encoder.final_layernorm
-       # GGUF names
-       gguf_final_norm = hasattr(model, "final_norm") and module == model.final_norm
-       return hf_norm or hf_final_layernorm or hf_transformer_final_layernorm or gguf_final_norm
+        # Hugging Face names
+        hf_norm = hasattr(model, "model") and hasattr(model.model, "norm") and module == model.model.norm
+        hf_final_layernorm = (
+            hasattr(model, "model")
+            and hasattr(model.model, "final_layernorm")
+            and module == model.model.final_layernorm
+        )
+        hf_transformer_final_layernorm = (
+            hasattr(model, "transformer")
+            and hasattr(model.transformer, "encoder")
+            and hasattr(model.transformer.encoder, "final_layernorm")
+            and module == model.transformer.encoder.final_layernorm
+        )
+        # GGUF names
+        gguf_final_norm = hasattr(model, "final_norm") and module == model.final_norm
+        return hf_norm or hf_final_layernorm or hf_transformer_final_layernorm or gguf_final_norm
 
     def make_preprocessing_nodes(self):
         self.make_attention_mask_reformatting()
@@ -2305,18 +3058,27 @@ def make_attention_mask_reformatting_for_mha(self):
         past_key_gather_name = self.make_past_key_subgraph(past_key_basename)
 
         # Make common attention mask subgraphs, one each for input_ids and attention_mask
-        shared_unsqueeze_name, end_expand_name = self.make_input_ids_subgraph(input_ids_basename, past_key_gather_name)
+        shared_unsqueeze_name, end_expand_name = self.make_input_ids_subgraph(
+            input_ids_basename, past_key_gather_name
+        )
         end_where_name = self.make_attention_mask_subgraph(attn_mask_basename, shared_unsqueeze_name)
 
         end_add_name = f"{basename}/Add"
         end_add_inputs = [f"{end_where_name}/output_0", f"{end_expand_name}/output_0"]
         end_add_shape = ["batch_size", 1, "source_sequence_length", "target_sequence_length"]
-        self.make_add(end_add_name, end_add_inputs, dtype=self.io_dtype, shape=end_add_shape) # Shape of mask is now (B, 1, S, T)
+        self.make_add(
+            end_add_name, end_add_inputs, dtype=self.io_dtype, shape=end_add_shape
+        )  # Shape of mask is now (B, 1, S, T)
 
         tile_name = f"{basename}/Tile"
-        tile_inputs = [f"{end_add_name}/output_0", f"/model/constants/TensorProto.INT64/1D/1, {self.num_attn_heads}, 1, 1"]
+        tile_inputs = [
+            f"{end_add_name}/output_0",
+            f"/model/constants/TensorProto.INT64/1D/1, {self.num_attn_heads}, 1, 1",
+        ]
         tile_shape = ["batch_size", self.num_attn_heads, "source_sequence_length", "target_sequence_length"]
-        self.make_tile(tile_name, tile_inputs, dtype=self.io_dtype, shape=tile_shape) # Shape of mask is now (B, N, S, T)
+        self.make_tile(
+            tile_name, tile_inputs, dtype=self.io_dtype, shape=tile_shape
+        )  # Shape of mask is now (B, N, S, T)
 
         self.mask_attrs["mask_name"] = tile_name
 
@@ -2342,7 +3104,9 @@ def make_input_ids_subgraph(self, basename, past_key_gather_name):
         shared_add_name = f"{basename}/Add_1"
         shared_add_inputs = [f"{basename}/Gather_2/output_0", f"{past_key_gather_name}/output_0"]
         self.make_add(shared_add_name, shared_add_inputs, dtype=TensorProto.INT64, shape=[])
-        unsqueeze_3_name = f"{basename}/Unsqueeze_3"  # shared unsqueeze for input_ids and past_key_values.0.key
+        unsqueeze_3_name = (
+            f"{basename}/Unsqueeze_3"  # shared unsqueeze for input_ids and past_key_values.0.key
+        )
         unsqueeze_3_inputs = [f"{shared_add_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"]
         self.make_unsqueeze(unsqueeze_3_name, unsqueeze_3_inputs, dtype=TensorProto.INT64, shape=[1])
 
@@ -2365,14 +3129,27 @@ def make_input_ids_subgraph(self, basename, past_key_gather_name):
         self.make_concat(concat_2_name, concat_inputs, dtype=TensorProto.INT64, shape=[2], axis=0)
         constant_shape_name = f"{basename}/ConstantOfShape_2"
         constant_shape_numpy_dtype = self.to_numpy_dtype[self.io_dtype]
-        constant_shape_value = numpy_helper.from_array(np.array([np.finfo(constant_shape_numpy_dtype).min], dtype=constant_shape_numpy_dtype))
-        self.make_constant_of_shape(constant_shape_name, f"{concat_2_name}/output_0", value=constant_shape_value, dtype=self.io_dtype, shape=['unk', 'unk'])
+        constant_shape_value = numpy_helper.from_array(
+            np.array([np.finfo(constant_shape_numpy_dtype).min], dtype=constant_shape_numpy_dtype)
+        )
+        self.make_constant_of_shape(
+            constant_shape_name,
+            f"{concat_2_name}/output_0",
+            value=constant_shape_value,
+            dtype=self.io_dtype,
+            shape=["unk", "unk"],
+        )
 
         # Top path
         shape_4_name = f"{basename}/Shape_4"
         self.make_shape(shape_4_name, f"{constant_shape_name}/output_0", shape=[2])
         slice_1_name = f"{basename}/Slice_1"
-        slice_1_inputs = [f"{shape_4_name}/output_0", "/model/constants/TensorProto.INT64/1D/-1", f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}", "/model/constants/TensorProto.INT64/1D/0"]
+        slice_1_inputs = [
+            f"{shape_4_name}/output_0",
+            "/model/constants/TensorProto.INT64/1D/-1",
+            f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}",
+            "/model/constants/TensorProto.INT64/1D/0",
+        ]
         self.make_slice(slice_1_name, slice_1_inputs, dtype=TensorProto.INT64, shape=[1])
         squeeze_1_name = f"{basename}/Squeeze_1"
         squeeze_1_inputs = [f"{slice_1_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"]
@@ -2388,13 +3165,22 @@ def make_input_ids_subgraph(self, basename, past_key_gather_name):
         shape_5_name = f"{basename}/Shape_5"
         self.make_shape(shape_5_name, f"{constant_shape_name}/output_0", shape=[2])
         slice_2_name = f"{basename}/Slice_2"
-        slice_2_inputs = [f"{shape_5_name}/output_0", "/model/constants/TensorProto.INT64/1D/-1", f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}", "/model/constants/TensorProto.INT64/1D/0"]
+        slice_2_inputs = [
+            f"{shape_5_name}/output_0",
+            "/model/constants/TensorProto.INT64/1D/-1",
+            f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}",
+            "/model/constants/TensorProto.INT64/1D/0",
+        ]
         self.make_slice(slice_2_name, slice_2_inputs, dtype=TensorProto.INT64, shape=[1])
         squeeze_2_name = f"{basename}/Squeeze_2"
         squeeze_2_inputs = [f"{slice_2_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"]
         self.make_squeeze(squeeze_2_name, squeeze_2_inputs)
         range_name = f"{basename}/Range"
-        range_inputs = ["/model/constants/TensorProto.INT64/0D/0", f"{squeeze_2_name}/output_0", "/model/constants/TensorProto.INT64/0D/1"]
+        range_inputs = [
+            "/model/constants/TensorProto.INT64/0D/0",
+            f"{squeeze_2_name}/output_0",
+            "/model/constants/TensorProto.INT64/0D/1",
+        ]
         self.make_range(range_name, range_inputs)
         add_2_name = f"{basename}/Add_2"
         add_inputs = [f"{range_name}/output_0", "/model/constants/TensorProto.INT64/0D/1"]
@@ -2408,7 +3194,11 @@ def make_input_ids_subgraph(self, basename, past_key_gather_name):
         less_inputs = [f"{range_name}/output_0", f"{reshape_name}/output_0"]
         self.make_less(less_name, less_inputs)
         where_2_name = f"{basename}/Where_2"
-        where_2_inputs = [f"{less_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/0", f"{constant_shape_name}/output_0"]
+        where_2_inputs = [
+            f"{less_name}/output_0",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/0",
+            f"{constant_shape_name}/output_0",
+        ]
         self.make_where(where_2_name, where_2_inputs, dtype=self.io_dtype, shape=None)
         unsqueeze_8_name = f"{basename}/Unsqueeze_8"
         unsqueeze_8_inputs = [f"{where_2_name}/output_0", "/model/constants/TensorProto.INT64/1D/0"]
@@ -2417,7 +3207,13 @@ def make_input_ids_subgraph(self, basename, past_key_gather_name):
         unsqueeze_9_inputs = [f"{unsqueeze_8_name}/output_0", "/model/constants/TensorProto.INT64/1D/1"]
         self.make_unsqueeze(unsqueeze_9_name, unsqueeze_9_inputs, dtype=self.io_dtype, shape=None)
 
-        expand_name = self.make_common_mask_reformat_subgraph(basename, root_input="input_ids" if not self.exclude_embeds else "inputs_embeds", unsqueeze_for_concat=unsqueeze_3_name, unsqueeze_for_expand=unsqueeze_9_name, input_ids_subgraph=True)
+        expand_name = self.make_common_mask_reformat_subgraph(
+            basename,
+            root_input="input_ids" if not self.exclude_embeds else "inputs_embeds",
+            unsqueeze_for_concat=unsqueeze_3_name,
+            unsqueeze_for_expand=unsqueeze_9_name,
+            input_ids_subgraph=True,
+        )
         return unsqueeze_6_name, expand_name
 
     def make_attention_mask_subgraph(self, basename, unsqueeze_for_concat):
@@ -2427,34 +3223,57 @@ def make_attention_mask_subgraph(self, basename, unsqueeze_for_concat):
 
         unsqueeze_3_name = f"{basename}/Unsqueeze_3"
         unsqueeze_3_inputs = ["attention_mask", "/model/constants/TensorProto.INT64/1D/1"]
-        attention_mask_shape.insert(1, 1) # ['batch_size', 'total_sequence_length'] --> ['batch_size', 1, 'total_sequence_length']
-        self.make_unsqueeze(unsqueeze_3_name, unsqueeze_3_inputs, dtype=TensorProto.INT64, shape=attention_mask_shape)
+        attention_mask_shape.insert(
+            1, 1
+        )  # ['batch_size', 'total_sequence_length'] --> ['batch_size', 1, 'total_sequence_length']
+        self.make_unsqueeze(
+            unsqueeze_3_name, unsqueeze_3_inputs, dtype=TensorProto.INT64, shape=attention_mask_shape
+        )
         unsqueeze_4_name = f"{basename}/Unsqueeze_4"
         unsqueeze_4_inputs = [f"{unsqueeze_3_name}/output_0", "/model/constants/TensorProto.INT64/1D/2"]
-        attention_mask_shape.insert(1, 1) # ['batch_size', 1, 'total_sequence_length'] --> ['batch_size', 1, 1, 'total_sequence_length']
-        self.make_unsqueeze(unsqueeze_4_name, unsqueeze_4_inputs, dtype=TensorProto.INT64, shape=attention_mask_shape)
+        attention_mask_shape.insert(
+            1, 1
+        )  # ['batch_size', 1, 'total_sequence_length'] --> ['batch_size', 1, 1, 'total_sequence_length']
+        self.make_unsqueeze(
+            unsqueeze_4_name, unsqueeze_4_inputs, dtype=TensorProto.INT64, shape=attention_mask_shape
+        )
 
         # Make the main subgraph
-        expand_name = self.make_common_mask_reformat_subgraph(basename, root_input="attention_mask", unsqueeze_for_concat=unsqueeze_for_concat, unsqueeze_for_expand=unsqueeze_4_name)
+        expand_name = self.make_common_mask_reformat_subgraph(
+            basename,
+            root_input="attention_mask",
+            unsqueeze_for_concat=unsqueeze_for_concat,
+            unsqueeze_for_expand=unsqueeze_4_name,
+        )
 
         # Make the additional subgraph after Expand:
         #                      +-----------------+
         #                      |                 |
         # Expand --> Cast --> Sub --> Cast --> Where
         cast_1_name = f"{basename}/Cast_1"
-        self.make_cast(cast_1_name, f"{expand_name}/output_0", dtype=self.io_dtype, shape=["unk", "unk", "unk", "unk"])
+        self.make_cast(
+            cast_1_name, f"{expand_name}/output_0", dtype=self.io_dtype, shape=["unk", "unk", "unk", "unk"]
+        )
         sub_name = f"{basename}/Sub"
         sub_inputs = [f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/1", f"{cast_1_name}/output_0"]
         self.make_sub(sub_name, sub_inputs, dtype=self.io_dtype, shape=["unk", "unk", "unk", "unk"])
         cast_2_name = f"{basename}/Cast_2"
-        self.make_cast(cast_2_name, f"{sub_name}/output_0", dtype=TensorProto.BOOL, shape=["unk", "unk", "unk", "unk"])
+        self.make_cast(
+            cast_2_name, f"{sub_name}/output_0", dtype=TensorProto.BOOL, shape=["unk", "unk", "unk", "unk"]
+        )
         where_2_name = f"{basename}/Where_2"
-        where_2_inputs = [f"{cast_2_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{np.finfo(self.to_numpy_dtype[self.io_dtype]).min}", f"{sub_name}/output_0"]
+        where_2_inputs = [
+            f"{cast_2_name}/output_0",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{np.finfo(self.to_numpy_dtype[self.io_dtype]).min}",
+            f"{sub_name}/output_0",
+        ]
         self.make_where(where_2_name, where_2_inputs, dtype=self.io_dtype, shape=["unk", "unk", "unk", "unk"])
 
         return where_2_name
 
-    def make_common_mask_reformat_subgraph(self, basename, root_input, unsqueeze_for_concat, unsqueeze_for_expand, input_ids_subgraph=False):
+    def make_common_mask_reformat_subgraph(
+        self, basename, root_input, unsqueeze_for_concat, unsqueeze_for_expand, input_ids_subgraph=False
+    ):
         #             root_input
         #            /         \
         #         Shape       Shape
@@ -2492,9 +3311,13 @@ def make_common_mask_reformat_subgraph(self, basename, root_input, unsqueeze_for
         #                              Expand
 
         shape_1_name = f"{basename}/Shape_1"
-        self.make_shape(shape_1_name, root_input, shape=[3] if self.exclude_embeds and input_ids_subgraph else [2])
+        self.make_shape(
+            shape_1_name, root_input, shape=[3] if self.exclude_embeds and input_ids_subgraph else [2]
+        )
         shape_2_name = f"{basename}/Shape_2"
-        self.make_shape(shape_2_name, root_input, shape=[3] if self.exclude_embeds and input_ids_subgraph else [2])
+        self.make_shape(
+            shape_2_name, root_input, shape=[3] if self.exclude_embeds and input_ids_subgraph else [2]
+        )
         gather_1_name = f"{basename}/Gather_1"
         gather_1_inputs = [f"{shape_1_name}/output_0", "/model/constants/TensorProto.INT64/0D/0"]
         self.make_gather(gather_1_name, gather_1_inputs, axis=0)
@@ -2510,14 +3333,26 @@ def make_common_mask_reformat_subgraph(self, basename, root_input, unsqueeze_for
 
         concat_name = f"{basename}/Concat" if not input_ids_subgraph else f"{basename}/Concat_1"
         concat_first_two_inputs = [f"{unsqueeze_1_name}/output_0", "/model/constants/TensorProto.INT64/1D/1"]
-        concat_last_two_inputs = [f"{unsqueeze_for_concat}/output_0", f"{unsqueeze_2_name}/output_0"] if not input_ids_subgraph else [f"{unsqueeze_2_name}/output_0", f"{unsqueeze_for_concat}/output_0"]
+        concat_last_two_inputs = (
+            [f"{unsqueeze_for_concat}/output_0", f"{unsqueeze_2_name}/output_0"]
+            if not input_ids_subgraph
+            else [f"{unsqueeze_2_name}/output_0", f"{unsqueeze_for_concat}/output_0"]
+        )
         concat_inputs = concat_first_two_inputs + concat_last_two_inputs
         self.make_concat(concat_name, concat_inputs, dtype=TensorProto.INT64, shape=[4], axis=0)
         shape_3_name = f"{basename}/Shape_3"
         self.make_shape(shape_3_name, f"{concat_name}/output_0", shape=[1])
-        constant_shape_name = f"{basename}/ConstantOfShape" if not input_ids_subgraph else f"{basename}/ConstantOfShape_1"
+        constant_shape_name = (
+            f"{basename}/ConstantOfShape" if not input_ids_subgraph else f"{basename}/ConstantOfShape_1"
+        )
         constant_shape_value = numpy_helper.from_array(np.array([1], dtype="int64"))
-        self.make_constant_of_shape(constant_shape_name, f"{shape_3_name}/output_0", value=constant_shape_value, dtype=TensorProto.INT64, shape=["unk"])
+        self.make_constant_of_shape(
+            constant_shape_name,
+            f"{shape_3_name}/output_0",
+            value=constant_shape_value,
+            dtype=TensorProto.INT64,
+            shape=["unk"],
+        )
         mul_name = f"{basename}/Mul"
         mul_inputs = [f"{constant_shape_name}/output_0", "/model/constants/TensorProto.INT64/0D/-1"]
         self.make_mul(mul_name, mul_inputs, dtype=TensorProto.INT64, shape=["unk"])
@@ -2526,7 +3361,11 @@ def make_common_mask_reformat_subgraph(self, basename, root_input, unsqueeze_for
         self.make_equal(equal_name, equal_inputs, shape=[4])
 
         where_name = f"{basename}/Where_1"
-        where_inputs = [f"{equal_name}/output_0", f"{constant_shape_name}/output_0", f"{concat_name}/output_0"]
+        where_inputs = [
+            f"{equal_name}/output_0",
+            f"{constant_shape_name}/output_0",
+            f"{concat_name}/output_0",
+        ]
         self.make_where(where_name, where_inputs, dtype=TensorProto.INT64, shape=[4])
         expand_name = f"{basename}/Expand"
         expand_inputs = [f"{unsqueeze_for_expand}/output_0", f"{where_name}/output_0"]
@@ -2556,7 +3395,9 @@ def make_attention_mask_reformatting_for_gqa(self):
         # Left path
         reduce_sum_name = f"{attn_mask_basename}/ReduceSum"
         reduce_sum_inputs = ["attention_mask", "/model/constants/TensorProto.INT64/1D/1"]
-        self.make_reduce_sum(reduce_sum_name, reduce_sum_inputs, dtype=TensorProto.INT64, shape=["batch_size", 1])
+        self.make_reduce_sum(
+            reduce_sum_name, reduce_sum_inputs, dtype=TensorProto.INT64, shape=["batch_size", 1]
+        )
         sub_name = f"{attn_mask_basename}/Sub"
         sub_inputs = [f"{reduce_sum_name}/output_0", "/model/constants/TensorProto.INT64/1D/1"]
         self.make_sub(sub_name, sub_inputs, dtype=TensorProto.INT64, shape=["batch_size", 1])
@@ -2596,9 +3437,13 @@ def make_attention_mask_reformatting_for_sparse_attn(self):
         # Left path
         reduce_sum_name = f"{attn_mask_basename}/ReduceSum"
         reduce_sum_inputs = ["attention_mask", "/model/constants/TensorProto.INT64/1D/1"]
-        self.make_reduce_sum(reduce_sum_name, reduce_sum_inputs, dtype=TensorProto.INT64, shape=["batch_size", 1])
+        self.make_reduce_sum(
+            reduce_sum_name, reduce_sum_inputs, dtype=TensorProto.INT64, shape=["batch_size", 1]
+        )
         cast_1_name = f"{attn_mask_basename}/ReduceSum/Cast"
-        self.make_cast(cast_1_name, f"{reduce_sum_name}/output_0", dtype=TensorProto.INT32, shape=["batch_size", 1])
+        self.make_cast(
+            cast_1_name, f"{reduce_sum_name}/output_0", dtype=TensorProto.INT32, shape=["batch_size", 1]
+        )
 
         # Right path
         shape_name = f"{attn_mask_basename}/Shape"
@@ -2632,7 +3477,11 @@ def make_position_ids_reformatting(self):
         basename = "/model/pos_ids_reformat"
 
         shape_name = f"{basename}/Shape"
-        self.make_shape(shape_name, root_input="input_ids" if not self.exclude_embeds else "inputs_embeds", shape=[2] if not self.exclude_embeds else [3])
+        self.make_shape(
+            shape_name,
+            root_input="input_ids" if not self.exclude_embeds else "inputs_embeds",
+            shape=[2] if not self.exclude_embeds else [3],
+        )
         gather_name = f"{basename}/Gather"
         gather_inputs = [f"{shape_name}/output_0", "/model/constants/TensorProto.INT64/0D/1"]
         self.make_gather(gather_name, gather_inputs, axis=0)
@@ -2657,7 +3506,11 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
 class MistralModel(Model):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
-        self.position_ids_name = f"{self.make_position_ids_reformatting()}/output_0" if not self.attention_attrs["use_rotemb_in_attn"] else "position_ids"
+        self.position_ids_name = (
+            f"{self.make_position_ids_reformatting()}/output_0"
+            if not self.attention_attrs["use_rotemb_in_attn"]
+            else "position_ids"
+        )
 
     def make_attention(self, layer_id, attention, root_input, **kwargs):
         super().make_attention(layer_id, attention, root_input, position_ids=self.position_ids_name, **kwargs)
@@ -2674,22 +3527,42 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         # self.input_shapes["position_ids"] = [1]  # Note: This is optional and only needed if you want position_ids to be an int instead of a 2D tensor
         self.layernorm_attrs["simple"] = False
         self.rotemb_attrs["num_heads"] = self.num_attn_heads
-        self.rotemb_attrs["rotary_embedding_dim"] = int(self.head_size * self.rotemb_attrs["partial_rotary_factor"])
+        self.rotemb_attrs["rotary_embedding_dim"] = int(
+            self.head_size * self.rotemb_attrs["partial_rotary_factor"]
+        )
         self.mlp_attrs["use_proj"], self.mlp_attrs["use_fc"] = False, True
 
     def make_rotary_embedding(self, rotemb, name, root_input, **kwargs):
-        super().make_rotary_embedding(rotemb, name, root_input, num_heads=self.rotemb_attrs["num_heads"], rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"], **kwargs)
+        super().make_rotary_embedding(
+            rotemb,
+            name,
+            root_input,
+            num_heads=self.rotemb_attrs["num_heads"],
+            rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"],
+            **kwargs,
+        )
 
     def make_layer(self, layer_id, layer):
         # Each Phi decoder layer is defined as:
         # input_layernorm --> attention --> MLP --> residual_add
-        self.make_layernorm(layer_id, layer.input_layernorm, skip=not self.layernorm_attrs["first_layernorm"], simple=self.layernorm_attrs["simple"], location="input")
+        self.make_layernorm(
+            layer_id,
+            layer.input_layernorm,
+            skip=not self.layernorm_attrs["first_layernorm"],
+            simple=self.layernorm_attrs["simple"],
+            location="input",
+        )
         self.make_attention(layer_id, layer.self_attn, root_input=self.layernorm_attrs["output_0"])
         self.make_mlp(layer_id, layer.mlp, root_input=self.layernorm_attrs["output_0"])
 
         residual_add_name = f"/model/layers.{layer_id}/residual_add/Add"
-        residual_add_inputs = [self.layernorm_attrs['skip_input'], self.mlp_attrs["output_0"]]
-        self.make_add(residual_add_name, residual_add_inputs, dtype=self.io_dtype, shape=['batch_size', 'sequence_length', self.hidden_size])
+        residual_add_inputs = [self.layernorm_attrs["skip_input"], self.mlp_attrs["output_0"]]
+        self.make_add(
+            residual_add_name,
+            residual_add_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.hidden_size],
+        )
 
         self.layernorm_attrs["first_layernorm"] = False
         if layer_id == self.num_layers - 1:
@@ -2710,31 +3583,55 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
 class Gemma2Model(GemmaModel):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
-        self.attention_attrs["scale"] = config.query_pre_attn_scalar ** -0.5
+        self.attention_attrs["scale"] = config.query_pre_attn_scalar**-0.5
         self.lm_head_attrs["scale"] = config.final_logit_softcapping
 
     def make_layer(self, layer_id, layer):
         # Gemma2 decoder layer is typically defined as:
         # input_layernorm --> attention --> post_attention_layernorm --> pre_ffn_layernorm --> MLP --> post_ffn_layernorm
-        self.make_layernorm(layer_id, layer.input_layernorm, skip=not self.layernorm_attrs["first_layernorm"], simple=self.layernorm_attrs["simple"], location="input")
+        self.make_layernorm(
+            layer_id,
+            layer.input_layernorm,
+            skip=not self.layernorm_attrs["first_layernorm"],
+            simple=self.layernorm_attrs["simple"],
+            location="input",
+        )
         self.make_attention(layer_id, layer.self_attn, root_input=self.layernorm_attrs["output_0"])
 
         # Temporarily set root_input for LayerNorm to skip_input for post_attention_layernorm
         # Set skip_input to output of post_attention_layernorm
         original_root_input = self.layernorm_attrs["root_input"]
         self.layernorm_attrs["root_input"] = self.layernorm_attrs["skip_input"]
-        self.make_layernorm(layer_id, layer.post_attention_layernorm, skip=False, simple=self.layernorm_attrs["simple"], location="post_attention")
+        self.make_layernorm(
+            layer_id,
+            layer.post_attention_layernorm,
+            skip=False,
+            simple=self.layernorm_attrs["simple"],
+            location="post_attention",
+        )
         self.layernorm_attrs["root_input"] = original_root_input
         self.layernorm_attrs["skip_input"] = self.layernorm_attrs["output_0"]
 
-        self.make_layernorm(layer_id, layer.pre_feedforward_layernorm, skip=True, simple=self.layernorm_attrs["simple"], location="pre_feedforward")
+        self.make_layernorm(
+            layer_id,
+            layer.pre_feedforward_layernorm,
+            skip=True,
+            simple=self.layernorm_attrs["simple"],
+            location="pre_feedforward",
+        )
         self.make_mlp(layer_id, layer.mlp, root_input=self.layernorm_attrs["output_0"])
 
         # Temporarily set root_input for LayerNorm to skip_input for post_feedforward_layernorm
         # Set skip_input to output of post_ffn_layernorm
         original_root_input = self.layernorm_attrs["root_input"]
         self.layernorm_attrs["root_input"] = self.layernorm_attrs["skip_input"]
-        self.make_layernorm(layer_id, layer.post_feedforward_layernorm, skip=False, simple=self.layernorm_attrs["simple"], location="post_feedforward")
+        self.make_layernorm(
+            layer_id,
+            layer.post_feedforward_layernorm,
+            skip=False,
+            simple=self.layernorm_attrs["simple"],
+            location="post_feedforward",
+        )
         self.layernorm_attrs["root_input"] = original_root_input
         self.layernorm_attrs["skip_input"] = self.layernorm_attrs["output_0"]
 
@@ -2745,7 +3642,9 @@ def make_layer(self, layer_id, layer):
 
     def make_attention(self, layer_id, attention, root_input, **kwargs):
         original_window_size = self.window_size
-        self.window_size = original_window_size if layer_id % 2 == 1 else -1  # default is -1 in GroupQueryAttention kernel
+        self.window_size = (
+            original_window_size if layer_id % 2 == 1 else -1
+        )  # default is -1 in GroupQueryAttention kernel
         super().make_attention(layer_id, attention, root_input, **kwargs)
         self.window_size = original_window_size
 
@@ -2756,17 +3655,35 @@ def make_lm_head(self, lm_head):
 
         # Add final logit softcapping (Div --> Tanh --> Mul)
         div_name = "/lm_head/Div"
-        div_inputs = [f"{matmul_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}"]
-        self.make_div(div_name, div_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.vocab_size])
+        div_inputs = [
+            f"{matmul_name}/output_0",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}",
+        ]
+        self.make_div(
+            div_name,
+            div_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.vocab_size],
+        )
 
         tanh_name = "/lm_head/Tanh"
-        self.make_tanh(tanh_name, f"{div_name}/output_0", dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.vocab_size])
+        self.make_tanh(
+            tanh_name,
+            f"{div_name}/output_0",
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.vocab_size],
+        )
 
         mul_name = "/lm_head/Mul"
-        mul_inputs = [f"{tanh_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}"]
+        mul_inputs = [
+            f"{tanh_name}/output_0",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.lm_head_attrs['scale']}",
+        ]
         mul_output = "logits"
-        self.make_node('Mul', inputs=mul_inputs, outputs=[mul_output], name=mul_name)
-        self.make_value_info(mul_output, self.io_dtype, shape=['batch_size', 'sequence_length', self.vocab_size])
+        self.make_node("Mul", inputs=mul_inputs, outputs=[mul_output], name=mul_name)
+        self.make_value_info(
+            mul_output, self.io_dtype, shape=["batch_size", "sequence_length", self.vocab_size]
+        )
 
 
 class Phi3Mini4KModel(MistralModel):
@@ -2783,12 +3700,15 @@ def make_mlp_proj(self, layer_id, mlp, root_input):
             super().make_mlp_unpacked(layer_id, mlp, root_input)
         super().make_mlp_proj(layer_id, mlp, root_input)
 
+
 class NemotronModel(LlamaModel):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
         self.layernorm_attrs["simple"] = False
         self.layernorm_attrs["add_offset"] = 1
-        self.rotemb_attrs["rotary_embedding_dim"] = int(self.head_size * self.rotemb_attrs["partial_rotary_factor"])
+        self.rotemb_attrs["rotary_embedding_dim"] = int(
+            self.head_size * self.rotemb_attrs["partial_rotary_factor"]
+        )
 
     def make_mlp_proj(self, layer_id, mlp, root_input):
         # Make nodes for the MLP subgraph
@@ -2814,18 +3734,26 @@ def make_mlp_proj(self, layer_id, mlp, root_input):
         self.layernorm_attrs["skip_input"] = f"{down_name}/output_0"
 
     def make_attention(self, layer_id, attention, root_input, **kwargs):
-        attention.rotary_emb = type("RotaryEmbedding", (object,), {'content':{}})()
+        attention.rotary_emb = type("RotaryEmbedding", (object,), {"content": {}})()
         return super().make_attention(layer_id, attention, root_input, **kwargs)
 
     def make_rotary_embedding(self, rotemb, name, root_input, **kwargs):
         num_heads = self.num_kv_heads if "k_rotary" in name else self.num_attn_heads
-        super().make_rotary_embedding(rotemb, name, root_input, num_heads=num_heads, rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"], **kwargs)
+        super().make_rotary_embedding(
+            rotemb,
+            name,
+            root_input,
+            num_heads=num_heads,
+            rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"],
+            **kwargs,
+        )
+
 
 class Phi3Mini128KModel(Phi3Mini4KModel):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
         self.make_rotary_embedding_multi_cache()
-   
+
     def make_position_ids_reformatting(self):
         if self.ep != "dml":
             position_ids_input_to_rotemb = super().make_position_ids_reformatting()
@@ -2836,19 +3764,27 @@ def make_position_ids_reformatting(self):
         reduce_max_inputs = ["position_ids"]
         self.make_reduce_max(reduce_max_name, reduce_max_inputs, dtype=TensorProto.INT64, shape=[1])
         greater_or_equal_name = f"{basename}/GreaterOrEqual"
-        greater_or_equal_inputs = [f"{reduce_max_name}/output_0", f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}"]
+        greater_or_equal_inputs = [
+            f"{reduce_max_name}/output_0",
+            f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}",
+        ]
         self.make_greater_or_equal(greater_or_equal_name, greater_or_equal_inputs, shape=[])
         cast_name = f"{basename}/Cast"
         self.make_cast(cast_name, f"{greater_or_equal_name}/output_0", dtype=TensorProto.INT64, shape=None)
         mul_name = f"{basename}/Mul"
-        mul_inputs = [f"{cast_name}/output_0", f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}"]
+        mul_inputs = [
+            f"{cast_name}/output_0",
+            f"/model/constants/TensorProto.INT64/0D/{self.original_context_length}",
+        ]
         self.make_mul(mul_name, mul_inputs, dtype=TensorProto.INT64, shape=None)
         add_1_name = f"{basename}/Add_1"
         add_1_inputs = [f"{mul_name}/output_0", "position_ids"]
-        self.make_add(add_1_name, add_1_inputs, dtype=TensorProto.INT64, shape=["batch_size", "sequence_length"])
+        self.make_add(
+            add_1_name, add_1_inputs, dtype=TensorProto.INT64, shape=["batch_size", "sequence_length"]
+        )
 
         return add_1_name
-        
+
     def make_rotary_embedding_caches(self, rotemb, **kwargs):
         if self.ep != "dml":
             cos_cache_name, sin_cache_name = super().make_rotary_embedding_caches(rotemb, **kwargs)
@@ -2890,6 +3826,7 @@ def make_rotary_embedding_caches(self, rotemb, **kwargs):
 
         return cos_cache_name, sin_cache_name
 
+
 class Phi3Small8KModel(Model):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
@@ -2923,7 +3860,7 @@ def calculate_block_mask(self):
             q_pos = torch.arange(N_BLOCK)[:, None]
             k_pos = torch.arange(N_BLOCK)[None]
             mask_vert_strided = (torch.arange(N_BLOCK) + 1) % vert_stride == 0
-            block_mask_dense = ((q_pos >= k_pos) & ((q_pos - k_pos < local_blocks) | mask_vert_strided))
+            block_mask_dense = (q_pos >= k_pos) & ((q_pos - k_pos < local_blocks) | mask_vert_strided)
             N_BLOCK_Q = self.calculate_cdiv(q_len, BLOCK)
             block_mask_dense_output = block_mask_dense[-N_BLOCK_Q:].contiguous().to_sparse_csr()
 
@@ -2935,10 +3872,14 @@ def calculate_block_mask(self):
         else:
             q_pos = torch.arange(N_BLOCK)[None, :, None]
             k_pos = torch.arange(N_BLOCK)[None, None]
-            head_sliding_step = max(1, int(vert_stride / n_heads))  # if vert_stride <= n_heads, rotating the heads
-            mask_vert_strided = [(torch.arange(N_BLOCK) + h * head_sliding_step + 1) % vert_stride == 0 for h in range(n_heads)]
+            head_sliding_step = max(
+                1, int(vert_stride / n_heads)
+            )  # if vert_stride <= n_heads, rotating the heads
+            mask_vert_strided = [
+                (torch.arange(N_BLOCK) + h * head_sliding_step + 1) % vert_stride == 0 for h in range(n_heads)
+            ]
             mask_vert_strided = torch.vstack(mask_vert_strided).unsqueeze(1)
-            block_mask_dense = ((q_pos >= k_pos) & ((q_pos - k_pos < local_blocks) | mask_vert_strided))
+            block_mask_dense = (q_pos >= k_pos) & ((q_pos - k_pos < local_blocks) | mask_vert_strided)
             N_BLOCK_Q = self.calculate_cdiv(q_len, BLOCK)
             block_mask_dense_output = block_mask_dense[:, -N_BLOCK_Q:]
 
@@ -2979,20 +3920,45 @@ def make_attention(self, layer_id, attention, root_input, **kwargs):
         q_size = self.num_attn_heads * self.head_size
         kv_size = self.num_kv_heads * self.head_size
 
-        qkv_weight = attention.query_key_value.weight.T.view(self.hidden_size, self.num_kv_heads, (self.num_attn_heads // self.num_kv_heads) + 2, self.head_size)
-        qkv_bias = attention.query_key_value.bias.view(self.num_kv_heads, (self.num_attn_heads // self.num_kv_heads) + 2, self.head_size)
+        qkv_weight = attention.query_key_value.weight.T.view(
+            self.hidden_size,
+            self.num_kv_heads,
+            (self.num_attn_heads // self.num_kv_heads) + 2,
+            self.head_size,
+        )
+        qkv_bias = attention.query_key_value.bias.view(
+            self.num_kv_heads, (self.num_attn_heads // self.num_kv_heads) + 2, self.head_size
+        )
 
         attention.q_proj = torch.nn.Linear(in_features=q_size, out_features=q_size)
-        attention.q_proj.weight = torch.nn.Parameter(qkv_weight[:, :, :-2].reshape(q_size, q_size).T, requires_grad=False)
-        attention.q_proj.bias = None if attention.query_key_value.bias is None else torch.nn.Parameter(qkv_bias[:, :-2].flatten(), requires_grad=False)
+        attention.q_proj.weight = torch.nn.Parameter(
+            qkv_weight[:, :, :-2].reshape(q_size, q_size).T, requires_grad=False
+        )
+        attention.q_proj.bias = (
+            None
+            if attention.query_key_value.bias is None
+            else torch.nn.Parameter(qkv_bias[:, :-2].flatten(), requires_grad=False)
+        )
 
         attention.k_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
-        attention.k_proj.weight = torch.nn.Parameter(qkv_weight[:, :, [-2]].reshape(q_size, kv_size).T, requires_grad=False)
-        attention.k_proj.bias = None if attention.query_key_value.bias is None else torch.nn.Parameter(qkv_bias[:, [-2]].flatten(), requires_grad=False)
+        attention.k_proj.weight = torch.nn.Parameter(
+            qkv_weight[:, :, [-2]].reshape(q_size, kv_size).T, requires_grad=False
+        )
+        attention.k_proj.bias = (
+            None
+            if attention.query_key_value.bias is None
+            else torch.nn.Parameter(qkv_bias[:, [-2]].flatten(), requires_grad=False)
+        )
 
         attention.v_proj = torch.nn.Linear(in_features=q_size, out_features=kv_size)
-        attention.v_proj.weight = torch.nn.Parameter(qkv_weight[:, :, [-1]].reshape(q_size, kv_size).T, requires_grad=False)
-        attention.v_proj.bias = None if attention.query_key_value.bias is None else torch.nn.Parameter(qkv_bias[:, [-1]].flatten(), requires_grad=False)
+        attention.v_proj.weight = torch.nn.Parameter(
+            qkv_weight[:, :, [-1]].reshape(q_size, kv_size).T, requires_grad=False
+        )
+        attention.v_proj.bias = (
+            None
+            if attention.query_key_value.bias is None
+            else torch.nn.Parameter(qkv_bias[:, [-1]].flatten(), requires_grad=False)
+        )
 
         del qkv_weight
         del qkv_bias
@@ -3041,43 +4007,121 @@ def make_mlp_proj(self, layer_id, mlp, root_input):
 
         # Left path
         slice_1_name = f"/model/layers.{layer_id}/mlp/gelu/Slice"
-        slice_1_inputs = [f"{up_add_name}/output_0", "/model/constants/TensorProto.INT64/1D/0", f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}", "/model/constants/TensorProto.INT64/1D/-1", "/model/constants/TensorProto.INT64/1D/2"]
-        self.make_slice(slice_1_name, slice_1_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        slice_1_inputs = [
+            f"{up_add_name}/output_0",
+            "/model/constants/TensorProto.INT64/1D/0",
+            f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}",
+            "/model/constants/TensorProto.INT64/1D/-1",
+            "/model/constants/TensorProto.INT64/1D/2",
+        ]
+        self.make_slice(
+            slice_1_name,
+            slice_1_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         cast_1_name = f"/model/layers.{layer_id}/mlp/gelu/Cast"
-        self.make_cast(cast_1_name, f"{slice_1_name}/output_0", dtype=TensorProto.FLOAT, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_cast(
+            cast_1_name,
+            f"{slice_1_name}/output_0",
+            dtype=TensorProto.FLOAT,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         isinf_1_name = f"/model/layers.{layer_id}/mlp/gelu/IsInf"
-        self.make_isinf(isinf_1_name, f"{cast_1_name}/output_0", shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_isinf(
+            isinf_1_name,
+            f"{cast_1_name}/output_0",
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         clip_1_name = f"/model/layers.{layer_id}/mlp/gelu/Clip"
-        clip_1_inputs = [f"{slice_1_name}/output_0", "", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.clamp_limit}"]
-        self.make_clip(clip_1_name, clip_1_inputs, self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        clip_1_inputs = [
+            f"{slice_1_name}/output_0",
+            "",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.clamp_limit}",
+        ]
+        self.make_clip(
+            clip_1_name,
+            clip_1_inputs,
+            self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         where_1_name = f"/model/layers.{layer_id}/mlp/gelu/Where"
         where_1_inputs = [f"{isinf_1_name}/output_0", f"{slice_1_name}/output_0", f"{clip_1_name}/output_0"]
-        self.make_where(where_1_name, where_1_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_where(
+            where_1_name,
+            where_1_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         # Make activation
         act_fn_name = self.make_activation(layer_id, root_input=f"{where_1_name}/output_0")
 
         # Right path
         slice_2_name = f"/model/layers.{layer_id}/mlp/linear/Slice"
-        slice_2_inputs = [f"{up_add_name}/output_0", "/model/constants/TensorProto.INT64/1D/1", f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}", "/model/constants/TensorProto.INT64/1D/-1", "/model/constants/TensorProto.INT64/1D/2"]
-        self.make_slice(slice_2_name, slice_2_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        slice_2_inputs = [
+            f"{up_add_name}/output_0",
+            "/model/constants/TensorProto.INT64/1D/1",
+            f"/model/constants/TensorProto.INT64/1D/{np.iinfo(np.int64).max}",
+            "/model/constants/TensorProto.INT64/1D/-1",
+            "/model/constants/TensorProto.INT64/1D/2",
+        ]
+        self.make_slice(
+            slice_2_name,
+            slice_2_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         cast_2_name = f"/model/layers.{layer_id}/mlp/linear/Cast"
-        self.make_cast(cast_2_name, f"{slice_2_name}/output_0", dtype=TensorProto.FLOAT, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_cast(
+            cast_2_name,
+            f"{slice_2_name}/output_0",
+            dtype=TensorProto.FLOAT,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         isinf_2_name = f"/model/layers.{layer_id}/mlp/linear/IsInf"
-        self.make_isinf(isinf_2_name, f"{cast_2_name}/output_0", shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_isinf(
+            isinf_2_name,
+            f"{cast_2_name}/output_0",
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         clip_2_name = f"/model/layers.{layer_id}/mlp/linear/Clip"
-        clip_2_inputs = [f"{slice_2_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/-{self.clamp_limit}", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.clamp_limit}"]
-        self.make_clip(clip_2_name, clip_2_inputs, self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        clip_2_inputs = [
+            f"{slice_2_name}/output_0",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/-{self.clamp_limit}",
+            f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/{self.clamp_limit}",
+        ]
+        self.make_clip(
+            clip_2_name,
+            clip_2_inputs,
+            self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         where_2_name = f"/model/layers.{layer_id}/mlp/linear/Where"
         where_2_inputs = [f"{isinf_2_name}/output_0", f"{slice_2_name}/output_0", f"{clip_2_name}/output_0"]
-        self.make_where(where_2_name, where_2_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_where(
+            where_2_name,
+            where_2_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
         add_name = f"/model/layers.{layer_id}/mlp/linear/Add"
         add_inputs = [f"{where_2_name}/output_0", f"/model/constants/{self.to_str_dtype[self.io_dtype]}/0D/1"]
-        self.make_add(add_name, add_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_add(
+            add_name,
+            add_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
 
         # Make Mul node after activation
         mul_name = f"/model/layers.{layer_id}/mlp/Mul"
         mul_inputs = [f"{act_fn_name}/output_0", f"{add_name}/output_0"]
-        self.make_mul(mul_name, mul_inputs, dtype=self.io_dtype, shape=["batch_size", "sequence_length", self.intermediate_size])
+        self.make_mul(
+            mul_name,
+            mul_inputs,
+            dtype=self.io_dtype,
+            shape=["batch_size", "sequence_length", self.intermediate_size],
+        )
 
         # Make output MatMul and Add nodes
         down_matmul_name = f"/model/layers.{layer_id}/mlp/down_proj/MatMul"
@@ -3112,17 +4156,33 @@ def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         self.moe_attrs["activation_type"] = "silu"
         self.moe_attrs["normalize_routing_weights"] = 0
         self.moe_attrs["use_sparse_mixer"] = 1
-        self.moe_attrs["use_int4"] = 0 if "use_8bits_moe" in extra_options and extra_options["use_8bits_moe"] == "1" else 1
+        self.moe_attrs["use_int4"] = (
+            0 if "use_8bits_moe" in extra_options and extra_options["use_8bits_moe"] == "1" else 1
+        )
 
         self.make_rotary_embedding_multi_cache()
 
     def make_layer(self, layer_id, layer):
         # Each LLM decoder layer is typically defined as:
         # input_layernorm --> attention --> MLP --> output_layernorm
-        self.make_layernorm(layer_id, layer.input_layernorm, skip=not self.layernorm_attrs["first_layernorm"], simple=self.layernorm_attrs["simple"], location="input")
+        self.make_layernorm(
+            layer_id,
+            layer.input_layernorm,
+            skip=not self.layernorm_attrs["first_layernorm"],
+            simple=self.layernorm_attrs["simple"],
+            location="input",
+        )
         self.make_attention(layer_id, layer.self_attn, root_input=self.layernorm_attrs["output_0"])
-        self.make_layernorm(layer_id, layer.post_attention_layernorm, skip=True, simple=self.layernorm_attrs["simple"], location="post_attention")
-        self.make_block_sparse_moe(layer_id, layer.block_sparse_moe, root_input=self.layernorm_attrs["output_0"])
+        self.make_layernorm(
+            layer_id,
+            layer.post_attention_layernorm,
+            skip=True,
+            simple=self.layernorm_attrs["simple"],
+            location="post_attention",
+        )
+        self.make_block_sparse_moe(
+            layer_id, layer.block_sparse_moe, root_input=self.layernorm_attrs["output_0"]
+        )
 
         self.layernorm_attrs["first_layernorm"] = False
         if layer_id == self.num_layers - 1:
@@ -3134,49 +4194,64 @@ class ChatGLMModel(Model):
     def __init__(self, config, io_dtype, onnx_dtype, ep, cache_dir, extra_options):
         super().__init__(config, io_dtype, onnx_dtype, ep, cache_dir, extra_options)
         self.rotemb_attrs["num_heads"] = self.num_attn_heads
-        self.rotemb_attrs["partial_rotary_factor"] = 0.5 # Line 755 of modeling_chatglm.py check self.rotary_pos_emb declaration
-        self.rotemb_attrs["rotary_embedding_dim"] = int(self.head_size * self.rotemb_attrs["partial_rotary_factor"])
+        self.rotemb_attrs["partial_rotary_factor"] = (
+            0.5  # Line 755 of modeling_chatglm.py check self.rotary_pos_emb declaration
+        )
+        self.rotemb_attrs["rotary_embedding_dim"] = int(
+            self.head_size * self.rotemb_attrs["partial_rotary_factor"]
+        )
         self.rotemb_attrs["interleaved"] = 1
 
     def make_rotary_embedding(self, rotemb, name, root_input, **kwargs):
-        super().make_rotary_embedding(rotemb, name, root_input, num_heads=self.rotemb_attrs["num_heads"], rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"], **kwargs)
+        super().make_rotary_embedding(
+            rotemb,
+            name,
+            root_input,
+            num_heads=self.rotemb_attrs["num_heads"],
+            rotary_embedding_dim=self.rotemb_attrs["rotary_embedding_dim"],
+            **kwargs,
+        )
 
     def make_attention(self, layer_id, attention, root_input, **kwargs):
         if self.quant_type is None:
             super().make_attention_unpacked(layer_id, attention, root_input, **kwargs)
             # Add dummy rotary_emb attribute
-            attention.rotary_emb = type("RotaryEmbedding", (object,), {'content':{}})()
+            attention.rotary_emb = type("RotaryEmbedding", (object,), {"content": {}})()
         return super().make_attention(layer_id, attention, root_input, **kwargs)
 
-
     def make_mlp_proj(self, layer_id, mlp, root_input):
         if self.quant_type is None:
             super().make_mlp_unpacked(layer_id, mlp, root_input)
         super().make_mlp_proj(layer_id, mlp, root_input)
 
     def make_layer(self, layer_id, layer):
-        layer.self_attn = layer.self_attn if hasattr(layer, 'self_attn') else layer.self_attention
+        layer.self_attn = layer.self_attn if hasattr(layer, "self_attn") else layer.self_attention
         super().make_layer(layer_id, layer)
 
+
 def check_extra_options(kv_pairs):
     if "int4_op_types_to_quantize" in kv_pairs:
         op_types_to_quantize = ()
         for op_type in kv_pairs["int4_op_types_to_quantize"].split("/"):
-            op_types_to_quantize += (op_type, )
+            op_types_to_quantize += (op_type,)
         kv_pairs["int4_op_types_to_quantize"] = op_types_to_quantize
 
     if "non_quant_nodes" in kv_pairs:
         op_types_to_quantize = ()
         for op_type in kv_pairs["non_quant_nodes"].split("/"):
-            op_types_to_quantize += (op_type, )
+            op_types_to_quantize += (op_type,)
         kv_pairs["non_quant_nodes"] = op_types_to_quantize
 
     if "use_8bits_moe" in kv_pairs:
-        assert(kv_pairs["use_8bits_moe"] == "1" or kv_pairs["use_8bits_moe"] == "0"), "use_8bits_moe must be 0 or 1."
+        assert kv_pairs["use_8bits_moe"] == "1" or kv_pairs["use_8bits_moe"] == "0", (
+            "use_8bits_moe must be 0 or 1."
+        )
     if "use_lora" in kv_pairs:
-        assert(kv_pairs["use_lora"] == "1" or kv_pairs["use_lora"] == "0"), "use_lora must be 0 or 1."
+        assert kv_pairs["use_lora"] == "1" or kv_pairs["use_lora"] == "0", "use_lora must be 0 or 1."
     if "enable_cuda_graph" in kv_pairs:
-        assert(kv_pairs["enable_cuda_graph"] == "1" or kv_pairs["enable_cuda_graph"] == "0"), "enable_cuda_graph must be 0 or 1."
+        assert kv_pairs["enable_cuda_graph"] == "1" or kv_pairs["enable_cuda_graph"] == "0", (
+            "enable_cuda_graph must be 0 or 1."
+        )
 
 
 def parse_extra_options(kv_items):
@@ -3187,7 +4262,7 @@ def parse_extra_options(kv_items):
 
     if kv_items:
         for kv_str in kv_items:
-            kv = kv_str.split('=')
+            kv = kv_str.split("=")
             kv_pairs[kv[0].strip()] = kv[1].strip()
     check_extra_options(kv_pairs)
     return kv_pairs
@@ -3210,7 +4285,9 @@ def parse_hf_token(hf_token):
     return hf_token
 
 
-def create_model(model_name, input_path, output_dir, precision, execution_provider, cache_dir, **extra_options):
+def create_model(
+    model_name, input_path, output_dir, precision, execution_provider, cache_dir, **extra_options
+):
     # Create cache and output directories
     os.makedirs(output_dir, exist_ok=True)
     os.makedirs(cache_dir, exist_ok=True)
@@ -3223,52 +4300,51 @@ def create_model(model_name, input_path, output_dir, precision, execution_provid
     config = AutoConfig.from_pretrained(hf_name, token=hf_token, trust_remote_code=True, **extra_kwargs)
     if "adapter_path" in extra_options:
         from peft import PeftConfig
-        peft_config = PeftConfig.from_pretrained(extra_options["adapter_path"], token=hf_token, trust_remote_code=True, **extra_kwargs)
+
+        peft_config = PeftConfig.from_pretrained(
+            extra_options["adapter_path"], token=hf_token, trust_remote_code=True, **extra_kwargs
+        )
         config.update(peft_config.__dict__)
 
     # Set input/output precision of ONNX model
-    io_dtype = TensorProto.FLOAT if precision in {"int8", "fp32"} or (precision == "int4" and execution_provider == "cpu") else TensorProto.FLOAT16
+    io_dtype = (
+        TensorProto.FLOAT
+        if precision in {"int8", "fp32"} or (precision == "int4" and execution_provider == "cpu")
+        else TensorProto.FLOAT16
+    )
 
     if "config_only" not in extra_options:
-        # List architecture options in alphabetical order
-        if config.architectures[0] == "GemmaForCausalLM":
-            onnx_model = GemmaModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Gemma2ForCausalLM":
-            onnx_model = Gemma2Model(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "LlamaForCausalLM":
-            onnx_model = LlamaModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "MistralForCausalLM":
-            onnx_model = MistralModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "PhiForCausalLM":
-            onnx_model = PhiModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Phi3ForCausalLM" and config.max_position_embeddings == 4096:
-            onnx_model = Phi3Mini4KModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Phi3ForCausalLM" and config.max_position_embeddings == 131072:
-            onnx_model = Phi3Mini128KModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "PhiMoEForCausalLM" and config.max_position_embeddings == 131072:
-            print("WARNING: This model only works for CUDA currently because `MoE` is only supported for CUDA in ONNX Runtime. Setting `--execution_provider cuda` by default.")
-            print("WARNING: This model currently only supports quantized version. Setting `--precision int4` by default.")
-            execution_provider = "cuda"
-            precision = "int4"
-            onnx_model = Phi3MoE128KModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Phi3SmallForCausalLM" and config.max_position_embeddings == 8192:
-            onnx_model = Phi3Small8KModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Phi3SmallForCausalLM" and config.max_position_embeddings == 131072:
-            onnx_model = Phi3Small128KModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Phi3VForCausalLM":
-            print("WARNING: This is only generating the text component of the model. Setting `--extra_options exclude_embeds=true` by default.")
-            extra_options["exclude_embeds"] = True
-            onnx_model = Phi3VModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "Qwen2ForCausalLM":
-            onnx_model = QwenModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "NemotronForCausalLM":
-            onnx_model = NemotronModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        elif config.architectures[0] == "ChatGLMForConditionalGeneration" or config.architectures[0] == "ChatGLMModel":
-            # Quantized ChatGLM model has ChatGLMForConditionalGeneration as architecture whereas HF model as the latter
-            config.hidden_act = "swiglu"
-            onnx_model = ChatGLMModel(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
-        else:
-            raise NotImplementedError(f"The {hf_name} model is not currently supported.")
+        # #6: the 14-branch architecture ladder that used to live here is now DATA in
+        # config/registry/architecture.py. Three of those branches did more than pick a class —
+        # PhiMoE forced cuda+int4, Phi3V forced exclude_embeds, ChatGLM forced hidden_act=swiglu —
+        # so the registry row carries those as option_overrides / extra_option_overrides /
+        # config_overrides rather than losing them. Adding an architecture is a row, not an elif.
+        from mobiletransformers.config.registry.architecture import resolve_architecture
+        from mobiletransformers.exceptions import UnsupportedModelError
+
+        try:
+            spec = resolve_architecture(config)
+        except UnsupportedModelError as exc:
+            raise NotImplementedError(f"The {hf_name} model is not currently supported.") from exc
+
+        for message in spec.warnings:
+            print(f"WARNING: {message}")
+        # Forced export options (e.g. PhiMoE's MoE op is CUDA-only and quantized-only in ORT).
+        execution_provider = spec.option_overrides.get("execution_provider", execution_provider)
+        precision = spec.option_overrides.get("precision", precision)
+        for key, value in spec.extra_option_overrides.items():
+            extra_options[key] = value
+        # Forced HF-config attributes, applied before the builder reads them.
+        for key, value in spec.config_overrides.items():
+            setattr(config, key, value)
+
+        variant_value = getattr(config, spec.variant_key, None) if spec.variant_key else None
+        try:
+            model_class = spec.load_inference_model_class(variant_value)
+        except UnsupportedModelError as exc:
+            raise NotImplementedError(f"The {hf_name} model is not currently supported.") from exc
+
+        onnx_model = model_class(config, io_dtype, precision, execution_provider, cache_dir, extra_options)
 
         # Make ONNX model
         onnx_model.make_model(input_path)
@@ -3337,21 +4413,21 @@ def get_args():
         "--cache_dir",
         required=False,
         type=str,
-        default=os.path.join('.', 'cache_dir'),
+        default=os.path.join(".", "cache_dir"),
         help="Cache directory for Hugging Face files and temporary ONNX external data files",
     )
 
     parser.add_argument(
         "--config",
         type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
     )
 
     parser.add_argument(
         "--extra_options",
         required=False,
         metavar="KEY=VALUE",
-        nargs='+',
+        nargs="+",
         help=textwrap.dedent("""\
             Key value pairs for various options. Currently supports:
                 int4_accuracy_level = 1/2/3/4: Specify the minimum accuracy level for activation of MatMul in int4 quantization.
@@ -3391,16 +4467,20 @@ def get_args():
     )
 
     args = parser.parse_args()
-    print("Valid precision + execution provider combinations are: FP32 CPU, FP32 CUDA, FP16 CUDA, FP16 DML, INT4 CPU, INT4 CUDA, INT4 DML")
+    print(
+        "Valid precision + execution provider combinations are: FP32 CPU, FP32 CUDA, FP16 CUDA, FP16 DML, INT4 CPU, INT4 CUDA, INT4 DML"
+    )
     return args
 
+
 def load_config_from_file(config_file: str):
     """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
+    with open(config_file) as file:
         config = yaml.safe_load(file)
     return config
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     args = get_args()
     extra_options = parse_extra_options(args.extra_options)
 
@@ -3408,16 +4488,24 @@ def load_config_from_file(config_file: str):
         config_dict = load_config_from_file(args.config)
 
         # Specific
-        setattr(args, "model_name", config_dict[TRAIN_CONFIG]["model_id"])
-        setattr(args, "cache_dir", os.environ['HF_CACHE'])
-        extra_options["hf_token"] = os.environ['HF_TOKEN']
+        args.model_name = config_dict[TRAIN_CONFIG]["model_id"]
+        args.cache_dir = os.environ["HF_CACHE"]
+        extra_options["hf_token"] = get_settings().require_hf_token()
         if config_dict[INFERENCE_CONFIG]["use_lora"]:
             extra_options["non_quant_nodes"] = config_dict[TRAIN_CONFIG]["lora_target"]
         else:
             extra_options["non_quant_nodes"] = []
         extra_options["prompt_templates"] = "1" if config_dict[INFERENCE_CONFIG]["prompt_templates"] else "0"
-        extra_options["int4_accuracy_level"] = config_dict[INFERENCE_CONFIG]["int4_accuracy_level"] if "int4_accuracy_level" in config_dict[INFERENCE_CONFIG] else 4
-        extra_options["int4_block_size"] = config_dict[INFERENCE_CONFIG]["int4_block_size"] if "int4_block_size" in config_dict[INFERENCE_CONFIG] else 32
+        extra_options["int4_accuracy_level"] = (
+            config_dict[INFERENCE_CONFIG]["int4_accuracy_level"]
+            if "int4_accuracy_level" in config_dict[INFERENCE_CONFIG]
+            else 4
+        )
+        extra_options["int4_block_size"] = (
+            config_dict[INFERENCE_CONFIG]["int4_block_size"]
+            if "int4_block_size" in config_dict[INFERENCE_CONFIG]
+            else 32
+        )
         extra_options["force_unpacked_matmul"] = config_dict[INFERENCE_CONFIG]["force_unpacked_matmul"]
         extra_options["export_tokenizer"] = config_dict[INFERENCE_CONFIG]["export_tokenizer"]
         extra_options["export_genai_config"] = config_dict[INFERENCE_CONFIG]["export_genai_config"]
@@ -3426,13 +4514,19 @@ def load_config_from_file(config_file: str):
         extra_options["force_transpose_inputs"] = config_dict[INFERENCE_CONFIG]["force_transpose_inputs"]
 
         for key, value in config_dict[INFERENCE_CONFIG].items():
-            
             if hasattr(args, key):
                 setattr(args, key, value)
             elif hasattr(extra_options, key):
                 setattr(extra_options, key, value)
 
-
     print(args)
     print(extra_options)
-    create_model(args.model_name, args.input, args.output, args.precision, args.execution_provider, args.cache_dir, **extra_options)
\ No newline at end of file
+    create_model(
+        args.model_name,
+        args.input,
+        args.output,
+        args.precision,
+        args.execution_provider,
+        args.cache_dir,
+        **extra_options,
+    )
diff --git a/inference/generator.py b/src/mobiletransformers/inference/generator.py
similarity index 75%
rename from inference/generator.py
rename to src/mobiletransformers/inference/generator.py
index 8944291..c95572e 100644
--- a/inference/generator.py
+++ b/src/mobiletransformers/inference/generator.py
@@ -1,29 +1,28 @@
 """
-Script for LLM generation loop using the provided inference model. 
+Script for LLM generation loop using the provided inference model.
 """
 
 import time
+
 import numpy as np
 
-def generate_tokens_onnx(tokenizer,
-                         model,
-                         config,
-                         model_train_weights=[],
-                         with_past=False,
-                         with_weight_input=False,
-                         with_position_ids=True,
-                         with_labels=False,
-                         prompt="Hello, how is your day?",
-                         output_name="logits",
-                         max_length=100,
-                         sampling={
-                            "method": "greedy",
-                            "temperature" : 1.0,
-                            "topP" : 0.9,
-                            "topK": 50
-                         },
-                         decode_between=True,
-                         **kwargs):
+
+def generate_tokens_onnx(
+    tokenizer,
+    model,
+    config,
+    model_train_weights=[],
+    with_past=False,
+    with_weight_input=False,
+    with_position_ids=True,
+    with_labels=False,
+    prompt="Hello, how is your day?",
+    output_name="logits",
+    max_length=100,
+    sampling={"method": "greedy", "temperature": 1.0, "topP": 0.9, "topK": 50},
+    decode_between=True,
+    **kwargs,
+):
     """
     Generates the tokens from the ONNX Inference sessions.
     Supports either greedy / top_k / top_p sampling methods.
@@ -31,8 +30,12 @@ def generate_tokens_onnx(tokenizer,
 
     input_ids = tokenizer(prompt, return_attention_mask=True, return_tensors="np")
 
-    num_kv_heads = config.num_key_value_heads if hasattr(config, "num_key_value_heads") else config.num_attention_heads
-    head_size = config.head_dim if hasattr(config, "head_dim") else config.hidden_size // config.num_attention_heads
+    num_kv_heads = (
+        config.num_key_value_heads if hasattr(config, "num_key_value_heads") else config.num_attention_heads
+    )
+    head_size = (
+        config.head_dim if hasattr(config, "head_dim") else config.hidden_size // config.num_attention_heads
+    )
 
     # Initialize the generated sequence with the prompt
     token_input_ids = input_ids["input_ids"]
@@ -45,8 +48,12 @@ def generate_tokens_onnx(tokenizer,
     if with_past:
         past_key_values = {}
         for i in range(config.num_hidden_layers):
-            past_key_values[f"past_key_values.{i}.key"] = np.random.rand(*(1, num_kv_heads, 0, head_size)).astype(np.float32)
-            past_key_values[f"past_key_values.{i}.value"] = np.random.rand(*(1, num_kv_heads, 0, head_size)).astype(np.float32)
+            past_key_values[f"past_key_values.{i}.key"] = np.random.rand(
+                *(1, num_kv_heads, 0, head_size)
+            ).astype(np.float32)
+            past_key_values[f"past_key_values.{i}.value"] = np.random.rand(
+                *(1, num_kv_heads, 0, head_size)
+            ).astype(np.float32)
 
         present_keys = [pkv.replace("past_key_values", "present") for pkv in past_key_values.keys()]
 
@@ -56,7 +63,6 @@ def generate_tokens_onnx(tokenizer,
     start_time = time.time()
     num_decode = 0
     for _ in range(max_length):
-        
         model_inputs = {
             "input_ids": token_input_ids,
             "attention_mask": attention_mask,
@@ -81,15 +87,18 @@ def generate_tokens_onnx(tokenizer,
             for pkv, pkv_name in zip(output[1:], past_key_values.keys()):
                 present_kv[pkv_name] = pkv
             past_key_values = present_kv
-        
+
         # Get the last token logits and apply temperature
         logits = logits[:, -1, :] / sampling["temperature"]
 
-        if sampling["method"]=="top_k":
+        if sampling["method"] == "top_k":
             top_k = sampling["topK"]
             # Apply top-k filtering
-            top_k_values, top_k_indices = np.partition(logits[0], -top_k)[-top_k:], np.argpartition(logits[0], -top_k)[-top_k:]
-            filtered_logits = np.full_like(logits[0], -float('Inf'))
+            top_k_values, top_k_indices = (
+                np.partition(logits[0], -top_k)[-top_k:],
+                np.argpartition(logits[0], -top_k)[-top_k:],
+            )
+            filtered_logits = np.full_like(logits[0], -float("Inf"))
             filtered_logits[top_k_indices] = top_k_values
 
             # Sample from the filtered logits
@@ -112,7 +121,7 @@ def generate_tokens_onnx(tokenizer,
             cutoff_index = np.searchsorted(cumulative_probs, top_p) + 1
 
             # Filter out tokens that fall outside the top-p cumulative probability
-            filtered_logits = np.full_like(logits[0], -float('Inf'))
+            filtered_logits = np.full_like(logits[0], -float("Inf"))
             filtered_logits[sorted_indices[:cutoff_index]] = sorted_logits[:cutoff_index]
 
             # Sample from the filtered logits
@@ -131,7 +140,9 @@ def generate_tokens_onnx(tokenizer,
             position_ids = np.array([[token_input_ids.shape[-1] - 1]], dtype=np.int64)
         else:
             # Handle for the full sequence
-            token_input_ids = np.concatenate([token_input_ids, np.array([[next_token_id]], dtype=np.int64)], axis=-1)
+            token_input_ids = np.concatenate(
+                [token_input_ids, np.array([[next_token_id]], dtype=np.int64)], axis=-1
+            )
             position_ids = np.arange(token_input_ids.shape[-1], dtype=np.int64).reshape(1, -1)
 
         if decode_between:
@@ -140,7 +151,7 @@ def generate_tokens_onnx(tokenizer,
             print("-------------------------------------------------")
 
         num_decode += 1
-        
+
         # Update the attention_mask (add 1 for the new token)
         new_ones = np.ones((attention_mask.shape[0], 1), dtype=np.int64)
         attention_mask = np.concatenate((attention_mask, new_ones), axis=-1)
@@ -148,10 +159,10 @@ def generate_tokens_onnx(tokenizer,
         # Stop if end-of-sequence token is generated
         if next_token_id == tokenizer.eos_token_id:
             break
-    
+
     end_time = time.time()
     print("\n")
     print(f"[INFO] Generation time: {(num_decode / (end_time - start_time)):.2f} token/s")
 
     # Decode the generated tokens
-    return tokenizer.decode(generated_ids[0], skip_special_tokens=True)
\ No newline at end of file
+    return tokenizer.decode(generated_ids[0], skip_special_tokens=True)
diff --git a/src/mobiletransformers/peft/__init__.py b/src/mobiletransformers/peft/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mobiletransformers/peft/ablation/__init__.py b/src/mobiletransformers/peft/ablation/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/peft_models/ablation/config.py b/src/mobiletransformers/peft/ablation/config.py
similarity index 78%
rename from peft_models/ablation/config.py
rename to src/mobiletransformers/peft/ablation/config.py
index 1d14455..7231898 100644
--- a/peft_models/ablation/config.py
+++ b/src/mobiletransformers/peft/ablation/config.py
@@ -1,14 +1,10 @@
 from __future__ import annotations
 
-import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import Enum
 
 from peft.config import PeftConfig
-from peft.utils import PeftType
 
-from dataclasses import dataclass, field
-from typing import Optional, Union, Tuple
-from enum import Enum
 
 class AblationVariant(Enum):
     """
@@ -22,7 +18,7 @@ class AblationVariant(Enum):
     - Variant G - Dynamic quantized backbone (int8)
     - Variant H - Dynamic quantized backbone (int4)
     """
-    
+
     VARIANT_0 = "0"
     VARIANT_A = "A"
     VARIANT_B = "B"
@@ -33,6 +29,7 @@ class AblationVariant(Enum):
     VARIANT_G = "G"
     VARIANT_H = "H"
 
+
 @dataclass
 class AblationConfig(PeftConfig):
     """
@@ -52,20 +49,22 @@ class AblationConfig(PeftConfig):
     """
 
     r: int = field(default=8, metadata={"help": "Lora attention dimension"})
-    variant: str = field(default="0", metadata={
-        "help": (
-            "Variants to choose from:"
-            "- Variant 0 - Normal LoRA"
-            "- Variant A - LoRA + intermediate layer"
-            "- Variant B - Input vector + frozen downprojection + up projection"
-            "- Variant C - Frozen downprojection + intermediate + up projection"
-            "- Variant D - Shared frozen downprojection + intermediate + up projection"
-            "- Variant E - Mid training random rank pruning"
-            "- Variant F - Mid training least L1 dimensions rank pruning"
-            "- Variant G - Dynamic quantized backbone (int8)"
-            "- Variant H - Dynamic quantized backbone (int4)"
+    variant: str = field(
+        default="0",
+        metadata={
+            "help": (
+                "Variants to choose from:"
+                "- Variant 0 - Normal LoRA"
+                "- Variant A - LoRA + intermediate layer"
+                "- Variant B - Input vector + frozen downprojection + up projection"
+                "- Variant C - Frozen downprojection + intermediate + up projection"
+                "- Variant D - Shared frozen downprojection + intermediate + up projection"
+                "- Variant E - Mid training random rank pruning"
+                "- Variant F - Mid training least L1 dimensions rank pruning"
+                "- Variant G - Dynamic quantized backbone (int8)"
+                "- Variant H - Dynamic quantized backbone (int4)"
             )
-        }
+        },
     )
     ### VARIANT SPECIFIC SETTINGS ###
     share_weights: bool = field(
@@ -77,7 +76,7 @@ class AblationConfig(PeftConfig):
         metadata={"help": "Track metrics during training."},
     )
     track_n: int = field(default=100, metadata={"help": "Average and store metrics every n steps."})
-    target_modules: Optional[Union[list[str], str]] = field(
+    target_modules: list[str] | str | None = field(
         default=None,
         metadata={
             "help": (
@@ -92,19 +91,17 @@ class AblationConfig(PeftConfig):
     alpha: int = field(default=8, metadata={"help": "Scaling factor, computed as alpha/rank."})
     init_weight: str = field(
         default="kaiming",
-        metadata={
-            "help": (
-                "Initialization of the adapter weights."
-            )
-        },
+        metadata={"help": ("Initialization of the adapter weights.")},
     )
     seed: int = field(default=42, metadata={"help": "Seed for initializing layers."})
-    bias: str = field(default="none", metadata={"help": "Bias type for Ablation. Can be 'none', 'all' or 'ablation_only'"})
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for Ablation. Can be 'none', 'all' or 'ablation_only'"}
+    )
     fan_in_fan_out: bool = field(
         default=False,
         metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
     )
-    modules_to_save: Optional[list[str]] = field(
+    modules_to_save: list[str] | None = field(
         default=None,
         metadata={
             "help": (
@@ -114,7 +111,7 @@ class AblationConfig(PeftConfig):
             )
         },
     )
-    layers_to_transform: Optional[Union[list[int], int]] = field(
+    layers_to_transform: list[int] | int | None = field(
         default=None,
         metadata={
             "help": (
@@ -124,7 +121,7 @@ class AblationConfig(PeftConfig):
             )
         },
     )
-    layers_pattern: Optional[Union[list[str], str]] = field(
+    layers_pattern: list[str] | str | None = field(
         default=None,
         metadata={
             "help": (
@@ -136,16 +133,18 @@ class AblationConfig(PeftConfig):
     )
 
     def __post_init__(self):
-        #super().__post_init__()
+        # super().__post_init__()
         # PEFT type
         self.peft_type = "ABLATION"
-        
+
         # Convert target_modules to list instead of set to avoid potential issues
         if isinstance(self.target_modules, list):
             self.target_modules = list(set(self.target_modules))  # Remove duplicates but keep as list
         elif isinstance(self.target_modules, set):
             self.target_modules = list(self.target_modules)  # Convert set to list
-            
+
         # check for layers_to_transform and layers_pattern
         if self.layers_pattern and not self.layers_to_transform:
-            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
\ No newline at end of file
+            raise ValueError(
+                "When `layers_pattern` is specified, `layers_to_transform` must also be specified. "
+            )
diff --git a/peft_models/ablation/layer.py b/src/mobiletransformers/peft/ablation/layer.py
similarity index 63%
rename from peft_models/ablation/layer.py
rename to src/mobiletransformers/peft/ablation/layer.py
index cc75ed6..4d3eff1 100644
--- a/peft_models/ablation/layer.py
+++ b/src/mobiletransformers/peft/ablation/layer.py
@@ -1,15 +1,22 @@
 import math
-from peft.tuners.tuners_utils import BaseTunerLayer
+
 import torch
 import torch.nn as nn
+from peft.tuners.tuners_utils import BaseTunerLayer
 
-from peft_models.ablation.config import AblationConfig, AblationVariant
+from mobiletransformers.peft.ablation.config import AblationConfig, AblationVariant
 
-class AblationLayer(BaseTunerLayer):
 
+class AblationLayer(BaseTunerLayer):
     adapter_layer_names = ()
 
-    def __init__(self, base_layer: nn.Module, ablation_config : AblationConfig, ablation_variant : AblationVariant, **kwargs) -> None:
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        ablation_config: AblationConfig,
+        ablation_variant: AblationVariant,
+        **kwargs,
+    ) -> None:
         self.base_layer = base_layer
 
         self.up_project = nn.ParameterDict({})
@@ -28,30 +35,34 @@ def __init__(self, base_layer: nn.Module, ablation_config : AblationConfig, abla
         elif self.ablation_variant == AblationVariant.VARIANT_D:
             self.intermediate = nn.ParameterDict({})
 
-    def update_layer(self, original_weights, adapter_name, ablation_config : AblationConfig, ablation_variant : AblationVariant):
+    def update_layer(
+        self,
+        original_weights,
+        adapter_name,
+        ablation_config: AblationConfig,
+        ablation_variant: AblationVariant,
+    ):
 
         self.ablation_variant = ablation_variant
         self.alpha = ablation_config.alpha / ablation_config.r
 
-        init_weight = getattr(ablation_config, 'init_weight', 'kaiming')
+        init_weight = getattr(ablation_config, "init_weight", "kaiming")
 
         # Initialize A matrix
         self.down_project[adapter_name] = nn.Parameter(
-            torch.empty(original_weights.in_features, ablation_config.r), 
-            requires_grad=True
+            torch.empty(original_weights.in_features, ablation_config.r), requires_grad=True
         )
-        
+
         if init_weight == "kaiming":
             torch.nn.init.kaiming_uniform_(self.down_project[adapter_name], a=math.sqrt(5))
         elif init_weight == "gaussian":
-            torch.nn.init.normal_(self.down_project[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+            torch.nn.init.normal_(self.down_project[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
         else:
             raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
-        
+
         # Initialize B matrix (up_project) with zeros - this will be trained
         self.up_project[adapter_name] = nn.Parameter(
-            torch.zeros(ablation_config.r, original_weights.out_features),
-            requires_grad=True
+            torch.zeros(ablation_config.r, original_weights.out_features), requires_grad=True
         )
 
         if self.ablation_variant == AblationVariant.VARIANT_0:
@@ -59,11 +70,13 @@ def update_layer(self, original_weights, adapter_name, ablation_config : Ablatio
 
         elif self.ablation_variant == AblationVariant.VARIANT_A:
             self.adapter_layer_names = ("down_project", "intermediate", "up_project")
-            self.intermediate[adapter_name] = nn.Parameter(torch.empty(ablation_config.r, ablation_config.r), requires_grad=True)
+            self.intermediate[adapter_name] = nn.Parameter(
+                torch.empty(ablation_config.r, ablation_config.r), requires_grad=True
+            )
             if init_weight == "kaiming":
                 torch.nn.init.kaiming_uniform_(self.intermediate[adapter_name], a=math.sqrt(5))
             elif init_weight == "gaussian":
-                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
             else:
                 raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
 
@@ -71,63 +84,64 @@ def update_layer(self, original_weights, adapter_name, ablation_config : Ablatio
             self.adapter_layer_names = ("input_vector", "up_project")
             # Initialize input vector with random normal distribution
             self.input_vector[adapter_name] = nn.Parameter(
-                torch.randn(original_weights.in_features), 
-                requires_grad=True
+                torch.randn(original_weights.in_features), requires_grad=True
             )
             # Cannot compute kaiming for a single vector
             if init_weight == "kaiming":
-                torch.nn.init.normal_(self.input_vector[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(self.input_vector[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
             elif init_weight == "gaussian":
-                torch.nn.init.normal_(self.input_vector[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(self.input_vector[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
             else:
                 raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
 
             self.down_project[adapter_name].requires_grad = False
         elif self.ablation_variant == AblationVariant.VARIANT_C:
             self.adapter_layer_names = ("intermediate", "up_project")
-            self.intermediate[adapter_name] = nn.Parameter(torch.empty(ablation_config.r, ablation_config.r), requires_grad=True)
+            self.intermediate[adapter_name] = nn.Parameter(
+                torch.empty(ablation_config.r, ablation_config.r), requires_grad=True
+            )
             if init_weight == "kaiming":
                 torch.nn.init.kaiming_uniform_(self.intermediate[adapter_name], a=math.sqrt(5))
             elif init_weight == "gaussian":
-                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
             else:
                 raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
             self.down_project[adapter_name].requires_grad = False
-        
+
         elif self.ablation_variant == AblationVariant.VARIANT_D:
             self.adapter_layer_names = ("intermediate", "up_project")
-            self.intermediate[adapter_name] = nn.Parameter(torch.empty(ablation_config.r, ablation_config.r), requires_grad=True)
+            self.intermediate[adapter_name] = nn.Parameter(
+                torch.empty(ablation_config.r, ablation_config.r), requires_grad=True
+            )
             if init_weight == "kaiming":
                 torch.nn.init.kaiming_uniform_(self.intermediate[adapter_name], a=math.sqrt(5))
             elif init_weight == "gaussian":
-                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(self.intermediate[adapter_name], mean=0.0, std=1.0 / ablation_config.r)
             else:
                 raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
             self.down_project[adapter_name].requires_grad = False
-        
+
         # Variant E and F
-        elif self.ablation_variant == AblationVariant.VARIANT_E or self.ablation_variant == AblationVariant.VARIANT_F:
+        elif (
+            self.ablation_variant == AblationVariant.VARIANT_E
+            or self.ablation_variant == AblationVariant.VARIANT_F
+        ):
             self.adapter_layer_names = ("down_project", "up_project")
         elif self.ablation_variant == AblationVariant.VARIANT_G:
             self.adapter_layer_names = ("down_project", "up_project")
             # Int8 quantized backbone (original weights)
-            self.base_layer = ManualQuantizedLinear(
-                original_weights, 
-                bits=8
-            )
+            self.base_layer = ManualQuantizedLinear(original_weights, bits=8)
         elif self.ablation_variant == AblationVariant.VARIANT_H:
             self.adapter_layer_names = ("down_project", "up_project")
             # Int4 quantized backbone (original weights)
-            self.base_layer = ManualQuantizedLinear(
-                original_weights,
-                bits=4
-            )
+            self.base_layer = ManualQuantizedLinear(original_weights, bits=4)
 
         self.adapter_name = adapter_name
 
         self._move_adapter_to_device_of_base_layer(adapter_name)
         self.set_adapter(adapter_name)
 
+
 class ManualQuantizedLinear(nn.Module):
     def __init__(self, original_linear, bits=8, symmetric=True, per_channel=True):
         super().__init__()
@@ -136,14 +150,14 @@ def __init__(self, original_linear, bits=8, symmetric=True, per_channel=True):
         self.bits = bits
         self.symmetric = symmetric
         self.per_channel = per_channel
-        
+
         self._quantize_weights(original_linear.weight.data)
-        
+
         if original_linear.bias is not None:
-            self.register_buffer('bias', original_linear.bias.data)
+            self.register_buffer("bias", original_linear.bias.data)
         else:
             self.bias = None
-    
+
     def _quantize_weights(self, weight):
         """Quantize weights with scale and zero point"""
         if self.bits == 8:
@@ -160,12 +174,12 @@ def _quantize_weights(self, weight):
             dtype = torch.int8  # Store in int8, but only use 4 bits
         else:
             raise ValueError("Only 4 and 8 bits supported")
-        
+
         if self.per_channel:
             # Per-channel quantization (per output channel)
             axis = 0  # Quantize along output dimension
             weight_reshaped = weight.view(weight.shape[0], -1)
-            
+
             if self.symmetric:
                 # Symmetric quantization: zero_point = 0
                 max_vals = weight_reshaped.abs().max(dim=1, keepdim=True)[0]
@@ -176,13 +190,13 @@ def _quantize_weights(self, weight):
                 # Asymmetric quantization: calculate optimal zero_point
                 min_vals = weight_reshaped.min(dim=1, keepdim=True)[0]
                 max_vals = weight_reshaped.max(dim=1, keepdim=True)[0]
-                
+
                 scales = (max_vals - min_vals) / (qmax - qmin)
                 scales = torch.clamp(scales, min=1e-8)
-                
+
                 zero_points = qmin - torch.round(min_vals / scales)
                 zero_points = torch.clamp(zero_points, qmin, qmax)
-            
+
             # Broadcast scales and zero_points back to weight shape
             scales = scales.view(-1, 1).expand_as(weight)
             zero_points = zero_points.view(-1, 1).expand_as(weight)
@@ -196,29 +210,29 @@ def _quantize_weights(self, weight):
             else:
                 min_val = weight.min()
                 max_val = weight.max()
-                
+
                 scales = (max_val - min_val) / (qmax - qmin)
                 scales = torch.clamp(scales, min=1e-8)
-                
+
                 zero_points = qmin - torch.round(min_val / scales)
                 zero_points = torch.clamp(zero_points, qmin, qmax)
-        
+
         # Quantize: q = round(x/scale + zero_point)
         quantized = torch.round(weight / scales + zero_points)
         quantized = torch.clamp(quantized, qmin, qmax)
-        
+
         # Store quantized weights and parameters
-        self.register_buffer('quantized_weight', quantized.to(dtype))
-        
+        self.register_buffer("quantized_weight", quantized.to(dtype))
+
         if self.per_channel:
             # Store per-channel scales and zero_points
-            self.register_buffer('scales', scales[:, 0])  # Take first column since all are same
-            self.register_buffer('zero_points', zero_points[:, 0].to(torch.int32))
+            self.register_buffer("scales", scales[:, 0])  # Take first column since all are same
+            self.register_buffer("zero_points", zero_points[:, 0].to(torch.int32))
         else:
             # Store per-tensor scales and zero_points
-            self.register_buffer('scales', scales)
-            self.register_buffer('zero_points', zero_points.to(torch.int32))
-    
+            self.register_buffer("scales", scales)
+            self.register_buffer("zero_points", zero_points.to(torch.int32))
+
     def dequantize_weights(self):
         """Dequantize weights: x = scale * (q - zero_point)"""
         if self.per_channel:
@@ -228,68 +242,72 @@ def dequantize_weights(self):
         else:
             scales = self.scales
             zero_points = self.zero_points
-        
+
         # Dequantize: x = scale * (q - zero_point)
         dequantized = scales * (self.quantized_weight.float() - zero_points.float())
         return dequantized
-    
+
     def forward(self, x):
         # Dequantize weights during forward pass
         dequantized_weight = self.dequantize_weights()
         return torch.nn.functional.linear(x, dequantized_weight, self.bias)
-    
+
     def get_quantization_info(self):
         """Return quantization parameters for inspection"""
         return {
-            'scales': self.scales,
-            'zero_points': self.zero_points,
-            'bits': self.bits,
-            'symmetric': self.symmetric,
-            'per_channel': self.per_channel,
-            'quantized_weight_shape': self.quantized_weight.shape,
-            'quantized_weight_dtype': self.quantized_weight.dtype
+            "scales": self.scales,
+            "zero_points": self.zero_points,
+            "bits": self.bits,
+            "symmetric": self.symmetric,
+            "per_channel": self.per_channel,
+            "quantized_weight_shape": self.quantized_weight.shape,
+            "quantized_weight_dtype": self.quantized_weight.dtype,
         }
 
+
 class Linear(nn.Module, AblationLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name,
+        ablation_variant: AblationVariant,
+        ablation_config: AblationConfig,
+        **kwargs,
+    ) -> None:
 
-    def __init__(self,
-                 base_layer,
-                 adapter_name,
-                 ablation_variant : AblationVariant,
-                 ablation_config : AblationConfig,
-                 **kwargs) -> None:
-        
         super().__init__()
         AblationLayer.__init__(self, base_layer, ablation_config, ablation_variant, **kwargs)
 
         self._active_adapter = adapter_name
         self.in_features = base_layer.in_features
         self.out_features = base_layer.out_features
-        self.update_layer(
-            base_layer, adapter_name, ablation_config, ablation_variant
-        )
+        self.update_layer(base_layer, adapter_name, ablation_config, ablation_variant)
 
         # Metric tracking setup
-        self.metric_tracking = ablation_config.metric_tracking if hasattr(ablation_config, 'metric_tracking') else False
-        self.track_n = ablation_config.track_n if hasattr(ablation_config, 'track_n') else 100
-        
+        self.metric_tracking = (
+            ablation_config.metric_tracking if hasattr(ablation_config, "metric_tracking") else False
+        )
+        self.track_n = ablation_config.track_n if hasattr(ablation_config, "track_n") else 100
+
         if self.metric_tracking:
             self.step_counter = 0
-            
+
             # Calibration-style storage
             self.in_activation_stats = []
             self.out_activation_stats = []
             self.weight_magnitudes = []
             self.gradient_norms = []
-            
+
             # Long-term storage
             self.stored_metrics = {}
 
-    def _track_layer_metrics_calibration(self, layer_name, input_tensor, output_tensor, param_tensor, active_adapter):
+    def _track_layer_metrics_calibration(
+        self, layer_name, input_tensor, output_tensor, param_tensor, active_adapter
+    ):
         """Calibration-style tracking for a single layer"""
         if not self.metric_tracking:
             return
-        
+
         with torch.no_grad():
             # Per-channel metrics
             if input_tensor.dim() == 3:  # (batch, seq, features)
@@ -298,104 +316,95 @@ def _track_layer_metrics_calibration(self, layer_name, input_tensor, output_tens
             else:  # (batch, features)
                 in_magnitude = torch.mean(torch.abs(input_tensor), dim=0)
                 out_magnitude = torch.mean(torch.abs(output_tensor), dim=0)
-            
+
             # Store activation stats
-            self.in_activation_stats.append({
-                'layer_name': layer_name,
-                'magnitude': in_magnitude.cpu().detach().numpy()
-            })
-            self.out_activation_stats.append({
-                'layer_name': layer_name,
-                'magnitude': out_magnitude.cpu().detach().numpy()
-            })
-            
+            self.in_activation_stats.append(
+                {"layer_name": layer_name, "magnitude": in_magnitude.cpu().detach().numpy()}
+            )
+            self.out_activation_stats.append(
+                {"layer_name": layer_name, "magnitude": out_magnitude.cpu().detach().numpy()}
+            )
+
             # Compute weight magnitudes
-            if 'down_project' in layer_name:
+            if "down_project" in layer_name:
                 weight_norm = torch.norm(param_tensor, p=1, dim=1)  # Shape: (input_channels,)
-            elif 'up_project' in layer_name:
+            elif "up_project" in layer_name:
                 weight_norm = torch.norm(param_tensor, p=1, dim=0)  # Shape: (output_channels,)
-            elif 'intermediate' in layer_name:
+            elif "intermediate" in layer_name:
                 weight_norm = torch.norm(param_tensor, p=1, dim=1)
-            elif 'input_vector' in layer_name:
+            elif "input_vector" in layer_name:
                 weight_norm = torch.abs(param_tensor)
             else:
                 weight_norm = torch.norm(param_tensor, p=1, dim=-1)
-            
+
             # Store weight magnitudes
-            self.weight_magnitudes.append({
-                'layer_name': layer_name,
-                'weight_norm': weight_norm.cpu().detach().numpy()
-            })
+            self.weight_magnitudes.append(
+                {"layer_name": layer_name, "weight_norm": weight_norm.cpu().detach().numpy()}
+            )
 
             # Store gradient norm if gradients exist
             if param_tensor.grad is not None:
                 grad_norm = param_tensor.grad.detach().norm(p=2).item()
             else:
                 grad_norm = 0.0
-                
-            self.gradient_norms.append({
-                'layer_name': layer_name,
-                'grad_norm': grad_norm
-            })
+
+            self.gradient_norms.append({"layer_name": layer_name, "grad_norm": grad_norm})
 
     def _store_channel_metrics(self, active_adapter):
         """Store aggregated channel metrics - called every track_n steps"""
         if not self.metric_tracking:
             return
-        
+
         # Get recent entries for this window
         window_start = max(0, len(self.in_activation_stats) - self.track_n)
-        
+
         # Aggregate metrics for this window
-        window_metrics = {
-            'step_range': (self.step_counter - self.track_n, self.step_counter),
-            'layers': {}
-        }
-        
+        window_metrics = {"step_range": (self.step_counter - self.track_n, self.step_counter), "layers": {}}
+
         # Group by layer name
         layer_groups = {}
         for i in range(window_start, len(self.in_activation_stats)):
-            layer_name = self.in_activation_stats[i]['layer_name']
+            layer_name = self.in_activation_stats[i]["layer_name"]
             if layer_name not in layer_groups:
                 layer_groups[layer_name] = {
-                    'in_magnitudes': [],
-                    'out_magnitudes': [],
-                    'weight_norms': [],
-                    "grad_norms": []
+                    "in_magnitudes": [],
+                    "out_magnitudes": [],
+                    "weight_norms": [],
+                    "grad_norms": [],
                 }
-            
-            layer_groups[layer_name]['in_magnitudes'].append(self.in_activation_stats[i]['magnitude'])
-            layer_groups[layer_name]['out_magnitudes'].append(self.out_activation_stats[i]['magnitude'])
-            layer_groups[layer_name]['weight_norms'].append(self.weight_magnitudes[i]['weight_norm'])
-            layer_groups[layer_name]['grad_norms'].append(self.gradient_norms[i]['grad_norm'])
-        
+
+            layer_groups[layer_name]["in_magnitudes"].append(self.in_activation_stats[i]["magnitude"])
+            layer_groups[layer_name]["out_magnitudes"].append(self.out_activation_stats[i]["magnitude"])
+            layer_groups[layer_name]["weight_norms"].append(self.weight_magnitudes[i]["weight_norm"])
+            layer_groups[layer_name]["grad_norms"].append(self.gradient_norms[i]["grad_norm"])
+
         # Compute aggregated statistics for each layer
         for layer_name, layer_data in layer_groups.items():
-            if layer_data['in_magnitudes']:
+            if layer_data["in_magnitudes"]:
                 import numpy as np
-                
-                in_mags = np.array(layer_data['in_magnitudes'])
-                out_mags = np.array(layer_data['out_magnitudes'])  
-                weight_norms = np.array(layer_data['weight_norms'])
-                
-                window_metrics['layers'][layer_name] = {
-                    'in_magnitude_mean': np.mean(in_mags, axis=0),
-                    'in_magnitude_std': np.std(in_mags, axis=0),
-                    'out_magnitude_mean': np.mean(out_mags, axis=0),
-                    'out_magnitude_std': np.std(out_mags, axis=0),
-                    'weight_norm_mean': np.mean(weight_norms, axis=0),
-                    'weight_norm_std': np.std(weight_norms, axis=0)
+
+                in_mags = np.array(layer_data["in_magnitudes"])
+                out_mags = np.array(layer_data["out_magnitudes"])
+                weight_norms = np.array(layer_data["weight_norms"])
+
+                window_metrics["layers"][layer_name] = {
+                    "in_magnitude_mean": np.mean(in_mags, axis=0),
+                    "in_magnitude_std": np.std(in_mags, axis=0),
+                    "out_magnitude_mean": np.mean(out_mags, axis=0),
+                    "out_magnitude_std": np.std(out_mags, axis=0),
+                    "weight_norm_mean": np.mean(weight_norms, axis=0),
+                    "weight_norm_std": np.std(weight_norms, axis=0),
                 }
 
-                if layer_data['grad_norms']:
-                    grad_norms = np.array(layer_data['grad_norms'])
-                    window_metrics['layers'][layer_name]['grad_norm_mean'] = np.mean(grad_norms)
-                    window_metrics['layers'][layer_name]['grad_norm_std'] = np.std(grad_norms)
-        
+                if layer_data["grad_norms"]:
+                    grad_norms = np.array(layer_data["grad_norms"])
+                    window_metrics["layers"][layer_name]["grad_norm_mean"] = np.mean(grad_norms)
+                    window_metrics["layers"][layer_name]["grad_norm_std"] = np.std(grad_norms)
+
         # Store in long-term storage
-        if 'windows' not in self.stored_metrics:
-            self.stored_metrics['windows'] = []
-        self.stored_metrics['windows'].append(window_metrics)
+        if "windows" not in self.stored_metrics:
+            self.stored_metrics["windows"] = []
+        self.stored_metrics["windows"].append(window_metrics)
 
         # Clear buffers to prevent memory growth
         self.in_activation_stats.clear()
@@ -413,281 +422,297 @@ def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
         elif self.merged:
             result = self.base_layer(x, *args, **kwargs)
         else:
-            
             result = self.base_layer(x, *args, **kwargs)
 
             # Update counter
             if self.metric_tracking:
                 self.step_counter += 1
-            
+
             for active_adapter in self.active_adapters:
                 if active_adapter not in self.up_project.keys():
                     continue
-                
-                
+
                 if self.ablation_variant == AblationVariant.VARIANT_0:
                     # Normal LoRA: x -> down_project -> up_project
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_A:
                     # LoRA + intermediate: x -> down_project -> intermediate -> up_project
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     intermediate_output = adapter_output @ self.intermediate[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'intermediate', 
-                            adapter_output, intermediate_output, 
-                            self.intermediate[active_adapter], 
-                            active_adapter
+                            "intermediate",
+                            adapter_output,
+                            intermediate_output,
+                            self.intermediate[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = intermediate_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            intermediate_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            intermediate_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_B:
                     # Input vector + frozen down + up: (x * input_vector) -> down_project -> up_project
                     x_modified = x * self.input_vector[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'input_vector', 
-                            x, x_modified, 
-                            self.input_vector[active_adapter], 
-                            active_adapter
+                            "input_vector", x, x_modified, self.input_vector[active_adapter], active_adapter
                         )
-                    
+
                     adapter_output = x_modified @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x_modified, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x_modified,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_C:
                     # Frozen down + intermediate + up: x -> down_project -> intermediate -> up_project
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     intermediate_output = adapter_output @ self.intermediate[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'intermediate', 
-                            adapter_output, intermediate_output, 
-                            self.intermediate[active_adapter], 
-                            active_adapter
+                            "intermediate",
+                            adapter_output,
+                            intermediate_output,
+                            self.intermediate[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = intermediate_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            intermediate_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            intermediate_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_D:
                     # Shared frozen down + intermediate + up: x -> down_project -> intermediate -> up_project
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     intermediate_output = adapter_output @ self.intermediate[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'intermediate', 
-                            adapter_output, intermediate_output, 
-                            self.intermediate[active_adapter], 
-                            active_adapter
+                            "intermediate",
+                            adapter_output,
+                            intermediate_output,
+                            self.intermediate[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = intermediate_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            intermediate_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            intermediate_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_E:
                     # Mid training random rank pruning (assume already pruned)
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_F:
                     # Mid training least L1 dimensions rank pruning (assume already pruned)
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_G:
                     # Int8 quantized backbone - only adapter computation (base already computed above)
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                    
+
                 elif self.ablation_variant == AblationVariant.VARIANT_H:
                     # Int4 quantized backbone - only adapter computation (base already computed above)
                     adapter_output = x @ self.down_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'down_project', 
-                            x, adapter_output, 
-                            self.down_project[active_adapter], 
-                            active_adapter
+                            "down_project",
+                            x,
+                            adapter_output,
+                            self.down_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     adapter_output_final = adapter_output @ self.up_project[active_adapter]
-                    
+
                     if self.metric_tracking:
                         self._track_layer_metrics_calibration(
-                            f'up_project', 
-                            adapter_output, adapter_output_final, 
-                            self.up_project[active_adapter], 
-                            active_adapter
+                            "up_project",
+                            adapter_output,
+                            adapter_output_final,
+                            self.up_project[active_adapter],
+                            active_adapter,
                         )
-                    
+
                     result += adapter_output_final * self.alpha
-                                
+
         # Store metrics every track_n steps
         if self.metric_tracking and self.step_counter % self.track_n == 0:
             self._store_channel_metrics(active_adapter)
 
         result = result.to(previous_dtype)
         return result
-    
+
     def get_delta_weight(self, adapter) -> torch.Tensor:
         # This function is introduced in newer PEFT versions. we modify this function instead of modifying
         # the merge function (as we did previously for version 0.4.0 of PEFT).
@@ -697,10 +722,25 @@ def get_delta_weight(self, adapter) -> torch.Tensor:
         Args:
             adapter (str):
                 The name of the adapter for which the delta weight should be computed.
+
+        Raises:
+            NotImplementedError: always. Merging is genuinely unimplemented for ablation PEFT — the
+                adapter's contribution is a zip-merge into a latent space, which has no closed-form
+                delta the way LoRA's ``B @ A`` does.
+
+        This used to ``pass``, i.e. return ``None``. PEFT's ``merge()`` adds the returned delta to the
+        base weight, so the whole merge completed "successfully" and wrote **nothing** — the caller got
+        an untrained model reported as merged. That is the recurring failure shape in this project
+        (a merge that happened without being correct), and it is worth an exception rather than a
+        silent no-op even though this method is only reachable on an unsupported path.
         """
-        # TODO: Implement merging (zip merging to a certain latent space)
-        pass
+        raise NotImplementedError(
+            f"merging is not implemented for ablation PEFT (adapter {adapter!r}). The ablation "
+            "adapter's contribution is a zip-merge into a latent space with no closed-form delta "
+            "weight. Use LoRA or MARS if you need an on-device merge; ablation is a research method "
+            "for measuring adapter contributions, not a shipping handoff path."
+        )
 
     def __repr__(self) -> str:
         rep = super().__repr__()
-        return "abl." + rep
\ No newline at end of file
+        return "abl." + rep
diff --git a/peft_models/ablation/model.py b/src/mobiletransformers/peft/ablation/model.py
similarity index 87%
rename from peft_models/ablation/model.py
rename to src/mobiletransformers/peft/ablation/model.py
index a7994ea..0a9fffe 100644
--- a/peft_models/ablation/model.py
+++ b/src/mobiletransformers/peft/ablation/model.py
@@ -1,16 +1,18 @@
 import math
 import os
 import warnings
+
+import torch
 from peft.config import PeftConfig
 from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
-import torch
-from torch.nn.modules import Module
 from safetensors.torch import save_file
+from torch.nn.modules import Module
 
-from peft_models.ablation.config import AblationConfig, AblationVariant
+from mobiletransformers.peft.ablation.config import AblationConfig, AblationVariant
 
-from .utils import TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING
 from .layer import AblationLayer, Linear
+from .utils import TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING
+
 
 class AblationModel(BaseTuner):
     """
@@ -30,8 +32,14 @@ class AblationModel(BaseTuner):
 
     prefix: str = "ablation"
 
-    def __init__(self, model, peft_config: PeftConfig | dict[str, PeftConfig], adapter_name: str = "ablation", low_cpu_mem_usage: bool = False) -> None:
-        
+    def __init__(
+        self,
+        model,
+        peft_config: PeftConfig | dict[str, PeftConfig],
+        adapter_name: str = "ablation",
+        low_cpu_mem_usage: bool = False,
+    ) -> None:
+
         ablation_mapping = {
             "0": AblationVariant.VARIANT_0,
             "A": AblationVariant.VARIANT_A,
@@ -45,33 +53,39 @@ def __init__(self, model, peft_config: PeftConfig | dict[str, PeftConfig], adapt
         }
 
         # Get the correct variant
-        self.ablation_variant = ablation_mapping[peft_config['ablation'].variant]
+        self.ablation_variant = ablation_mapping[peft_config["ablation"].variant]
 
         super().__init__(model, peft_config, adapter_name, low_cpu_mem_usage)
 
     def _pre_injection_hook(self, model: Module, config: PeftConfig, adapter_name: str) -> None:
         self.shared_weights = {}
 
-    def _create_and_replace(self, ablation_config : AblationConfig, adapter_name: str, target, target_name: str, parent, current_key: str, **kwargs) -> None:
+    def _create_and_replace(
+        self,
+        ablation_config: AblationConfig,
+        adapter_name: str,
+        target,
+        target_name: str,
+        parent,
+        current_key: str,
+        **kwargs,
+    ) -> None:
 
         if current_key is None:
             raise ValueError("Current Key shouldn't be `None`")
-        
+
         bias = hasattr(target, "bias") and target.bias is not None
 
         if isinstance(target, Linear):
-            target.update_layer(
-                target,
-                adapter_name,
-                ablation_config,
-                self.ablation_variant
-            )
+            target.update_layer(target, adapter_name, ablation_config, self.ablation_variant)
 
             if ablation_config.share_weights or self.ablation_variant == AblationVariant.VARIANT_D:
                 target = self._shared_and_store_weights(target, ablation_config)
 
         else:
-            new_module = self._create_new_module(ablation_config, self.ablation_variant, adapter_name, target, **kwargs)
+            new_module = self._create_new_module(
+                ablation_config, self.ablation_variant, adapter_name, target, **kwargs
+            )
 
             if ablation_config.share_weights or self.ablation_variant == AblationVariant.VARIANT_D:
                 new_module = self._shared_and_store_weights(new_module, ablation_config)
@@ -81,27 +95,28 @@ def _create_and_replace(self, ablation_config : AblationConfig, adapter_name: st
 
             self._replace_module(parent, target_name, new_module, target)
 
-
     def _shared_and_store_weights(self, new_module, ablation_config):
         # Ensure weight sharing in new_module.down_project
-        down_project_shape = f"{new_module.in_features}x{ablation_config.r}"  # Use a string key for ParameterDict
+        down_project_shape = (
+            f"{new_module.in_features}x{ablation_config.r}"  # Use a string key for ParameterDict
+        )
 
         if down_project_shape in self.shared_weights:
             # Reuse existing shared weights
             new_module.down_project[self.active_adapter] = self.shared_weights[down_project_shape]
-        else:            
+        else:
             # Generate new shared weights
             A = torch.empty(ablation_config.r, new_module.in_features)
 
-            init_weight = getattr(ablation_config, 'init_weight', 'kaiming')  # Default to kaiming
+            init_weight = getattr(ablation_config, "init_weight", "kaiming")  # Default to kaiming
 
             if init_weight == "kaiming":
                 torch.nn.init.kaiming_uniform_(A, a=math.sqrt(5))
             elif init_weight == "gaussian":
-                torch.nn.init.normal_(A, mean=0.0, std=1.0/ablation_config.r)
+                torch.nn.init.normal_(A, mean=0.0, std=1.0 / ablation_config.r)
             else:
                 raise ValueError(f"Unknown init_weight: {init_weight}. Use 'kaiming' or 'gaussian'")
-            
+
             # Store only the Parameter, not the Linear module
             shared_weight_param = torch.nn.Parameter(A.T.contiguous(), requires_grad=False)
             self.shared_weights[down_project_shape] = shared_weight_param
@@ -157,17 +172,17 @@ def _create_new_module(ablation_config, ablation_variant, adapter_name, target,
                 f"Target module {target} is not supported. Currently, only the following modules are supported: "
                 "`torch.nn.Linear`"
             )
-        
+
         new_module = Linear(
             base_layer=target,
             adapter_name=adapter_name,
             ablation_variant=ablation_variant,
             ablation_config=ablation_config,
-            **kwargs
+            **kwargs,
         )
 
         return new_module
-    
+
     @staticmethod
     def _check_target_module_exists(ablation_config, key):
         return check_target_module_exists(ablation_config, key)
@@ -181,9 +196,9 @@ def _prepare_adapter_config(peft_config, model_config):
                 TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING[model_config["model_type"]]
             )
         return peft_config
-    
+
     def _mark_only_adapters_as_trainable(self, model: torch.nn.Module) -> None:
-        
+
         for n, p in model.named_parameters():
             if self.prefix not in n:
                 p.requires_grad = False
@@ -202,7 +217,7 @@ def _mark_only_adapters_as_trainable(self, model: torch.nn.Module) -> None:
                         m.bias.requires_grad = True
             else:
                 raise NotImplementedError(f"Requested bias: {bias}, is not implemented.")
-    
+
     def enable_adapter_layers(self) -> None:
         """Enable all adapters.
 
@@ -224,16 +239,18 @@ def disable_adapter_layers(self) -> None:
                 )
                 warnings.warn(msg)
         self._set_adapter_layers(enabled=False)
-    
+
     def set_adapter(self, adapter_name):
         for module in self.model.modules():
             if isinstance(module, AblationLayer):
                 if module.merged:
-                    warnings.warn("Adapter cannot be set when the model is merged. Unmerging the model first.")
+                    warnings.warn(
+                        "Adapter cannot be set when the model is merged. Unmerging the model first."
+                    )
                     module.unmerge()
                 module.set_adapter(adapter_name)
         self.active_adapter = adapter_name
-    
+
     def save_pretrained(self, save_directory: str, safe_serialization: bool = True) -> None:
         """
         Saves the trainable adapter weights of the AblationModel in safetensors format.
@@ -268,4 +285,4 @@ def save_pretrained(self, save_directory: str, safe_serialization: bool = True)
         for adapter_name, config in self.peft_config.items():
             config.save_pretrained(save_directory)
 
-        print(f"Ablation adapters saved to {save_directory}")
\ No newline at end of file
+        print(f"Ablation adapters saved to {save_directory}")
diff --git a/src/mobiletransformers/peft/ablation/utils.py b/src/mobiletransformers/peft/ablation/utils.py
new file mode 100644
index 0000000..4e73b3c
--- /dev/null
+++ b/src/mobiletransformers/peft/ablation/utils.py
@@ -0,0 +1,11 @@
+"""Ablation target-module table.
+
+DEDUPLICATED (#6): the table itself lives once in
+``mobiletransformers.config.registry.peft.PEFT_TARGET_MODULES_BY_MODEL_TYPE``. This module and
+``peft_models/mars/utils.py`` used to carry byte-identical copies under two different names, so a
+new model type had to be added twice or the two silently drifted apart.
+"""
+
+from mobiletransformers.config.registry.peft import PEFT_TARGET_MODULES_BY_MODEL_TYPE
+
+TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING = PEFT_TARGET_MODULES_BY_MODEL_TYPE
diff --git a/src/mobiletransformers/peft/adapters.py b/src/mobiletransformers/peft/adapters.py
new file mode 100644
index 0000000..203e414
--- /dev/null
+++ b/src/mobiletransformers/peft/adapters.py
@@ -0,0 +1,29 @@
+"""Loading serialized adapter weights back onto a PEFT-wrapped model.
+
+Migration Map S8 side-effect: this lived in ``research/utils.py``, but the only caller is the packaged
+`evaluation.eval_adapter_models` evaluator. A packaged module importing `research.` works from a
+checkout and fails from an installed wheel — `research/` is not part of the distribution — so the
+helper moved rather than the import being allow-listed. `research/utils.py` re-exports it.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+
+def load_mars_adapters(model: Any, adapter_path: str) -> Any:
+    """Load a safetensors adapter file onto ``model`` in place and return it.
+
+    ``strict=False``: the file holds only the adapted tensors, so the base model's own parameters are
+    legitimately "missing" from it. That also means a wholly mismatched file loads silently — the
+    caller is responsible for pairing an adapter with the model it was trained against.
+    """
+    from safetensors.torch import load_file
+
+    if not os.path.exists(adapter_path):
+        raise FileNotFoundError(f"Adapter file not found: {adapter_path}")
+
+    adapter_state_dict = load_file(adapter_path)
+    model.base_model.model.load_state_dict(adapter_state_dict, strict=False)
+    return model
diff --git a/src/mobiletransformers/peft/lora_xs/__init__.py b/src/mobiletransformers/peft/lora_xs/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/peft_models/lora_xs/initialization_utils.py b/src/mobiletransformers/peft/lora_xs/initialization_utils.py
similarity index 74%
rename from peft_models/lora_xs/initialization_utils.py
rename to src/mobiletransformers/peft/lora_xs/initialization_utils.py
index ccd9cb8..fd96e58 100644
--- a/peft_models/lora_xs/initialization_utils.py
+++ b/src/mobiletransformers/peft/lora_xs/initialization_utils.py
@@ -8,16 +8,16 @@
 from torch.nn import init
 from tqdm import tqdm
 
-from .latent_utils import get_delta_weight, forward_latent
+from .latent_utils import forward_latent, get_delta_weight
 from .svd_utils import get_linear_rec_svd
 
 
 def get_replacement_module(weight, module_name, type, writer, reconstruct_config):
     cfg = reconstruct_config[type]
-    if type == 'svd':
-        reconstructed_matrix, enc, dec = get_linear_rec_svd(weight.cpu().detach().numpy(), cfg['rank'],
-                                                            cfg['n_iter'],
-                                                            cfg['random_state'])
+    if type == "svd":
+        reconstructed_matrix, enc, dec = get_linear_rec_svd(
+            weight.cpu().detach().numpy(), cfg["rank"], cfg["n_iter"], cfg["random_state"]
+        )
         final_enc = torch.tensor(enc, dtype=weight.dtype, device=weight.device)
         final_dec = torch.tensor(dec, dtype=weight.dtype, device=weight.device)
     else:
@@ -57,23 +57,25 @@ def update_decoder_weights(target_module, new_weight):
 
 def kaiming_uniform_init_lower_half(matrix: torch.tensor):
     rows, _ = matrix.size()
-    init.kaiming_uniform_(matrix[math.ceil(rows / 2):, :], a=math.sqrt(5))
+    init.kaiming_uniform_(matrix[math.ceil(rows / 2) :, :], a=math.sqrt(5))
     return matrix
 
+
 def kaiming_uniform_init(matrix: torch.tensor):
     init.kaiming_uniform_(matrix, a=math.sqrt(5))
     return matrix
-  
+
+
 def find_and_initialize(model, peft_config, adapter_name, reconstr_type, reconstruct_config, writer):
     """
     :param adapter_name: options: 'default'
     :param reconstr_type: options: 'svd'
     """
-    half_init_dec = reconstruct_config['half_init_dec']
-    replacement_module_random_init = reconstruct_config['replacement_module_random_init']
-    reconstruction_mode = reconstruct_config['reconstr_mode']
+    half_init_dec = reconstruct_config["half_init_dec"]
+    replacement_module_random_init = reconstruct_config["replacement_module_random_init"]
+    reconstruction_mode = reconstruct_config["reconstr_mode"]
     lora_config = peft_config[adapter_name]
-    r_squared = reconstruct_config['r_squared']  # whether using r*r matrix between lora_A and lora_B or not
+    r_squared = reconstruct_config["r_squared"]  # whether using r*r matrix between lora_A and lora_B or not
     loaded_in_8bit = getattr(model, "is_loaded_in_8bit", False)
     if loaded_in_8bit and not is_bnb_available():
         raise ImportError(
@@ -82,7 +84,7 @@ def find_and_initialize(model, peft_config, adapter_name, reconstr_type, reconst
         )
     is_target_modules_in_base_model = False
     key_list = [key for key, _ in model.named_modules()]
-    assert (not isinstance(lora_config.target_modules, str))
+    assert not isinstance(lora_config.target_modules, str)
     print("Iterating through model's specified modules to initialize A/B matrices.")
     for key in tqdm(key_list):
         target_module_found = any(key.endswith(target_key) for target_key in lora_config.target_modules)
@@ -91,15 +93,19 @@ def find_and_initialize(model, peft_config, adapter_name, reconstr_type, reconst
                 is_target_modules_in_base_model = True
             _, target, target_name = _get_submodules(model, key)
 
-            if reconstruction_mode == 'separated':
-                replacement_encoder_weight, replacement_decoder_weight = get_replacement_module(weight=target.weight.T,
-                                                                                                module_name=key,
-                                                                                                type=reconstr_type,
-                                                                                                writer=writer,
-                                                                                                reconstruct_config=reconstruct_config)
+            if reconstruction_mode == "separated":
+                replacement_encoder_weight, replacement_decoder_weight = get_replacement_module(
+                    weight=target.weight.T,
+                    module_name=key,
+                    type=reconstr_type,
+                    writer=writer,
+                    reconstruct_config=reconstruct_config,
+                )
 
                 if not isinstance(target, peft.tuners.lora.Linear):
-                    raise NotImplementedError('Only initialization for peft.tuners.lora.Linear type is implemented.')
+                    raise NotImplementedError(
+                        "Only initialization for peft.tuners.lora.Linear type is implemented."
+                    )
                     # TODO implement for Linear8bitLt
                 else:
                     if half_init_dec:
@@ -112,12 +118,18 @@ def find_and_initialize(model, peft_config, adapter_name, reconstr_type, reconst
                         target.forward = types.MethodType(forward_latent, target)
                         target.get_delta_weight = types.MethodType(get_delta_weight, target)
                         replace_module_weights(target.lora_A.default, replacement_encoder_weight.T)
-                        target.default_lora_latent_mapping = torch.nn.Linear(lora_config.r, lora_config.r, bias=False)
+                        target.default_lora_latent_mapping = torch.nn.Linear(
+                            lora_config.r, lora_config.r, bias=False
+                        )
                         init_module_weights(target.default_lora_latent_mapping, sigma=0.00001)
                         target.default_lora_latent_mapping.to(target.lora_A.default.weight.device)
 
-                        target.lora_A.default.weight.requires_grad = False  # only the r*r matrix will be tuned
-                        target.lora_B.default.weight.requires_grad = False  # only the r*r matrix will be tuned
+                        target.lora_A.default.weight.requires_grad = (
+                            False  # only the r*r matrix will be tuned
+                        )
+                        target.lora_B.default.weight.requires_grad = (
+                            False  # only the r*r matrix will be tuned
+                        )
 
                     else:
                         init_module_weights(target.lora_A.default, sigma=0.00001)
diff --git a/peft_models/lora_xs/latent_utils.py b/src/mobiletransformers/peft/lora_xs/latent_utils.py
similarity index 93%
rename from peft_models/lora_xs/latent_utils.py
rename to src/mobiletransformers/peft/lora_xs/latent_utils.py
index 3d121f9..c68486d 100644
--- a/peft_models/lora_xs/latent_utils.py
+++ b/src/mobiletransformers/peft/lora_xs/latent_utils.py
@@ -1,4 +1,3 @@
-import warnings
 import torch
 import torch.nn.functional as F
 
@@ -32,10 +31,10 @@ def get_delta_weight(self, adapter) -> torch.Tensor:
         weight_A = weight_A.float()
         weight_B = weight_B.float()
 
-    output_tensor = transpose(
-        weight_B @ self.default_lora_latent_mapping.weight @ weight_A,
-        self.fan_in_fan_out
-    ) * self.scaling[adapter]
+    output_tensor = (
+        transpose(weight_B @ self.default_lora_latent_mapping.weight @ weight_A, self.fan_in_fan_out)
+        * self.scaling[adapter]
+    )
 
     if cast_to_fp32:
         output_tensor = output_tensor.to(dtype=dtype)
@@ -76,4 +75,3 @@ def forward_latent(self, x: torch.Tensor):
     result = result.to(previous_dtype)
 
     return result
-
diff --git a/peft_models/lora_xs/merger.py b/src/mobiletransformers/peft/lora_xs/merger.py
similarity index 57%
rename from peft_models/lora_xs/merger.py
rename to src/mobiletransformers/peft/lora_xs/merger.py
index aab4302..f8bab3f 100644
--- a/peft_models/lora_xs/merger.py
+++ b/src/mobiletransformers/peft/lora_xs/merger.py
@@ -1,27 +1,30 @@
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from peft import PeftModel, PeftConfig, LoraConfig, get_peft_model
 import argparse
-import torch
-import os
 import json
-from pathlib import Path
+import os
+
+from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model
 from safetensors import safe_open
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from mobiletransformers.config.constants import PEFTMethod
+
 from .initialization_utils import find_and_initialize
 
 
 def main(args):
 
-    if args.peft_method == "lora":
-        return load_and_merge_lora_model(model_name_or_path=args.base_model,
-                                         peft_model_path=args.adapter,
-                                         save_directory=args.output_path)
+    # #6: dispatch on the typed enum, not the raw wire string (PEFTMethod fails closed on unknown).
+    if PEFTMethod(args.peft_method) is PEFTMethod.LORA:
+        return load_and_merge_lora_model(
+            model_name_or_path=args.base_model, peft_model_path=args.adapter, save_directory=args.output_path
+        )
 
     model = AutoModelForCausalLM.from_pretrained(
         args.base_model,
         # torch_dtype=torch.float16,
-        device_map='auto',
+        device_map="auto",
     )
-    tokenizer = AutoTokenizer.from_pretrained(args.base_model, device_map='auto')
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model, device_map="auto")
     with open(os.path.join(args.adapter, "adapter_config.json")) as f:
         lora_config_dict = json.load(f)
     lora_config = LoraConfig(**lora_config_dict)
@@ -33,39 +36,45 @@ def main(args):
 
     # TODO: Hardcoded
     reconstr_config = {
-        'reconstruction_type': "svd",
-        'reconstr_mode': "separated",
-        'half_init_dec': False,
-        'replacement_module_random_init': False,
-        'r_squared': True,
-        'svd': {
+        "reconstruction_type": "svd",
+        "reconstr_mode": "separated",
+        "half_init_dec": False,
+        "replacement_module_random_init": False,
+        "r_squared": True,
+        "svd": {
             # TODO: hardcoded
-            'rank': args.rank,
-            'n_iter': 10,
-            'random_state': 42
-        }
+            "rank": args.rank,
+            "n_iter": 10,
+            "random_state": 42,
+        },
     }
 
-    reconstr_type = reconstr_config['reconstruction_type']
+    reconstr_type = reconstr_config["reconstruction_type"]
 
     # in order to accelerate model preparation, svd iterations will be set to 1.
-    reconstr_config['svd']['n_iter'] = 1
+    reconstr_config["svd"]["n_iter"] = 1
 
-    find_and_initialize(model, peft_config_dict, adapter_name=adapter_name, reconstr_type=reconstr_type, writer=None, reconstruct_config=reconstr_config)
+    find_and_initialize(
+        model,
+        peft_config_dict,
+        adapter_name=adapter_name,
+        reconstr_type=reconstr_type,
+        writer=None,
+        reconstruct_config=reconstr_config,
+    )
 
     peft_model_weights = {}
-    with safe_open(os.path.join(args.adapter, "adapter_model.safetensors"),
-                   framework="pt", device="cpu") as f:
+    with safe_open(
+        os.path.join(args.adapter, "adapter_model.safetensors"), framework="pt", device="cpu"
+    ) as f:
         for key in f.keys():
             peft_model_weights[key] = f.get_tensor(key)
     renamed_state_dict = {
-        k.replace(
-            "lora_A", "lora_A.default"
-        ).replace(
-            "lora_B", "lora_B.default"
-        ).replace(
-            "_lora_latent", ".default_lora_latent"): v
-        for (k, v) in peft_model_weights.items() if "classifier.out_proj" not in k
+        k.replace("lora_A", "lora_A.default")
+        .replace("lora_B", "lora_B.default")
+        .replace("_lora_latent", ".default_lora_latent"): v
+        for (k, v) in peft_model_weights.items()
+        if "classifier.out_proj" not in k
     }
     model.load_state_dict(renamed_state_dict, strict=False)
     print("merging the LoRA into the base model.")
@@ -74,11 +83,12 @@ def main(args):
     model.save_pretrained(args.output_path)
     tokenizer.save_pretrained(args.output_path)
 
+
 def load_and_merge_lora_model(model_name_or_path, peft_model_path, save_directory):
     """
-    Loads a base model, applies a LoRA adapter, merges the LoRA adapters into the model, 
+    Loads a base model, applies a LoRA adapter, merges the LoRA adapters into the model,
     and saves the merged model and tokenizer.
-    
+
     Args:
         model_name_or_path (str): Path or name of the base model.
         peft_model_path (str): Path to the directory containing the LoRA adapter.
@@ -87,11 +97,11 @@ def load_and_merge_lora_model(model_name_or_path, peft_model_path, save_director
     # Load base model and tokenizer
     model = AutoModelForCausalLM.from_pretrained(model_name_or_path)
     tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
-    
+
     # Load PEFT config and initialize LoRA model
     peft_config = PeftConfig.from_pretrained(peft_model_path)
     model = PeftModel.from_pretrained(model, peft_model_path, config=peft_config)
-    
+
     # Merge LoRA weights into base model
     model = model.merge_and_unload()
 
@@ -101,12 +111,13 @@ def load_and_merge_lora_model(model_name_or_path, peft_model_path, save_director
 
     print(f"Model and tokenizer saved to {save_directory}.")
 
+
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Merge Adapter to Base Model')
-    parser.add_argument('--base_model', type=str)
-    parser.add_argument('--adapter', type=str)
-    parser.add_argument('--output_path', type=str)
-    parser.add_argument('--peft_method', type=str)
-    parser.add_argument('--rank', type=int)
+    parser = argparse.ArgumentParser(description="Merge Adapter to Base Model")
+    parser.add_argument("--base_model", type=str)
+    parser.add_argument("--adapter", type=str)
+    parser.add_argument("--output_path", type=str)
+    parser.add_argument("--peft_method", type=str)
+    parser.add_argument("--rank", type=int)
     args = parser.parse_args()
     main(args)
diff --git a/src/mobiletransformers/peft/lora_xs/svd_utils.py b/src/mobiletransformers/peft/lora_xs/svd_utils.py
new file mode 100644
index 0000000..4bafca4
--- /dev/null
+++ b/src/mobiletransformers/peft/lora_xs/svd_utils.py
@@ -0,0 +1,41 @@
+"""Truncated-SVD helpers for LoRA-XS initialization.
+
+scikit-learn is imported lazily, inside :func:`run_svd`. At module scope it was an import-time
+dependency of ``export/training_export.py`` (via ``initialization_utils``), so **every** training-stage
+export — including plain LoRA and MARS, which never touch SVD — died with `ModuleNotFoundError: No
+module named 'sklearn'` before doing any work. scikit-learn is not in the `ort-training-local` profile;
+only the LoRA-XS path actually needs it, and that path now says so with a message naming the fix.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from sklearn.decomposition import TruncatedSVD
+
+
+def run_svd(
+    input_matrix: np.ndarray, rank: int, n_iter: int, random_state: int
+) -> tuple[np.ndarray, "TruncatedSVD"]:
+    try:
+        from sklearn.decomposition import TruncatedSVD
+    except ImportError as exc:  # pragma: no cover - depends on the active profile
+        raise ImportError(
+            "LoRA-XS initialization needs scikit-learn, which is not part of the training profile. "
+            "Install it alongside the profile (`uv pip install scikit-learn`) or choose --peft lora/mars."
+        ) from exc
+
+    svd = TruncatedSVD(n_components=rank, n_iter=n_iter, random_state=random_state)
+    svd.fit(input_matrix)
+    reduced_matrix = svd.transform(input_matrix)
+    return reduced_matrix, svd
+
+
+def get_linear_rec_svd(
+    input_matrix: np.ndarray, rank: int, n_iter: int, random_state: int
+) -> tuple[np.ndarray, np.ndarray, Any]:
+    reduced_matrix, svd = run_svd(input_matrix, rank, n_iter, random_state)
+
+    reconstructed_matrix = svd.inverse_transform(reduced_matrix)
+    return reconstructed_matrix, reduced_matrix, svd.components_
diff --git a/src/mobiletransformers/peft/mapping.py b/src/mobiletransformers/peft/mapping.py
new file mode 100644
index 0000000..74898e0
--- /dev/null
+++ b/src/mobiletransformers/peft/mapping.py
@@ -0,0 +1,221 @@
+"""Base-layer -> adapter-tensor mapping builders (MARS and LoRA).
+
+Migrated from ``trainer/utils.py`` (Migration Map S4). These are the two builders the #6 registry
+resolves through :func:`mobiletransformers.config.registry.peft.build_adapter_mapping` — callers pass a
+``PEFTMethod`` and never choose between them directly.
+
+They are genuinely different walks, not one function with a flag: MARS tracks shared-module identity
+and qkv/mlp adapter indices, LoRA is a flat ``named_modules`` scan.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.config.registry.architecture import ArchitectureSpec, resolve_architecture
+
+
+def _arch_spec_for(model) -> ArchitectureSpec:
+    """The architecture spec behind a PEFT-wrapped model.
+
+    Prefers the one the MARS tuner already resolved (``peft_model.base_model`` is the ``MarsModel``),
+    so the mapping and the wrap can never disagree about which naming applies. Falls back to
+    resolving from the wrapped HF model, which fails closed on an unknown architecture.
+    """
+    tuner = getattr(model, "base_model", None)
+    spec = getattr(tuner, "_arch_spec", None)
+    if isinstance(spec, ArchitectureSpec):
+        return spec
+    inner = getattr(tuner, "model", None) or model
+    return resolve_architecture(inner.config, architecture=type(inner).__name__)
+
+
+def _projection_role(model, base_layer_name: str) -> str | None:
+    """``...attention.self.value.base_layer`` -> ``"v"``; ``...self_attn.v_proj.base_layer`` -> ``"v"``."""
+    parent = base_layer_name.rsplit(".base_layer", 1)[0]
+    return _arch_spec_for(model).role_for_module(parent)
+
+
+def create_mars_adapter_mapping(model, shared_qkv=["q", "k", "v"], shared_mlp_enabled=True):
+    """
+    Create a JSON mapping of base layers to their corresponding adapters.
+    Handles shared modules by their object identity and deduplicates them.
+
+    NOTE: There could be problems with mapping with this function, depending on model architectures and position of the layers.
+
+    Args:
+        model: PyTorch model with PEFT adapters
+
+    Returns:
+        dict: Mapping of base layer names to their adapter configurations
+    """
+    mapping = {}
+
+    # Track unique modules by their object id to handle shared modules
+    module_id_to_name = {}
+
+    def register_unique_module(module, full_name):
+        """Register a module and return the canonical name for shared modules"""
+        module_id = id(module)
+        if module_id in module_id_to_name:
+            # This module is shared, return the canonical name
+            return module_id_to_name[module_id]
+        else:
+            # First time seeing this module
+            module_id_to_name[module_id] = full_name
+            return full_name
+
+    # First pass: collect all modules and their paths
+    all_modules = {}
+    for name, module in model.named_modules():
+        all_modules[name] = module
+
+    # Find all base layers and their parent contexts
+    base_layer_contexts = {}
+    for name, module in all_modules.items():
+        if "base_layer" in name:
+            # Get parent path (everything before .base_layer)
+            parent_path = name.rsplit(".base_layer", 1)[0]
+            base_layer_contexts[name] = parent_path
+
+    current_shared_mlp_name = None
+    shared_mlp_counter = 0
+    current_inter_mlp_name = None
+    current_shared_qkv_name = None
+    shared_qkv_counter = 0
+    current_inter_qkv_name = None
+
+    # For each base layer, find its adapters
+    for base_layer_name, parent_path in base_layer_contexts.items():
+        adapters = {}
+
+        # Prefix renaming if needed
+        if base_layer_name.startswith("base_model.model.model."):
+            base_layer_name = base_layer_name.replace("base_model.model.model.", "backbone.model.")
+
+        # Look for adapters in the parent context
+        for module_name, module in all_modules.items():
+            # Skip if not in the same parent context
+            if not module_name.startswith(parent_path + "."):
+                continue
+
+            # Prefix renaming if needed
+            if module_name.startswith("base_model.model.model."):
+                module_name.replace("base_model.model.model.", "backbone.model.")
+
+            # Get the relative path from parent
+            relative_path = module_name[len(parent_path) + 1 :]
+
+            # Apply categorization rules based on path patterns
+            # Rule 1: shared_*.mars_down_* -> "shared_A"
+
+            if relative_path.startswith("shared_") and ".mars_down_" in relative_path:
+                canonical_name = register_unique_module(module, module_name)
+                adapters["shared_A"] = canonical_name
+
+                if relative_path.startswith("shared_mlp"):
+                    current_shared_mlp_name = module_name
+
+                elif relative_path.startswith("shared_qkv"):
+                    current_shared_qkv_name = module_name
+
+            # Rule 2: shared_*.mars -> "intermediate" (direct mars in shared)
+            elif relative_path.startswith("shared_") and relative_path.endswith(".mars"):
+                canonical_name = register_unique_module(module, module_name)
+                adapters["intermediate"] = canonical_name
+
+                if relative_path.startswith("shared_mlp"):
+                    current_inter_mlp_name = module_name
+                    shared_mlp_counter = 0
+                    adapters["adapter_index"] = 0
+                    shared_mlp_counter += 1
+                elif relative_path.startswith("shared_qkv"):
+                    current_inter_qkv_name = module_name
+                    shared_qkv_counter = 0
+                    adapters["adapter_index"] = 0
+                    shared_qkv_counter += 1
+
+            # Rule 3: up_project.mars -> "adapter_B"
+            elif relative_path == "up_project.mars":
+                canonical_name = register_unique_module(module, module_name)
+                adapters["adapter_B"] = canonical_name
+
+                if hasattr(module, "rank"):
+                    adapters["rank"] = int(module.rank)
+                else:
+                    print(f"[WARNING] Could not find rank in {module_name}")
+                if hasattr(module, "alpha"):
+                    adapters["alpha"] = float(module.alpha)
+
+            # Rule 4: down_project.mars -> "adapter_A"
+            elif relative_path == "down_project.mars":
+                canonical_name = register_unique_module(module, module_name)
+                adapters["adapter_A"] = canonical_name
+
+        # Check if we need to add pointer to shared or intermediate layer.
+        #
+        # `named_modules()` yields a shared object ONCE, under the first path that reaches it, so only
+        # one projection per attention block ever finds `shared_qkv` in its own subtree. The others
+        # need this back-pointer — without it the codec never learns that they share the tensor.
+        #
+        # Which projection this is used to be decided by `"q_proj" in base_layer_name`, a decoder-only
+        # literal that matched nothing on an encoder: BERT's `value` silently lost its `shared_A`,
+        # `intermediate` and `adapter_index` while `query` kept them, so the two projections of a
+        # layer disagreed about whether they shared anything. Now resolved by ROLE through the
+        # architecture registry, exactly as `peft/mars/model.py` does.
+        base_role = _projection_role(model, base_layer_name)
+        if "shared_A" not in adapters and "adapter_A" not in adapters:
+            if base_role in shared_qkv:
+                adapters["shared_A"] = current_shared_qkv_name
+                adapters["intermediate"] = current_inter_qkv_name
+                adapters["adapter_index"] = shared_qkv_counter
+                shared_qkv_counter += 1
+            elif shared_mlp_enabled and base_role in ("gate", "up"):
+                adapters["shared_A"] = current_shared_mlp_name
+                adapters["intermediate"] = current_inter_mlp_name
+                adapters["adapter_index"] = shared_mlp_counter
+                shared_mlp_counter += 1
+
+        if adapters:
+            mapping[base_layer_name] = adapters
+
+    # with open('base_mapping.json', 'w') as f:
+    #    json.dump(mapping, f)
+
+    return mapping
+
+
+def create_lora_mapping(peft_model) -> dict:
+    """
+    Creates a mapping from base layer names to their corresponding LoRA adapter layer names
+    within a PEFT LoRA model.
+
+    Args:
+        peft_model (PeftModel): An instance of a PEFT LoRA model with applied LoRA adapters.
+
+    Returns:
+        dict: A dictionary where:
+              - Keys are the full path names of the base layers with LoRA adapters.
+              - Values are dictionaries containing the full path names to their
+                corresponding 'lora_A' and 'lora_B' adapter modules.
+    """
+    from peft.tuners.lora import LoraLayer  # noqa: PLC0415
+
+    peft_mapping = {}
+
+    for module_path, module in peft_model.named_modules():
+        # Identify modules that are LoRA-enabled layers
+        if isinstance(module, LoraLayer):
+            base_layer_name = module_path
+
+            # Iterate through all adapter names for this LoRA layer (e.g., 'default')
+            for adapter_name in module.lora_A.keys():
+                lora_a_full_path = f"{base_layer_name}.lora_A.{adapter_name}"
+                lora_b_full_path = f"{base_layer_name}.lora_B.{adapter_name}"
+
+                # Prioritize 'default' adapter or use the first one found
+                if adapter_name == "default" or base_layer_name not in peft_mapping:
+                    peft_mapping[base_layer_name] = {
+                        "adapter_A": lora_a_full_path,
+                        "adapter_B": lora_b_full_path,
+                    }
+
+    return peft_mapping
diff --git a/src/mobiletransformers/peft/mars/__init__.py b/src/mobiletransformers/peft/mars/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/peft_models/mars/config.py b/src/mobiletransformers/peft/mars/config.py
similarity index 73%
rename from peft_models/mars/config.py
rename to src/mobiletransformers/peft/mars/config.py
index 613e580..6099679 100644
--- a/peft_models/mars/config.py
+++ b/src/mobiletransformers/peft/mars/config.py
@@ -1,13 +1,9 @@
 from __future__ import annotations
 
-import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from peft.config import PeftConfig
-from peft.utils import PeftType
 
-from dataclasses import dataclass, field
-from typing import Optional, Union, Tuple
 
 @dataclass
 class MarsConfig(PeftConfig):
@@ -28,19 +24,21 @@ class MarsConfig(PeftConfig):
     """
 
     r: int = field(default=8, metadata={"help": "Lora attention dimension"})
-    shared_r: Optional[int] = field(default=None, metadata={"help": "Shared rank attention dimension"})
-    optimization_level: int = field(default=0, metadata={
-        "help": (
-            "Optimization level to enable with other configurations:"
-            "0 - fully trainable all layers and no quantization"
-            "1 - partial trainable layers (frozen and fused down projection layers) with no quantization"
-            "2 - fully trainable layers with partial quantization (specified in `modules_to_quantize`)"
-            "3 - fully trainable layers with full quantization"
-            "4 - partial trainable layers (frozen and fused down projection layers) with full quantization"
+    shared_r: int | None = field(default=None, metadata={"help": "Shared rank attention dimension"})
+    optimization_level: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Optimization level to enable with other configurations:"
+                "0 - fully trainable all layers and no quantization"
+                "1 - partial trainable layers (frozen and fused down projection layers) with no quantization"
+                "2 - fully trainable layers with partial quantization (specified in `modules_to_quantize`)"
+                "3 - fully trainable layers with full quantization"
+                "4 - partial trainable layers (frozen and fused down projection layers) with full quantization"
             )
-        }
+        },
     )
-    target_modules: Optional[Union[list[str], str]] = field(
+    target_modules: list[str] | str | None = field(
         default=None,
         metadata={
             "help": (
@@ -52,16 +50,23 @@ class MarsConfig(PeftConfig):
             )
         },
     )
-    enabled_qkv: Optional[Tuple[str, ...]] = field(default=("q", "k", "v"), metadata={"help": "Which QKV projections to enable in the shared QKV adapter. Please select between 'q', 'k' and 'v'."})
+    enabled_qkv: tuple[str, ...] | None = field(
+        default=("q", "k", "v"),
+        metadata={
+            "help": "Which QKV projections to enable in the shared QKV adapter. Please select between 'q', 'k' and 'v'."
+        },
+    )
     enabled_mlp: bool = field(
         default=True,
-        metadata={"help": "Set this to True if we should have a shared down_proj and gate_proj down projection layers."},
+        metadata={
+            "help": "Set this to True if we should have a shared down_proj and gate_proj down projection layers."
+        },
     )
     mixture: bool = field(
         default=False,
         metadata={"help": "Set this to True if the adapter layer should include a mixture layer."},
     )
-    modules_to_quantize: Optional[list[str]] = field(
+    modules_to_quantize: list[str] | None = field(
         default=None,
         metadata={
             "help": (
@@ -70,7 +75,7 @@ class MarsConfig(PeftConfig):
             )
         },
     )
-    modules_to_preserve_errors: Optional[list[str]] = field(
+    modules_to_preserve_errors: list[str] | None = field(
         default=None,
         metadata={
             "help": (
@@ -84,7 +89,12 @@ class MarsConfig(PeftConfig):
         default=False,
         metadata={"help": "Whether to enable orthogonal initialization in intermediate matrices."},
     )
-    quant_n_bits: int = field(default=8, metadata={"help": "Quantization type (bits for quantized weights) for MARS. Can be either '8' or '4'."})
+    quant_n_bits: int = field(
+        default=8,
+        metadata={
+            "help": "Quantization type (bits for quantized weights) for MARS. Can be either '8' or '4'."
+        },
+    )
     use_bnb: bool = field(
         default=True,
         metadata={"help": "Whether to use BitsAndBytes to quantize base layers."},
@@ -95,12 +105,14 @@ class MarsConfig(PeftConfig):
     )
     alpha: int = field(default=8, metadata={"help": "Scaling factor, computed as alpha/rank."})
     seed: int = field(default=42, metadata={"help": "Seed for initializing layers."})
-    bias: str = field(default="none", metadata={"help": "Bias type for Mars. Can be 'none', 'all' or 'mars_only'"})
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for Mars. Can be 'none', 'all' or 'mars_only'"}
+    )
     fan_in_fan_out: bool = field(
         default=False,
         metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
     )
-    modules_to_save: Optional[list[str]] = field(
+    modules_to_save: list[str] | None = field(
         default=None,
         metadata={
             "help": (
@@ -110,7 +122,7 @@ class MarsConfig(PeftConfig):
             )
         },
     )
-    layers_to_transform: Optional[Union[list[int], int]] = field(
+    layers_to_transform: list[int] | int | None = field(
         default=None,
         metadata={
             "help": (
@@ -120,7 +132,7 @@ class MarsConfig(PeftConfig):
             )
         },
     )
-    layers_pattern: Optional[Union[list[str], str]] = field(
+    layers_pattern: list[str] | str | None = field(
         default=None,
         metadata={
             "help": (
@@ -132,16 +144,18 @@ class MarsConfig(PeftConfig):
     )
 
     def __post_init__(self):
-        #super().__post_init__()
+        # super().__post_init__()
         # PEFT type
         self.peft_type = "MARS"
-        
+
         # Convert target_modules to list instead of set to avoid potential issues
         if isinstance(self.target_modules, list):
             self.target_modules = list(set(self.target_modules))  # Remove duplicates but keep as list
         elif isinstance(self.target_modules, set):
             self.target_modules = list(self.target_modules)  # Convert set to list
-            
+
         # check for layers_to_transform and layers_pattern
         if self.layers_pattern and not self.layers_to_transform:
-            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
\ No newline at end of file
+            raise ValueError(
+                "When `layers_pattern` is specified, `layers_to_transform` must also be specified. "
+            )
diff --git a/peft_models/mars/layer.py b/src/mobiletransformers/peft/mars/layer.py
similarity index 81%
rename from peft_models/mars/layer.py
rename to src/mobiletransformers/peft/mars/layer.py
index 8072750..2899b3a 100644
--- a/peft_models/mars/layer.py
+++ b/src/mobiletransformers/peft/mars/layer.py
@@ -1,11 +1,12 @@
-from peft.tuners.tuners_utils import BaseTunerLayer
 import torch
 import torch.nn as nn
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from mobiletransformers.peft.mars.matrices import create_orthogonal_matrices
 
-from research.pytorch_experiments.matrix_experiments import create_orthogonal_matrices
 
 class QuantizedBaseLayer(nn.Module):
-    def __init__(self, original_linear, bits=8, use_bnb = True, symmetric = True, per_channel=True):
+    def __init__(self, original_linear, bits=8, use_bnb=True, symmetric=True, per_channel=True):
         super().__init__()
         self.in_features = original_linear.in_features
         self.out_features = original_linear.out_features
@@ -14,88 +15,89 @@ def __init__(self, original_linear, bits=8, use_bnb = True, symmetric = True, pe
         self.symmetric = symmetric
         self.device = original_linear.weight.device
         self.use_bnb = use_bnb
-        
+
         # Check for bitsandbytes availability
         self._check_bnb_availability()
-        
+
         # Store bias
         if original_linear.bias is not None:
-            self.register_buffer('bias', original_linear.bias.data)
+            self.register_buffer("bias", original_linear.bias.data)
         else:
             self.bias = None
-        
+
         # Quantize weights using the appropriate method
         self._quantize_weights(original_linear.weight.data)
-    
+
     def _check_bnb_availability(self):
         """Check if bitsandbytes is available and supports our configuration"""
         self.bnb_config = None
-        
+
         if not self.use_bnb:
             return
-        
+
         # Check BNB availability
         self.use_bnb = False
 
         try:
             import bitsandbytes as bnb
             from transformers import BitsAndBytesConfig
-            
+
             # Check if CUDA is available
             if not torch.cuda.is_available():
                 print("BitsAndBytes requires CUDA, but CUDA is not available. Using manual implementation.")
                 return
-            
+
             # Ensure we're on CUDA device for BitsAndBytes
-            if self.device.type != 'cuda':
+            if self.device.type != "cuda":
                 print(f"BitsAndBytes requires CUDA, moving from {self.device} to CUDA.")
-                self.device = torch.device('cuda:0')  # Move to first CUDA device
-            
+                self.device = torch.device("cuda:0")  # Move to first CUDA device
+
             # Check if configuration is supported by bitsandbytes
             if self.bits == 4:
                 self.bnb_config = BitsAndBytesConfig(
                     load_in_4bit=True,
                     bnb_4bit_compute_dtype=torch.float32,
                     bnb_4bit_use_double_quant=True,  # Use double quantization for better accuracy
-                    bnb_4bit_quant_type="fp4"
+                    bnb_4bit_quant_type="fp4",
                 )
                 self.use_bnb = True
-                #print("Using BitsAndBytes 4-bit quantization")
-                
+                # print("Using BitsAndBytes 4-bit quantization")
+
             elif self.bits == 8:
                 self.bnb_config = BitsAndBytesConfig(
-                    load_in_8bit=True,
-                    llm_int8_enable_fp32_cpu_offload=False
+                    load_in_8bit=True, llm_int8_enable_fp32_cpu_offload=False
                 )
                 self.use_bnb = True
                 print("Using BitsAndBytes 8-bit quantization")
             else:
-                print(f"BitsAndBytes doesn't support {self.bits}-bit quantization. Using manual implementation.")
-                
+                print(
+                    f"BitsAndBytes doesn't support {self.bits}-bit quantization. Using manual implementation."
+                )
+
         except ImportError:
             print("BitsAndBytes not found. Using manual quantization implementation.")
         except Exception as e:
             print(f"Error setting up BitsAndBytes: {e}. Using manual implementation.")
-    
+
     def _quantize_weights_bnb(self, weight):
         """Quantize weights using BitsAndBytes"""
         try:
             import bitsandbytes as bnb
 
             # Ensure weight is on CUDA device
-            if weight.device.type != 'cuda':
+            if weight.device.type != "cuda":
                 print(f"Moving weight from {weight.device} to {self.device}")
                 weight = weight.to(self.device)
-            
+
             if self.bits == 4:
                 # Use FP4 for asymmetric quantization
                 self._bnb_layer = bnb.nn.LinearFP4(
                     self.in_features,
                     self.out_features,
                     bias=self.bias is not None,
-                    compute_dtype=torch.float32
+                    compute_dtype=torch.float32,
                 )
-                
+
             elif self.bits == 8:
                 # Use 8-bit quantization
                 self._bnb_layer = bnb.nn.Linear8bitLt(
@@ -103,7 +105,7 @@ def _quantize_weights_bnb(self, weight):
                     self.out_features,
                     bias=self.bias is not None,
                     has_fp16_weights=False,
-                    threshold=6.0
+                    threshold=6.0,
                 )
 
             # Load the original weights into the BnB layer
@@ -117,12 +119,12 @@ def _quantize_weights_bnb(self, weight):
 
             # Store quantization metadata
             self.bnb_quantization_info = {
-                'bits': self.bits,
-                'quant_type': ("fp4" if self.bits == 4 else "int8"),
-                'original_shape': weight.shape,
-                'original_dtype': weight.dtype
+                "bits": self.bits,
+                "quant_type": ("fp4" if self.bits == 4 else "int8"),
+                "original_shape": weight.shape,
+                "original_dtype": weight.dtype,
             }
-            
+
         except Exception as e:
             print(f"BitsAndBytes quantization failed: {e}. Falling back to manual implementation.")
             self.use_bnb = False
@@ -130,7 +132,7 @@ def _quantize_weights_bnb(self, weight):
             if weight.device != self.device:
                 weight = weight.to(self.device)
             self._quantize_weights_manual(weight)
-    
+
     def _quantize_weights_manual(self, weight):
         """Manual quantization implementation (your original code)"""
         if self.bits == 8:
@@ -147,12 +149,12 @@ def _quantize_weights_manual(self, weight):
             dtype = torch.int8  # Store in int8, but only use 4 bits
         else:
             raise ValueError("Only 4 and 8 bits supported")
-        
+
         if self.per_channel:
             # Per-channel quantization (per output channel)
             axis = 0  # Quantize along output dimension
             weight_reshaped = weight.view(weight.shape[0], -1)
-            
+
             if self.symmetric:
                 # Symmetric quantization: zero_point = 0
                 max_vals = weight_reshaped.abs().max(dim=1, keepdim=True)[0]
@@ -163,13 +165,13 @@ def _quantize_weights_manual(self, weight):
                 # Asymmetric quantization: calculate optimal zero_point
                 min_vals = weight_reshaped.min(dim=1, keepdim=True)[0]
                 max_vals = weight_reshaped.max(dim=1, keepdim=True)[0]
-                
+
                 scales = (max_vals - min_vals) / (qmax - qmin)
                 scales = torch.clamp(scales, min=1e-8)
-                
+
                 zero_points = qmin - torch.round(min_vals / scales)
                 zero_points = torch.clamp(zero_points, qmin, qmax)
-            
+
             # Broadcast scales and zero_points back to weight shape
             scales = scales.view(-1, 1).expand_as(weight)
             zero_points = zero_points.view(-1, 1).expand_as(weight)
@@ -183,66 +185,62 @@ def _quantize_weights_manual(self, weight):
             else:
                 min_val = weight.min()
                 max_val = weight.max()
-                
+
                 scales = (max_val - min_val) / (qmax - qmin)
                 scales = torch.clamp(scales, min=1e-8)
-                
+
                 zero_points = qmin - torch.round(min_val / scales)
                 zero_points = torch.clamp(zero_points, qmin, qmax)
-        
+
         # Quantize: q = round(x/scale + zero_point)
         quantized = torch.round(weight / scales + zero_points)
         quantized = torch.clamp(quantized, qmin, qmax)
-        
+
         # Store quantized weights and parameters
-        self.register_buffer('quantized_weight', quantized.to(dtype))
-        
+        self.register_buffer("quantized_weight", quantized.to(dtype))
+
         if self.per_channel:
             # Store per-channel scales and zero_points
-            self.register_buffer('scales', scales[:, 0])  # Take first column since all are same
-            self.register_buffer('zero_points', zero_points[:, 0].to(torch.int32))
+            self.register_buffer("scales", scales[:, 0])  # Take first column since all are same
+            self.register_buffer("zero_points", zero_points[:, 0].to(torch.int32))
         else:
             # Store per-tensor scales and zero_points
-            self.register_buffer('scales', scales)
-            self.register_buffer('zero_points', zero_points.to(torch.int32))
-    
+            self.register_buffer("scales", scales)
+            self.register_buffer("zero_points", zero_points.to(torch.int32))
+
     def _quantize_weights(self, weight):
         """Main quantization method that chooses between BnB and manual"""
         if self.use_bnb:
             self._quantize_weights_bnb(weight)
         else:
             self._quantize_weights_manual(weight)
-    
+
     def dequantize_weights(self):
         """Dequantize weights using the appropriate method"""
         if self.use_bnb:
             return self._dequantize_weights_bnb()
         else:
             return self._dequantize_weights_manual()
-    
+
     def _dequantize_weights_bnb(self):
         """Dequantize weights using BitsAndBytes"""
         try:
-            if hasattr(self, '_bnb_layer'):
+            if hasattr(self, "_bnb_layer"):
                 # For BnB layers, we can access the weight directly
                 # Clone to avoid view issues during autograd
                 weight_data = self._bnb_layer.weight.data
-                if hasattr(weight_data, 'clone'):
+                if hasattr(weight_data, "clone"):
                     return weight_data.detach().clone().float()
                 else:
                     return weight_data.float()
             else:
                 raise AttributeError("BnB layer not found")
-                
+
         except Exception as e:
             print(f"BitsAndBytes dequantization failed: {e}. Using fallback.")
             # Fallback - return a zero tensor with correct shape
-            return torch.zeros(
-                (self.out_features, self.in_features), 
-                device=self.device, 
-                dtype=torch.float32
-            )
-    
+            return torch.zeros((self.out_features, self.in_features), device=self.device, dtype=torch.float32)
+
     def _dequantize_weights_manual(self):
         """Manual dequantization implementation (your original code)"""
         if self.per_channel:
@@ -252,43 +250,44 @@ def _dequantize_weights_manual(self):
         else:
             scales = self.scales
             zero_points = self.zero_points
-        
+
         # Dequantize: x = scale * (q - zero_point)
         dequantized = scales * (self.quantized_weight.float() - zero_points.float())
         return dequantized
-    
+
     def forward(self, x):
         """Forward pass using the appropriate method"""
         if self.use_bnb:
             return self._forward_bnb(x)
         else:
             return self._forward_manual(x)
-    
+
     def _forward_bnb(self, x):
         """Forward pass using BitsAndBytes - just calls the existing layer"""
         try:
-            if hasattr(self, '_bnb_layer'):
+            if hasattr(self, "_bnb_layer"):
                 output = self._bnb_layer(x)
                 # For 8-bit layers, clone the output to avoid view+inplace issues
-                if self.bits == 8 and hasattr(output, 'data'):
+                if self.bits == 8 and hasattr(output, "data"):
                     # Clone to break the view relationship and avoid autograd issues
                     output = output.clone()
-                
+
                 return output
             else:
                 raise AttributeError("BnB layer not found")
-            
+
         except Exception as e:
             print(f"BitsAndBytes forward failed: {e}. Falling back to manual dequantization.")
             # Fallback to manual method
             dequantized_weight = self.dequantize_weights()
             return torch.nn.functional.linear(x, dequantized_weight, self.bias)
-    
+
     def _forward_manual(self, x):
         """Forward pass using manual dequantization"""
         dequantized_weight = self.dequantize_weights()
         return torch.nn.functional.linear(x, dequantized_weight, self.bias)
 
+
 class MarsLayer(BaseTunerLayer):
     adapter_layer_names = ("up_project",)
 
@@ -303,18 +302,14 @@ def __init__(self, base_layer: nn.Module, **kwargs) -> None:
         self.onnx_export = kwargs.get("onnx_export", False)
         n_bits = kwargs.get("quant_n_bits", 8)
         use_bnb = kwargs.get("use_bnb", False)
-        
+
         # Apply dynamic quantization to base layer if requested
         # Do not apply quantization if exporting for ONNX
         if self.quantize_base and not self.onnx_export and isinstance(base_layer, nn.Linear):
-            self.base_layer = QuantizedBaseLayer(
-                base_layer,
-                n_bits,
-                use_bnb
-            )
+            self.base_layer = QuantizedBaseLayer(base_layer, n_bits, use_bnb)
         else:
             self.base_layer = base_layer
-        
+
         self.manual_seed = True
 
     def update_layer(self, original_weights, adapter_name, rank, alpha, projection_type, **kwargs):
@@ -330,32 +325,37 @@ def update_layer(self, original_weights, adapter_name, rank, alpha, projection_t
 
         # If base layer quantized and preserve errors (either standalone or shared)
         if self.quantize_base and self.preserve_errors:
-            self._compute_error_residuals_and_svd(original_weights.weight.data.clone(), adapter_name, rank, self.shared_rank)
+            self._compute_error_residuals_and_svd(
+                original_weights.weight.data.clone(), adapter_name, rank, self.shared_rank
+            )
 
         # If base layer is not quantized and standalone adapter
         elif self.is_standalone and not self.preserve_errors:
-                
-                self.adapter_layer_names = ("up_project","down_project")
-
-                # Down-projection
-                self.down_project[adapter_name] = nn.Linear(self.in_features, rank, bias=False)
-                torch.nn.init.normal_(self.down_project[adapter_name].weight, mean=0, std=1 / rank)
-
-                # If frozen down add scale to matrix
-                if not self.trainable_down:
-                    self.down_project[adapter_name].weight.data *= (alpha / rank)
-                self.down_project[adapter_name].requires_grad_(self.trainable_down)
-
-                # Up-projection
-                self.up_project[adapter_name] = nn.Linear(self.rank, self.out_features, bias=False)
-                self.up_project[adapter_name].weight.data = torch.nn.init.zeros_(self.up_project[adapter_name].weight.data)
-                self.up_project[adapter_name].weight.requires_grad = True
-        
+            self.adapter_layer_names = ("up_project", "down_project")
+
+            # Down-projection
+            self.down_project[adapter_name] = nn.Linear(self.in_features, rank, bias=False)
+            torch.nn.init.normal_(self.down_project[adapter_name].weight, mean=0, std=1 / rank)
+
+            # If frozen down add scale to matrix
+            if not self.trainable_down:
+                self.down_project[adapter_name].weight.data *= alpha / rank
+            self.down_project[adapter_name].requires_grad_(self.trainable_down)
+
+            # Up-projection
+            self.up_project[adapter_name] = nn.Linear(self.rank, self.out_features, bias=False)
+            self.up_project[adapter_name].weight.data = torch.nn.init.zeros_(
+                self.up_project[adapter_name].weight.data
+            )
+            self.up_project[adapter_name].weight.requires_grad = True
+
         # If base layer is not quantized and not standalone
         else:
             # Up-projection
             self.up_project[adapter_name] = nn.Linear(self.rank, self.out_features, bias=False)
-            self.up_project[adapter_name].weight.data = torch.nn.init.zeros_(self.up_project[adapter_name].weight.data)
+            self.up_project[adapter_name].weight.data = torch.nn.init.zeros_(
+                self.up_project[adapter_name].weight.data
+            )
             self.up_project[adapter_name].weight.requires_grad = True
 
         # If we have to get it ready for ONNX export by replacing the quantized weights with original weights
@@ -366,30 +366,29 @@ def update_layer(self, original_weights, adapter_name, rank, alpha, projection_t
         # Attach alpha and rank to up projections
         self.up_project[adapter_name].rank = self.rank
         self.up_project[adapter_name].alpha = self.alpha
-    
+
         self.adapter_name = adapter_name
         self._move_adapter_to_device_of_base_layer(adapter_name)
         self.set_adapter(adapter_name)
-    
+
     def _compute_error_residuals_and_svd(self, original_weight, adapter_name, rank, shared_rank):
         """
         Compute error residuals between quantized and original weights,
         then perform SVD to initialize adapter weights with error correction.
         """
-        
+
         # Get dequantized weights from quantized layer
         quantized_weight = self._extract_dequantized_weights()
-        
+
         # Compute error residuals: E = Q(W) - W
         error_residuals = quantized_weight - original_weight
-        
+
         # Perform SVD on error residuals
         U, S, Vt = torch.linalg.svd(error_residuals.T, full_matrices=False)
 
         max_rank = min(rank, S.shape[0], Vt.shape[0])
 
         if self.is_standalone:
-
             U_truncated = U[:, :max_rank]
             S = torch.diag(S)
             S_truncated = S[:max_rank, :max_rank]
@@ -412,18 +411,18 @@ def _compute_error_residuals_and_svd(self, original_weight, adapter_name, rank,
             self.up_project[adapter_name].weight.requires_grad = True
 
             return
-        
+
         # Truncate to specified shared rank
         max_shared_rank = min(shared_rank, U.shape[1], S.shape[0])
-        
+
         U_truncated = U[:, :max_shared_rank]
         S = torch.diag(S)
         S_truncated = S[:max_shared_rank, :max_rank]
         Vt_truncated = Vt[:max_rank, :]
-        
+
         # Store U and Sigma separately for potential future use
-        #self._store_svd_components(U_truncated, S_truncated)
-        
+        # self._store_svd_components(U_truncated, S_truncated)
+
         # Replace up projection with Vt
         self.up_project[adapter_name] = nn.Linear(rank, self.out_features, bias=False)
         with torch.no_grad():
@@ -432,62 +431,62 @@ def _compute_error_residuals_and_svd(self, original_weight, adapter_name, rank,
 
     def _extract_dequantized_weights(self):
         """Extract dequantized weights from quantized base layer"""
-        
+
         # Check if it's our custom QuantizedBaseLayer
         if isinstance(self.base_layer, QuantizedBaseLayer):
             # Use the built-in dequantization method
             return self.base_layer.dequantize_weights()
-        
+
         # For PyTorch's dynamically quantized layers
-        elif hasattr(self.base_layer, '_packed_params'):
+        elif hasattr(self.base_layer, "_packed_params"):
             # For quantized linear layers
             packed_params = self.base_layer._packed_params
-            if hasattr(packed_params, 'unpack'):
+            if hasattr(packed_params, "unpack"):
                 weight, bias = packed_params.unpack()
                 return weight.dequantize()
-        
+
         # Direct dequantization if available
-        elif hasattr(self.base_layer, 'weight') and hasattr(self.base_layer.weight, 'dequantize'):
+        elif hasattr(self.base_layer, "weight") and hasattr(self.base_layer.weight, "dequantize"):
             return self.base_layer.weight.dequantize()
-        
+
         # Fallback for regular non-quantized layers
-        elif hasattr(self.base_layer, 'weight'):
+        elif hasattr(self.base_layer, "weight"):
             return self.base_layer.weight.data
-        
+
         else:
             raise ValueError("Cannot extract dequantized weights from base layer")
-    
+
     def _store_svd_components(self, U, S):
         """Store U and Sigma components separately"""
-        if not hasattr(self, 'svd_U'):
+        if not hasattr(self, "svd_U"):
             self.svd_U = None
-        if not hasattr(self, 'svd_S'):
+        if not hasattr(self, "svd_S"):
             self.svd_S = None
-        
+
         self.svd_U = U.clone()
         self.svd_S = S.clone()
 
     def clear_svd_components(self):
         """Clear stored U and Sigma matrices to free memory"""
-        
+
         # Clear all SVD components
-        if hasattr(self, 'svd_U'):
+        if hasattr(self, "svd_U"):
             del self.svd_U
             self.svd_U = None
-        if hasattr(self, 'svd_S'):
+        if hasattr(self, "svd_S"):
             del self.svd_S
             self.svd_S = None
-        
-class SharedMLPAdapter(nn.Module):
 
+
+class SharedMLPAdapter(nn.Module):
     def __init__(self, hidden_size, rank, shared_rank, alpha, **kwargs):
         super().__init__()
 
         self.rank = rank
         self.shared_rank = shared_rank
         self.alpha = alpha / self.rank
-        self.orth_init = kwargs.get('orth_init', False)
-        self.no_mixture = kwargs.get('no_mixture', False)
+        self.orth_init = kwargs.get("orth_init", False)
+        self.no_mixture = kwargs.get("no_mixture", False)
         self.trainable_down = kwargs.get("trainable_down", True)
 
         # Shared frozen down-projection
@@ -497,7 +496,7 @@ def __init__(self, hidden_size, rank, shared_rank, alpha, **kwargs):
         if not self.trainable_down:
             self.mars_down_mlp.weight.data *= alpha / rank
         self.mars_down_mlp.requires_grad_(self.trainable_down)
-        
+
         # Shared trainable transform as nn.Linear (with 'mars' key)
         if not self.no_mixture:
             self.mars = nn.Linear(shared_rank, 2 * rank, bias=False)
@@ -518,17 +517,18 @@ def _update_layer(self, u_proj=None, sigma=None, res_projection_type=None):
 
         # Update intermediate matrices
         if self.orth_init:
-            orthogonal_matrices = create_orthogonal_matrices(self.rank, num_matrices=2, mean=0, std= 1 / self.rank, initial_matrix=sigma, device='cuda')
+            orthogonal_matrices = create_orthogonal_matrices(
+                self.rank, num_matrices=2, mean=0, std=1 / self.rank, initial_matrix=sigma, device="cuda"
+            )
 
             with torch.no_grad():
                 self.mars.weight.copy_(orthogonal_matrices.T)
         elif sigma is not None and res_projection_type is not None:
-
             with torch.no_grad():
-                if res_projection_type == 'gate':
-                    self.mars.weight[:self.rank, :].copy_(sigma.T)
-                elif res_projection_type == 'up':
-                    self.mars.weight[self.rank:, :].copy_(sigma.T)
+                if res_projection_type == "gate":
+                    self.mars.weight[: self.rank, :].copy_(sigma.T)
+                elif res_projection_type == "up":
+                    self.mars.weight[self.rank :, :].copy_(sigma.T)
         else:
             torch.nn.init.normal_(self.mars.weight, mean=0, std=1 / self.rank)
 
@@ -544,25 +544,25 @@ def forward(self, x):
 
         return gate_out, up_out
 
-class SharedAttentionAdapter(nn.Module):
 
-    def __init__(self, hidden_size, rank, shared_rank, alpha, enabled: list[str] = ['q', 'k', 'v'], **kwargs):
+class SharedAttentionAdapter(nn.Module):
+    def __init__(self, hidden_size, rank, shared_rank, alpha, enabled: list[str] = ["q", "k", "v"], **kwargs):
         super().__init__()
 
         self.rank = rank
         self.shared_rank = shared_rank
         self.alpha = alpha / self.rank
         self.enabled = enabled
-        self.enabled_idx = [i for i, name in enumerate(['q', 'k', 'v']) if name in enabled]
+        self.enabled_idx = [i for i, name in enumerate(["q", "k", "v"]) if name in enabled]
         self.num_enabled = len(self.enabled)
 
-        self.orth_init = kwargs.get('orth_init', False)
-        self.no_mixture = kwargs.get('no_mixture', False)
+        self.orth_init = kwargs.get("orth_init", False)
+        self.no_mixture = kwargs.get("no_mixture", False)
         self.trainable_down = kwargs.get("trainable_down", True)
 
         # Shared frozen down-projection
         self.mars_down_qkv = nn.Linear(hidden_size, shared_rank, bias=False)
-        
+
         if not self.trainable_down:
             self.mars_down_qkv.weight.data *= alpha / rank
         self.mars_down_qkv.requires_grad_(self.trainable_down)
@@ -586,8 +586,14 @@ def _update_layer(self, u_proj=None, sigma=None, res_projection_type=None):
             return
 
         if self.orth_init:
-
-            orthogonal_matrices = create_orthogonal_matrices(self.rank, num_matrices=self.num_enabled, mean=0, std= 1 / self.rank, initial_matrix=sigma, device='cuda')
+            orthogonal_matrices = create_orthogonal_matrices(
+                self.rank,
+                num_matrices=self.num_enabled,
+                mean=0,
+                std=1 / self.rank,
+                initial_matrix=sigma,
+                device="cuda",
+            )
 
             with torch.no_grad():
                 self.mars.weight.copy_(orthogonal_matrices.T)
@@ -596,7 +602,7 @@ def _update_layer(self, u_proj=None, sigma=None, res_projection_type=None):
                 idx = self.enabled.index(res_projection_type)
             except ValueError:
                 raise ValueError(f"{res_projection_type} is not enabled in {self.enabled}")
-            
+
             start = idx * self.rank
             end = (idx + 1) * self.rank
 
@@ -604,7 +610,7 @@ def _update_layer(self, u_proj=None, sigma=None, res_projection_type=None):
                 self.mars.weight[start:end, :].copy_(sigma.T)
         else:
             torch.nn.init.normal_(self.mars.weight, mean=0, std=1 / self.rank)
-        
+
     def forward(self, x):
         # Shared projection + transform
         shared_out = self.mars_down_qkv(x)
@@ -615,6 +621,7 @@ def forward(self, x):
 
         return dict(zip(self.enabled, parts))
 
+
 class Linear(nn.Module, MarsLayer):
     def __init__(self, base_layer, adapter_name, r, alpha, projection_type, **kwargs):
         super().__init__()
@@ -623,13 +630,13 @@ def __init__(self, base_layer, adapter_name, r, alpha, projection_type, **kwargs
         self.ada_name = kwargs.get("target_name", None)
         self.fan_in_fan_out = kwargs.get("fan_in_fan_out", False)
         self._active_adapter = adapter_name
-        
+
         self.update_layer(base_layer, adapter_name, r, alpha, projection_type, **kwargs)
-        
+
     def forward(self, *args, **kwargs) -> torch.Tensor:
 
         if not self.is_standalone and len(args) > 0:
-        # First arg is shared_output, second is original input
+            # First arg is shared_output, second is original input
             shared_out = args[0]
             x = args[1] if len(args) > 1 else None
             remaining_args = args[2:] if len(args) > 2 else ()
@@ -649,7 +656,7 @@ def forward(self, *args, **kwargs) -> torch.Tensor:
         # Get base model output
         base_args = (x,) + remaining_args if x is not None else remaining_args
         result = self.base_layer(*base_args)
-        
+
         # Apply up-projection if needed
         for active_adapter in self.active_adapters:
             if active_adapter not in self.up_project:
@@ -659,10 +666,10 @@ def forward(self, *args, **kwargs) -> torch.Tensor:
                 adapter_result = self.up_project[active_adapter](self.down_project[active_adapter](x))
             elif shared_out is not None:
                 adapter_result = self.up_project[active_adapter](shared_out)
-            
+
             if self.trainable_down:
                 result += adapter_result * self.alpha
             else:
                 result += adapter_result
-                
-        return result
\ No newline at end of file
+
+        return result
diff --git a/src/mobiletransformers/peft/mars/matrices.py b/src/mobiletransformers/peft/mars/matrices.py
new file mode 100644
index 0000000..25a8132
--- /dev/null
+++ b/src/mobiletransformers/peft/mars/matrices.py
@@ -0,0 +1,102 @@
+"""Orthogonal-matrix construction for MARS shared adapters.
+
+VENDORED from ``research/pytorch_experiments/matrix_experiments.py`` (Migration Map S3).
+
+``research/`` is deliberately kept OUT of the package — it is exploratory code with heavy, unpinned
+dependencies (sklearn, scipy, a CCA module). ``mars/layer.py`` needed exactly one self-contained
+function from it, so that function is vendored here rather than dragging the research tree into the
+wheel. Keep the two in sync only deliberately; this copy is the one that ships.
+"""
+
+from __future__ import annotations
+
+import torch
+
+
+def create_orthogonal_matrices(
+    m, num_matrices, mean=0.0, std=1.0, initial_matrix=None, device="cpu", generator=None
+):
+    """
+    Create mutually orthogonal matrices using null space construction.
+
+    This approach is based on the fact that if B is in the null space of A^T,
+    then A^T @ B = 0, which means the matrices are orthogonal.
+
+    Args:
+        m (int): Dimension of each square matrix (m x m)
+        num_matrices (int): Number of matrices to generate
+        mean (float): Mean for random initialization
+        std (float): Standard deviation for random initialization
+        initial_matrix (torch.Tensor, optional): Initial matrix of size (m, m)
+        device (str): Device to create tensors on
+        generator (torch.Generator, optional): Random number generator
+
+    Returns:
+        torch.Tensor: Stacked matrices of size (m, m * num_matrices)
+    """
+
+    if initial_matrix is not None:
+        if initial_matrix.shape != (m, m):
+            raise ValueError(f"Initial matrix must be of size ({m}, {m})")
+        A = initial_matrix.to(device)
+        remaining = num_matrices - 1
+    else:
+        # Generate first matrix with controlled rank
+        # We need null_dim >= remaining matrices
+        # So rank should be <= m - (num_matrices - 1)
+        remaining = num_matrices - 1
+        max_rank = m - remaining
+
+        if max_rank <= 0:
+            raise ValueError(f"Cannot fit {num_matrices} matrices of size ({m}, {m}). Maximum possible: {m}")
+
+        # Create a rank-deficient matrix by construction: A = U @ V^T
+        # where U is (m, max_rank) and V is (m, max_rank)
+        U = torch.nn.init.normal_(
+            torch.empty((m, max_rank), device=device), mean=mean, std=std, generator=generator
+        )
+        V = torch.nn.init.normal_(
+            torch.empty((m, max_rank), device=device), mean=mean, std=std, generator=generator
+        )
+        A = U @ V.T  # This has rank <= max_rank
+
+    if remaining == 0:
+        return A
+
+    # Compute QR decomposition to get null space basis
+    Q, _ = torch.linalg.qr(A, mode="complete")
+
+    # The rank determines how much null space we have
+    rank_A = torch.linalg.matrix_rank(A).item()
+    null_dim = m - rank_A
+
+    if null_dim == 0:
+        raise ValueError(
+            f"Matrix A is full rank (rank={rank_A}). No null space available for orthogonal matrices."
+        )
+
+    # Check if we have enough null space dimensions
+    if remaining > null_dim:
+        raise ValueError(
+            f"Cannot generate {remaining} additional matrices. Null space dimension is only {null_dim}."
+        )
+
+    # Extract null space basis (last null_dim columns of Q)
+    null_basis = Q[:, rank_A:]  # Shape: (m, null_dim)
+
+    # Generate remaining matrices in the null space
+    matrices = [A]
+
+    for i in range(remaining):
+        # Generate random coefficients for the null space basis
+        coeffs = torch.nn.init.normal_(
+            torch.empty((null_dim, m), device=device), mean=mean, std=std, generator=generator
+        )
+
+        # Create matrix in null space: null_basis @ coeffs
+        B = null_basis @ coeffs  # Shape: (m, m)
+        matrices.append(B)
+
+    # Stack all matrices horizontally
+    result = torch.cat(matrices, dim=1)
+    return result
diff --git a/src/mobiletransformers/peft/mars/model.py b/src/mobiletransformers/peft/mars/model.py
new file mode 100644
index 0000000..750a24b
--- /dev/null
+++ b/src/mobiletransformers/peft/mars/model.py
@@ -0,0 +1,567 @@
+import os
+import warnings
+
+import torch
+from peft.config import PeftConfig
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from safetensors.torch import save_file
+from torch.nn.modules import Module
+
+from mobiletransformers.config.registry.architecture import ArchitectureSpec, resolve_architecture
+from mobiletransformers.exceptions import UnsupportedModelError
+from mobiletransformers.utils.logging import get_logger
+
+from .layer import Linear, MarsLayer, SharedAttentionAdapter, SharedMLPAdapter
+from .utils import TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING
+
+logger = get_logger(__name__)
+
+#: Roles whose projections share one :class:`SharedAttentionAdapter`, and one
+#: :class:`SharedMLPAdapter`, respectively. Roles — not module names: the names are per-architecture
+#: data on :class:`~mobiletransformers.config.registry.architecture.ArchitectureSpec`.
+_QKV_ROLES = ("q", "k", "v")
+_MLP_ROLES = ("gate", "up")
+
+
+def _hidden_states_from(module: Module, args: tuple, kwargs: dict) -> torch.Tensor:
+    """Extract the hidden-states input of an attention/MLP block's forward.
+
+    A decoder's ``LlamaAttention.forward`` is called with ``hidden_states=`` as a keyword, which is
+    what this code used to assume unconditionally (``kwargs["hidden_states"]``). ``BertAttention``
+    and ``BertSelfAttention`` take it **positionally**, so the old form raised ``KeyError`` on every
+    encoder forward. Accept either, and fail closed naming the module rather than letting a wrong
+    tensor through.
+    """
+    hidden_states = kwargs.get("hidden_states")
+    if hidden_states is None and args:
+        hidden_states = args[0]
+    if not isinstance(hidden_states, torch.Tensor):
+        raise UnsupportedModelError(
+            f"{type(module).__name__}: MARS could not locate the hidden-states input of this module's "
+            "forward (neither a `hidden_states` keyword nor a tensor first positional argument). "
+            "The shared adapter cannot be applied without it."
+        )
+    return hidden_states
+
+
+def _owns_any_child(module: Module, names: set[str]) -> bool:
+    """True when ``module`` has a direct child submodule with one of ``names``."""
+    return any(child in names for child, _ in module.named_children())
+
+
+def _is_within(module_path: str, block_name: str) -> bool:
+    """True when ``block_name`` is one of ``module_path``'s dotted components (or the leaf itself).
+
+    ``model.layers.0.self_attn`` is within ``self_attn``; ``bert.encoder.layer.0.attention.self`` is
+    within ``attention``. Component-wise, not substring: ``attention_probs`` must not match
+    ``attention``.
+    """
+    return block_name in module_path.split(".")
+
+
+def _compute_shared_qkv(module: Module, args: tuple, kwargs: dict) -> None:
+    """Compute the block's shared QKV outputs once, for its projections to consume."""
+    module.shared_qkv._shared_outputs = module.shared_qkv(_hidden_states_from(module, args, kwargs))
+    return None
+
+
+def _pass_qkv_inputs(module: Module, args: tuple) -> tuple:
+    if module is None or not hasattr(module, "shared_qkv"):
+        return args
+
+    shared_outputs = getattr(module.shared_qkv, "_shared_outputs", None)
+    if shared_outputs is None:
+        return args
+
+    # Get the specific output for this projection type
+    if module.projection_type not in shared_outputs:
+        return args
+
+    shared_output = shared_outputs[module.projection_type]
+
+    # Delete the specific key to free memory
+    del module.shared_qkv._shared_outputs[module.projection_type]
+
+    # Optional: Clean up the entire dict when empty
+    if not module.shared_qkv._shared_outputs:
+        del module.shared_qkv._shared_outputs
+
+    # Return original input paired with shared output
+    return (shared_output,) + args
+
+
+def _compute_shared_mlp(module: Module, args: tuple, kwargs: dict) -> None:
+    gate_out, up_out = module.shared_mlp(_hidden_states_from(module, args, kwargs))
+    module.shared_mlp._shared_outputs = {"gate": gate_out, "up": up_out}
+    return None
+
+
+def _pass_mlp_inputs(module: Module, args: tuple) -> tuple:
+    projection_type = getattr(module, "projection_type", None)
+    if projection_type not in ("gate", "up"):
+        return args
+    shared_outputs = getattr(module.shared_mlp, "_shared_outputs", None)
+    if shared_outputs is None or projection_type not in shared_outputs:
+        return args
+    shared_output = shared_outputs.pop(projection_type)
+    return (shared_output,) + args
+
+
+class MarsModel(BaseTuner):
+    """
+    PEFT model implementing the MARS (Multi-Adapter Rank Sharing) adapter technique on base models.
+    """
+
+    prefix: str = "mars"
+
+    def __init__(
+        self,
+        model,
+        peft_config: PeftConfig | dict[str, PeftConfig],
+        adapter_name: str = "mars",
+        low_cpu_mem_usage: bool = False,
+    ) -> None:
+
+        # Pre-initialization
+        if peft_config[adapter_name].shared_r is None:
+            peft_config[adapter_name].shared_r = peft_config[adapter_name].r
+
+        self.trainable_down = True
+        self.optimization_level = peft_config[adapter_name].optimization_level
+        self.only_export = peft_config[adapter_name].onnx_export
+        self.quant_n_bits = peft_config[adapter_name].quant_n_bits
+        self.use_bnb = peft_config[adapter_name].use_bnb
+
+        # Based on optimization level set configurations
+        if peft_config[adapter_name].optimization_level == 0:
+            self.trainable_down = True
+        elif peft_config[adapter_name].optimization_level == 1:
+            self.trainable_down = False
+        elif peft_config[adapter_name].optimization_level == 2:
+            self.trainable_down = True
+        elif peft_config[adapter_name].optimization_level == 3:
+            self.trainable_down = True
+        elif peft_config[adapter_name].optimization_level == 4:
+            self.trainable_down = False
+
+        # Which module names carry which projection role is per-architecture DATA, resolved from the
+        # class that was actually loaded (the head is part of the architecture identity — the same
+        # reason `export/training_export.py` passes `architecture=type(model).__name__`). Resolved
+        # BEFORE `super().__init__`, because BaseTuner's constructor runs the injection that consumes
+        # it. Fails closed on an unknown architecture rather than silently applying decoder naming to
+        # a model that does not use it — which is precisely the failure this replaces.
+        self._arch_spec: ArchitectureSpec = resolve_architecture(
+            model.config, architecture=type(model).__name__
+        )
+
+        super().__init__(model, peft_config, adapter_name, low_cpu_mem_usage)
+
+    def _pre_injection_hook(self, model: Module, config: PeftConfig, adapter_name: str) -> None:
+
+        enabled_qkv = getattr(config, "enabled_qkv", ("q", "k", "v"))
+
+        # Map enabled projections to indices in tuple
+        enabled_list = list(enabled_qkv)
+
+        spec = self._arch_spec
+        qkv_names = {n for n in (spec.module_name_for_role(r) for r in _QKV_ROLES) if n}
+        mlp_names = {n for n in (spec.module_name_for_role(r) for r in _MLP_ROLES) if n}
+
+        # Whether the user's target set actually reaches shared-adapter projections, decided by ROLE
+        # rather than by the decoder-only literals `q_proj`/`gate_proj` this used to test for.
+        any_qkv = any(spec.role_for_module(tm) in _QKV_ROLES for tm in config.target_modules)
+        any_mlp = any(spec.role_for_module(tm) in _MLP_ROLES for tm in config.target_modules)
+
+        # The anchor for a shared adapter is the module that DIRECTLY OWNS the projections, because
+        # that is both where the hidden states arrive and the `parent` that `_replace_module` reads
+        # `shared_qkv`/`shared_mlp` off. For a decoder that is `self_attn` itself; for BERT the
+        # projections live one level deeper, in `attention.self`, so anchoring on the module named
+        # `attention_module_name` would have attached the adapter to the wrong parent and silently
+        # never wired it up. `attention_module_name` still scopes the search, so an unrelated module
+        # that happens to own a `query`/`value` child is not mistaken for attention.
+        qkv_anchors = [
+            (name, module)
+            for name, module in model.named_modules()
+            if any_qkv and _owns_any_child(module, qkv_names) and _is_within(name, spec.attention_module_name)
+        ]
+        mlp_anchors = [
+            (name, module)
+            for name, module in model.named_modules()
+            if any_mlp and _owns_any_child(module, mlp_names)
+        ]
+        if any_qkv and not qkv_anchors:
+            raise UnsupportedModelError(
+                f"MARS found no attention module owning any of {sorted(qkv_names)} under a "
+                f"{spec.attention_module_name!r} block in {spec.architecture}. The shared QKV adapter "
+                "would be a silent no-op; fix `projection_names`/`attention_module_name` for this "
+                "architecture in the registry instead."
+            )
+        logger.info(
+            "MARS shared adapters for %s: %d attention anchor(s), %d mlp anchor(s)",
+            spec.architecture,
+            len(qkv_anchors),
+            len(mlp_anchors),
+        )
+
+        # --- shared QKV adapters, one per attention block -------------------------------------
+        for _name, module in qkv_anchors:
+            module.shared_qkv = SharedAttentionAdapter(
+                hidden_size=model.config.hidden_size,
+                rank=config.r,
+                shared_rank=config.shared_r,
+                alpha=config.alpha,
+                enabled=enabled_list,
+            )
+            module.register_forward_pre_hook(_compute_shared_qkv, with_kwargs=True)
+
+            for role in _QKV_ROLES:
+                if role not in enabled_qkv:
+                    continue
+                proj_name = spec.module_name_for_role(role)
+                proj = getattr(module, proj_name, None) if proj_name else None
+                if proj is None:
+                    continue
+                proj.projection_type = role
+                proj.register_forward_pre_hook(_pass_qkv_inputs)
+
+        # --- shared MLP adapters -----------------------------------------------------------------
+        for _name, module in mlp_anchors:
+            module.shared_mlp = SharedMLPAdapter(
+                hidden_size=model.config.hidden_size,
+                rank=config.r,
+                shared_rank=config.shared_r,
+                alpha=config.alpha,
+            )
+            module.register_forward_pre_hook(_compute_shared_mlp, with_kwargs=True)
+
+            for role in _MLP_ROLES:
+                proj_name = spec.module_name_for_role(role)
+                proj = getattr(module, proj_name, None) if proj_name else None
+                if proj is None:
+                    continue
+                proj.projection_type = role
+                proj.register_forward_pre_hook(_pass_mlp_inputs)
+
+    def _create_and_replace(
+        self, mars_config, adapter_name, target, target_name, parent, current_key, **kwargs
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # TODO: Add tqdm to this function and class
+        # Print out what will be needed for the layer creation (creating quantization, preserving errors...)
+
+        # Get rank and alpha from config
+        r = mars_config.r
+        alpha = mars_config.alpha
+
+        quantize_base = False
+        preserve_errors = False
+        is_standalone = True
+
+        # Registry data, not a literal ladder: `query` -> "q" on BERT, `q_proj` -> "q" on Llama.
+        # When this returns None the module gets a standalone adapter — which is correct for a target
+        # that genuinely has no shared role, and used to happen to EVERY encoder module because the
+        # ladder tested decoder names only.
+        projection_type = self._arch_spec.role_for_module(target_name)
+
+        self.validate_preserve_errors(mars_config)
+
+        # Determine if adapter is shared or standalone
+        if projection_type in mars_config.enabled_qkv:
+            is_standalone = False
+        elif mars_config.enabled_mlp and projection_type in ["gate", "up"]:
+            is_standalone = False
+
+        # Determine if adapter needs base layer quantization or not
+        # By default optimization level has full quantization of base layers
+        if self.optimization_level > 1:
+            quantize_base = True
+            if (
+                mars_config.modules_to_preserve_errors
+                and projection_type in mars_config.modules_to_preserve_errors
+            ):
+                preserve_errors = True
+        # Else if partial quantization only quantize those layers specified
+        elif self.optimization_level == 1:
+            if mars_config.modules_to_quantize and projection_type in mars_config.modules_to_quantize:
+                quantize_base = True
+                if (
+                    mars_config.modules_to_preserve_errors
+                    and projection_type in mars_config.modules_to_preserve_errors
+                ):
+                    preserve_errors = True
+
+        module_config = {}
+
+        module_config["target_name"] = target_name
+        module_config["is_standalone"] = is_standalone
+        module_config["shared_rank"] = mars_config.shared_r
+        module_config["preserve_errors"] = preserve_errors
+        module_config["quantize_base"] = quantize_base
+        module_config["trainable_down"] = self.trainable_down
+        module_config["onnx_export"] = self.only_export
+        module_config["quant_n_bits"] = self.quant_n_bits
+        module_config["use_bnb"] = self.use_bnb
+
+        if isinstance(target, Linear):
+            target.update_layer(adapter_name, r, alpha, projection_type, **module_config)
+        else:
+            new_module = self._create_new_module(
+                mars_config, adapter_name, target, r, alpha, projection_type, **module_config
+            )
+
+            if adapter_name not in self.active_adapter:
+                new_module.requires_grad_(False)
+
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+
+        # Was a @staticmethod with the decoder module names inlined; it is only ever called from
+        # `_create_and_replace` above, so binding it to the instance is what gives it access to the
+        # architecture spec. Grouping is now by ROLE.
+        role = self._arch_spec.role_for_module(child_name)
+        projection_type = None
+        if role in _QKV_ROLES:
+            projection_type = "qkv"
+        elif role in _MLP_ROLES:
+            projection_type = "mlp"
+
+        forward_hooks = {}
+        forward_pre_hooks = {}
+
+        if hasattr(child, "_forward_hooks"):
+            forward_hooks = child._forward_hooks.copy()
+            child._forward_hooks.clear()  # Remove hooks from original module
+
+        if hasattr(child, "_forward_pre_hooks"):
+            forward_pre_hooks = child._forward_pre_hooks.copy()
+            child._forward_pre_hooks.clear()  # Remove hooks from original module
+
+        setattr(parent, child_name, new_module)
+
+        # child layer wraps the original module, unpack it
+        if hasattr(child, "base_layer"):
+            child = child.base_layer
+
+        if not hasattr(new_module, "base_layer"):
+            new_module.weight = child.weight
+            if hasattr(child, "bias"):
+                new_module.bias = child.bias
+
+        if getattr(child, "state", None) is not None:
+            if hasattr(new_module, "base_layer"):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+
+            new_module.to(child.weight.device)
+
+        # Transfer hooks to the new module
+        if hasattr(new_module, "_forward_hooks"):
+            new_module._forward_hooks.update(forward_hooks)
+        if hasattr(new_module, "_forward_pre_hooks"):
+            new_module._forward_pre_hooks.update(forward_pre_hooks)
+
+        # Set up shared QKV reference
+        if projection_type == "qkv" and hasattr(parent, "shared_qkv"):
+            new_module.shared_qkv = parent.shared_qkv
+
+            # If dequantized module, then update the shared QKV
+            if new_module.preserve_errors:
+                new_module.shared_qkv._update_layer(
+                    new_module.svd_U, new_module.svd_S, new_module.projection_type
+                )
+                new_module.clear_svd_components()
+
+        # Set up shared MLP reference
+        if projection_type == "mlp" and hasattr(parent, "shared_mlp"):
+            new_module.shared_mlp = parent.shared_mlp
+
+            # If dequantized module, then update the shared MLP
+            if new_module.preserve_errors:
+                new_module.shared_mlp._update_layer(
+                    new_module.svd_U, new_module.svd_S, new_module.projection_type
+                )
+                new_module.clear_svd_components()
+
+        meta = torch.device("meta")
+        # dispatch to correct device
+        for name, module in new_module.named_modules():
+            if "mars" in name:
+                if not any(p.device == meta for p in module.parameters()):
+                    module.to(child.weight.device)
+
+    @staticmethod
+    def _create_new_module(mars_config, adapter_name, target, rank, alpha, projection_type, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if "fan_in_fan_out" in kwargs:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                kwargs["fan_in_fan_out"] = False
+        else:
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`"
+            )
+
+        new_module = Linear(
+            base_layer=target,
+            adapter_name=adapter_name,
+            r=rank,
+            alpha=alpha,
+            projection_type=projection_type,
+            mixture=mars_config.mixture,
+            **kwargs,
+        )
+
+        return new_module
+
+    @staticmethod
+    def _check_target_module_exists(mars_config, key):
+        return check_target_module_exists(mars_config, key)
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING:
+                raise ValueError("Please specify `target_modules` in `peft_config`")
+            peft_config.target_modules = set(
+                TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING[model_config["model_type"]]
+            )
+        return peft_config
+
+    def validate_preserve_errors(self, mars_config):
+        if mars_config.modules_to_preserve_errors is None:
+            return
+
+        qkv_errors = {"q", "k", "v"}
+        mlp_errors = {"gate", "down"}
+
+        # Validate QKV
+        if mars_config.enabled_qkv:
+            present_qkv = [x for x in mars_config.modules_to_preserve_errors if x in qkv_errors]
+            if len(present_qkv) > 1:
+                raise ValueError(
+                    f"Only one of ['q', 'k', 'v'] can be in `modules_to_preserve_errors` when shared QKV is enabled. Found: {present_qkv}"
+                )
+
+        # Validate MLP
+        if mars_config.enabled_mlp:
+            present_mlp = [x for x in mars_config.modules_to_preserve_errors if x in mlp_errors]
+            if len(present_mlp) > 1:
+                raise ValueError(
+                    f"Only one of ['gate', 'down'] can be in `modules_to_preserve_errors` when shared MLP is enabled. Found: {present_mlp}"
+                )
+
+    def _mark_only_adapters_as_trainable(self, model: torch.nn.Module) -> None:
+        """Mark only adapter parameters as trainable."""
+        for n, p in model.named_parameters():
+            # If no adapter prefix in name
+            if self.prefix not in n:
+                p.requires_grad = False
+
+            # if we don't want trainable down projection
+            if (
+                not self.trainable_down
+                and self.prefix in n
+                and any([m_name in n for m_name in ["down_project", "shared_qkv", "shared_mlp"]])
+            ):
+                p.requires_grad = False
+
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == "none":
+                continue
+            if bias == "all":
+                for n, p in model.named_parameters():
+                    if "bias" in n:
+                        p.requires_grad = True
+            elif bias == "mars_only":
+                for m in model.modules():
+                    if isinstance(m, MarsLayer) and hasattr(m, "bias") and m.bias is not None:
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f"Requested bias: {bias}, is not implemented.")
+
+    def set_adapter(self, adapter_name):
+        for module in self.model.modules():
+            if isinstance(module, MarsLayer):
+                if module.merged:
+                    warnings.warn(
+                        "Adapter cannot be set when the model is merged. Unmerging the model first."
+                    )
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    def enable_adapter_layers(self) -> None:
+        """Enable all adapters.
+
+        Call this if you have previously disabled all adapters and want to re-enable them.
+        """
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        """Disable all adapters.
+
+        When disabling all adapters, the model output corresponds to the output of the base model.
+        """
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != "none":
+                msg = (
+                    f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same "
+                    "output as the the base model would without adaption."
+                )
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def _set_adapter_layers(self, enabled=True):
+        """Set the enabled state of all adapter layers."""
+        for module in self.model.modules():
+            if isinstance(module, MarsLayer):
+                module.disable_adapters = not enabled
+
+    def save_pretrained(self, save_directory: str, safe_serialization: bool = True) -> None:
+        """Save the trainable adapter weights of the MarsModel.
+
+        Args:
+            save_directory (str): Directory where the adapter model and configuration files will be saved.
+            safe_serialization (bool, optional): Whether to save in safetensors format. Defaults to True.
+        """
+        if os.path.isfile(save_directory):
+            raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
+
+        os.makedirs(save_directory, exist_ok=True)
+
+        # Collect trainable adapter weights
+        adapter_weights = {
+            name: param.clone().detach().cpu()
+            for name, param in self.model.named_parameters()
+            if self.prefix in name
+        }
+
+        if not adapter_weights:
+            warnings.warn("No trainable Mars adapters found. Nothing to save.")
+
+        # Save weights
+        file_path = os.path.join(save_directory, "adapter_model.safetensors")
+        if safe_serialization:
+            save_file(adapter_weights, file_path, metadata={"format": "pt"})
+        else:
+            torch.save(adapter_weights, file_path.replace(".safetensors", ".pt"))
+
+        # Save adapter configuration
+        for adapter_name, config in self.peft_config.items():
+            config.save_pretrained(save_directory)
+
+        print(f"Mars adapters saved to {save_directory}")
diff --git a/peft_models/mars/study.py b/src/mobiletransformers/peft/mars/study.py
similarity index 87%
rename from peft_models/mars/study.py
rename to src/mobiletransformers/peft/mars/study.py
index 1fb7374..ce57b8b 100644
--- a/peft_models/mars/study.py
+++ b/src/mobiletransformers/peft/mars/study.py
@@ -1,11 +1,12 @@
 from itertools import combinations
-import torch
+
 import tensorly as tl
+import torch
 from tensorly.decomposition import tensor_train
-import tensorly.backend as T
 
 # Make sure to set Tensorly to use PyTorch as backend
-tl.set_backend('pytorch')
+tl.set_backend("pytorch")
+
 
 def tensor_train_decomposition(weight_matrix, ranks):
     """
@@ -20,6 +21,7 @@ def tensor_train_decomposition(weight_matrix, ranks):
     tensor_train_cores = tensor_train(weight_matrix, rank=ranks)
     return tensor_train_cores
 
+
 def tensor_train_contract(cores):
     """
     Contract the Tensor Train decomposition back into the original matrix.
@@ -32,6 +34,7 @@ def tensor_train_contract(cores):
     contracted_matrix = tl.tt_to_tensor(cores)
     return contracted_matrix
 
+
 def factorize(n):
     """Finds all factors of a number."""
     factors = []
@@ -42,6 +45,7 @@ def factorize(n):
                 factors.append(n // i)
     return sorted(factors)
 
+
 def find_best_shape(num_elements, target_order):
     """
     Finds the best shape for a higher-order tensor with a given target order.
@@ -53,7 +57,7 @@ def find_best_shape(num_elements, target_order):
     """
     factors = factorize(num_elements)
     best_shape = None
-    min_diff = float('inf')
+    min_diff = float("inf")
 
     # Iterate through all combinations of factors for the target order
     for dims in combinations(factors, target_order):
@@ -67,6 +71,7 @@ def find_best_shape(num_elements, target_order):
         raise ValueError(f"Cannot reshape tensor into order-{target_order} with the given constraints.")
     return best_shape
 
+
 def reshape_to_higher_order(tensor, target_order):
     """
     Reshapes a 2D tensor into a higher-order tensor.
@@ -80,12 +85,13 @@ def reshape_to_higher_order(tensor, target_order):
     best_shape = find_best_shape(num_elements, target_order)
     return tensor.view(*best_shape)
 
+
 def tt_tensor_elements(tt_cores):
     """
     Calculate the total number of elements in a TT decomposition.
-    
+
     Args:
-        tt_cores (list of torch.Tensor): List of TT cores, where each core is a 3D tensor 
+        tt_cores (list of torch.Tensor): List of TT cores, where each core is a 3D tensor
                                          with shape (r_prev, n, r_next).
     Returns:
         int: Total number of elements in the TT decomposition.
@@ -101,71 +107,71 @@ def sequential_svd(matrix, ranks, steps):
     """
     Perform sequential SVD decomposition on a given matrix with rank truncation at each step.
     Afterward, reconstruct the matrix and calculate the error accuracy drop-off.
-    
+
     Args:
         matrix (np.ndarray): The input matrix to decompose.
         ranks (list[int]): A list of ranks to truncate to at each step.
         steps (int): The number of SVD steps to perform.
-    
+
     Returns:
         float: The reconstruction error as a fraction of the original matrix norm.
     """
     assert len(ranks) == steps, "Number of ranks must match the number of steps."
     original_matrix = matrix.clone()
     intermediates = []  # Store intermediate results
-    
+
     for step in range(steps):
         # Perform SVD decomposition
         U, Sigma, Vt = torch.linalg.svd(matrix, full_matrices=False)
-        
+
         # Truncate based on the rank for this step
         rank = ranks[step]
         U_truncated = U[:, :rank]
-        Sigma_truncated = torch.diag(Sigma[:rank]) 
-
+        Sigma_truncated = torch.diag(Sigma[:rank])
 
         print(Sigma_truncated)
         Vt_truncated = Vt[:rank, :]
 
         # Store the truncated components
         intermediates.append(U_truncated)
-        
+
         # Multiply Sigma and Vt to create the next matrix for SVD
         matrix = Sigma_truncated @ Vt_truncated
-        #intermediates.append(matrix[:rank, :rank])
+        # intermediates.append(matrix[:rank, :rank])
 
     intermediates.append(matrix)
-    
+
     # Reconstruct the final matrix from all truncated components
     reconstructed_matrix = intermediates[0]
     for m in intermediates[1:]:
         reconstructed_matrix = reconstructed_matrix @ m
-    
+
     # Compute reconstruction error
     error = torch.linalg.norm(original_matrix - reconstructed_matrix)
     original_norm = torch.linalg.norm(original_matrix)
     reconstruction_error = error / original_norm  # Fraction of the original norm
-    
+
     return reconstruction_error
 
+
 # Example usage:
 if __name__ == "__main__":
     # Generate a random large matrix
     torch.manual_seed(42)
     matrix = torch.rand(1024, 1024)
     # Define ranks for each step and number of steps
-    #ranks = [1, 32, 32, 1]  # Ranks at each step
-    
-    #tt_c = tensor_train_decomposition(weight_matrix=matrix, ranks=ranks)
-    #tt_d = tensor_train_contract(tt_c)
-    #error = torch.linalg.norm(matrix - tt_d)
-    #original_norm = torch.linalg.norm(matrix)
-    #reconstruction_error = error / original_norm  # Fraction of the original norm
-    #print(f"Reconstruction error (TT): {reconstruction_error:.6f}")
+    # ranks = [1, 32, 32, 1]  # Ranks at each step
+
+    # tt_c = tensor_train_decomposition(weight_matrix=matrix, ranks=ranks)
+    # tt_d = tensor_train_contract(tt_c)
+    # error = torch.linalg.norm(matrix - tt_d)
+    # original_norm = torch.linalg.norm(matrix)
+    # reconstruction_error = error / original_norm  # Fraction of the original norm
+    # print(f"Reconstruction error (TT): {reconstruction_error:.6f}")
     # Perform sequential SVD and get reconstruction error
 
     ranks = [128]
     steps = len(ranks)
- 
+
     error = sequential_svd(matrix, ranks, steps=steps)
-    print(f"Reconstruction error (SVD): {error:.6f}")
\ No newline at end of file
+    print(f"Reconstruction error (SVD): {error:.6f}")
diff --git a/src/mobiletransformers/peft/mars/utils.py b/src/mobiletransformers/peft/mars/utils.py
new file mode 100644
index 0000000..442f970
--- /dev/null
+++ b/src/mobiletransformers/peft/mars/utils.py
@@ -0,0 +1,11 @@
+"""MARS target-module table.
+
+DEDUPLICATED (#6): the table itself lives once in
+``mobiletransformers.config.registry.peft.PEFT_TARGET_MODULES_BY_MODEL_TYPE``. This module and
+``peft_models/ablation/utils.py`` used to carry byte-identical copies under two different names,
+so a new model type had to be added twice or the two silently drifted apart.
+"""
+
+from mobiletransformers.config.registry.peft import PEFT_TARGET_MODULES_BY_MODEL_TYPE
+
+TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING = PEFT_TARGET_MODULES_BY_MODEL_TYPE
diff --git a/src/mobiletransformers/public_api.txt b/src/mobiletransformers/public_api.txt
new file mode 100644
index 0000000..bd15a80
--- /dev/null
+++ b/src/mobiletransformers/public_api.txt
@@ -0,0 +1,14 @@
+ConfigValidationError
+ExportError
+HandoffError
+HubError
+ManifestError
+MergeError
+MobileTransformersError
+Settings
+UnsupportedModelError
+__version__
+configure_logging
+get_logger
+get_settings
+resolve
diff --git a/src/mobiletransformers/py.typed b/src/mobiletransformers/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/mobiletransformers/rag/__init__.py b/src/mobiletransformers/rag/__init__.py
new file mode 100644
index 0000000..dbf5ea0
--- /dev/null
+++ b/src/mobiletransformers/rag/__init__.py
@@ -0,0 +1,21 @@
+"""Python-side RAG / vector-database helpers (Migration Map S7, formerly the ``database/`` root).
+
+Builds and queries the ObjectBox vector store that ships beside a package's ``embedding/`` stage. The
+**on-device** store is the Android module's ObjectBox (``ORTVectorDatabase``); this half prepares and
+inspects it on a host, so a corpus can be embedded once and pushed rather than indexed on a phone.
+
+Modules:
+
+* :mod:`~mobiletransformers.rag.vector_entity` — the fixed-dimension entity classes (64…1536). The
+  dimensions here must stay in step with the Kotlin ``DimensionRegistry``; a package whose encoder
+  emits an unlisted dimension cannot be indexed on device.
+* :mod:`~mobiletransformers.rag.builder` — document ingestion, chunking and embedding precompute.
+* :mod:`~mobiletransformers.rag.query` — similarity/text search over a built store.
+* :mod:`~mobiletransformers.rag.json2entity` — ObjectBox model-JSON <-> entity UID plumbing.
+
+Imports are deliberately NOT re-exported at package level: these modules need ``objectbox`` (and
+``builder`` additionally needs LangChain), which the core profile does not install. Importing this
+package must stay cheap, so callers import the submodule they need.
+
+``database/`` still holds deprecation shims re-exporting these names; they are removed in S9.
+"""
diff --git a/database/builder.py b/src/mobiletransformers/rag/builder.py
similarity index 72%
rename from database/builder.py
rename to src/mobiletransformers/rag/builder.py
index 9bcd883..2e63ae0 100644
--- a/database/builder.py
+++ b/src/mobiletransformers/rag/builder.py
@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# DECOMPOSE(#5): RAG/vector-DB helpers move to src/mobiletransformers/rag
+# (ingestion/embeddings/vector_store) in Tier 2 (#25/#26); Android ObjectBox stays in the Android module. ~28 KB.
 """
 ObjectBox Vector Database Precompute Script with LangChain
 
@@ -9,23 +11,22 @@
     python objectbox_precompute_langchain.py --input-dir ./documents --output-dir ./database --embedding-dim 384
 """
 
-
-import json
 import argparse
-from pathlib import Path
+import json
+import logging
 import shutil
 import time
-from typing import List, Optional, Dict, Any
-import logging
+from pathlib import Path
+from typing import Any
 
 # Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 from objectbox import Store
 from objectbox.model import *
 
-from database.vector_entity import (
+from mobiletransformers.rag.vector_entity import (
     VectorEntity64,
     VectorEntity128,
     VectorEntity256,
@@ -33,48 +34,54 @@
     VectorEntity512,
     VectorEntity768,
     VectorEntity1024,
-    VectorEntity1536
+    VectorEntity1536,
 )
 
 try:
-    from langchain_objectbox.vectorstores import ObjectBox as LangChainObjectBox
-    from langchain_community.document_loaders import (
-        TextLoader, 
-        DirectoryLoader,
-        JSONLoader,
-        UnstructuredMarkdownLoader
-    )
+    from langchain.schema import Document
     from langchain.text_splitter import (
+        MarkdownTextSplitter,
         RecursiveCharacterTextSplitter,
         TokenTextSplitter,
-        MarkdownTextSplitter
+    )
+    from langchain_community.document_loaders import (
+        DirectoryLoader,
+        JSONLoader,
+        TextLoader,
+        UnstructuredMarkdownLoader,
     )
     from langchain_huggingface.embeddings import HuggingFaceEmbeddings
-    from langchain.schema import Document
+    from langchain_objectbox.vectorstores import ObjectBox as LangChainObjectBox
 except ImportError as e:
     logger.error(f"LangChain dependencies not installed: {e}")
     logger.error("Install with: pip install langchain-community langchain-objectbox")
     exit(1)
 
 
-class ORTMobileObjectBoxProcessor:
-    def __init__(self, database_dir: str, embedding_dim: Optional[int] = None, model_name: str = "all-MiniLM-L6-v2", no_embed: bool = False):
+class MobileTransformersObjectBoxProcessor:
+    def __init__(
+        self,
+        database_dir: str,
+        embedding_dim: int | None = None,
+        model_name: str = "all-MiniLM-L6-v2",
+        no_embed: bool = False,
+    ):
         self.database_dir = Path(database_dir)
         self.model_name = model_name
         self.no_embed = no_embed
-        
+
         # Create database directory
         self.database_dir.mkdir(parents=True, exist_ok=True)
-        
+
         if not self.no_embed:
             # Initialize embeddings first to get the actual dimension
             logger.info(f"Initializing HuggingFace embeddings with model: {model_name}")
             self.embeddings = HuggingFaceEmbeddings(
                 model_name=model_name,
-                model_kwargs={'device': 'cpu'},  # Use CPU for compatibility
-                encode_kwargs={'normalize_embeddings': True}
+                model_kwargs={"device": "cpu"},  # Use CPU for compatibility
+                encode_kwargs={"normalize_embeddings": True},
             )
-            
+
             # Infer embedding dimension from model if not provided
             if embedding_dim is None:
                 # Test embedding to get dimension
@@ -88,7 +95,9 @@ def __init__(self, database_dir: str, embedding_dim: Optional[int] = None, model
                 test_embedding = self.embeddings.embed_query("test")
                 actual_dim = len(test_embedding)
                 if actual_dim != embedding_dim:
-                    logger.warning(f"Provided embedding dimension ({embedding_dim}) doesn't match model dimension ({actual_dim}). Using model dimension: {actual_dim}")
+                    logger.warning(
+                        f"Provided embedding dimension ({embedding_dim}) doesn't match model dimension ({actual_dim}). Using model dimension: {actual_dim}"
+                    )
                     self.embedding_dim = actual_dim
         else:
             # When no embedding, use provided dimension or default to 384
@@ -96,26 +105,26 @@ def __init__(self, database_dir: str, embedding_dim: Optional[int] = None, model
             self.embeddings = None
             self.embedding_dim = embedding_dim if embedding_dim is not None else 384
             logger.info(f"Using embedding dimension for empty vectors: {self.embedding_dim}")
-        
+
         # Validate dimension is supported
         if self.embedding_dim not in [64, 128, 256, 384, 512, 768, 1024, 1536]:
             logger.error(f"Specified embedding dimension {self.embedding_dim} is not supported.")
             logger.error("Supported dimensions: 64, 128, 256, 384, 512, 768, 1024, 1536")
             raise ValueError(f"Unsupported embedding dimension: {self.embedding_dim}")
-        
+
         logger.info(f"Using embedding dimension: {self.embedding_dim}")
-        
+
         # Setup ObjectBox model and store
         self.entity_class = self._get_entity_class(self.embedding_dim)
         self.model = Model()
         self._setup_model()
-        
+
         # Create ObjectBox store and box
         self.store = Store(model=self.model, directory=str(self.database_dir))
         self.box = self.store.box(self.entity_class)
-        
+
         logger.info(f"ObjectBox database initialized at {self.database_dir}")
-    
+
     def _get_entity_class(self, embedding_dim: int):
         """Get the appropriate entity class based on embedding dimension."""
         entity_map = {
@@ -126,15 +135,17 @@ def _get_entity_class(self, embedding_dim: int):
             512: VectorEntity512,
             768: VectorEntity768,
             1024: VectorEntity1024,
-            1536: VectorEntity1536
+            1536: VectorEntity1536,
         }
-        
+
         if embedding_dim not in entity_map:
-            raise ValueError(f"Unsupported embedding dimension: {embedding_dim}. "
-                           f"Supported dimensions: {list(entity_map.keys())}")
-        
+            raise ValueError(
+                f"Unsupported embedding dimension: {embedding_dim}. "
+                f"Supported dimensions: {list(entity_map.keys())}"
+            )
+
         return entity_map[embedding_dim]
-    
+
     def _setup_model(self):
         """Setup the ObjectBox model."""
         entity_configs = {
@@ -145,98 +156,93 @@ def _setup_model(self):
             512: (VectorEntity512, IdUid(7, 5007), IdUid(5, 5)),
             768: (VectorEntity768, IdUid(7, 6007), IdUid(6, 6)),
             1024: (VectorEntity1024, IdUid(7, 7007), IdUid(7, 7)),
-            1536: (VectorEntity1536, IdUid(7, 8007), IdUid(8, 8))
+            1536: (VectorEntity1536, IdUid(7, 8007), IdUid(8, 8)),
         }
-        
+
         entity_class, _, entity_id = entity_configs[self.embedding_dim]
         self.model.entity(entity_class)
         self.model.last_entity_id = entity_id
-    
-    def load_documents(self, input_dir: Path) -> List[Document]:
+
+    def load_documents(self, input_dir: Path) -> list[Document]:
         """Load documents using LangChain loaders."""
         documents = []
-        
+
         # Load text files
         try:
             text_loader = DirectoryLoader(
                 str(input_dir),
                 glob="**/*.txt",
                 loader_cls=TextLoader,
-                loader_kwargs={'encoding': 'utf-8'},
+                loader_kwargs={"encoding": "utf-8"},
                 recursive=True,
-                show_progress=True
+                show_progress=True,
             )
             text_docs = text_loader.load()
             documents.extend(text_docs)
             logger.info(f"Loaded {len(text_docs)} text files")
         except Exception as e:
             logger.warning(f"Error loading text files: {e}")
-        
+
         # Load markdown files
         try:
             md_loader = DirectoryLoader(
-                    str(input_dir),
-                    glob="**/*.md",
-                    loader_cls=TextLoader,
-                    loader_kwargs={'encoding': 'utf-8'},
-                    recursive=True,
-                    show_progress=True
+                str(input_dir),
+                glob="**/*.md",
+                loader_cls=TextLoader,
+                loader_kwargs={"encoding": "utf-8"},
+                recursive=True,
+                show_progress=True,
             )
             md_docs = md_loader.load()
             logger.info(f"Loaded {len(md_docs)} markdown files (preserving formatting)")
         except Exception as e:
             logger.warning(f"Error loading markdown files: {e}")
-        
+
         # Load JSON files
         try:
             for json_file in input_dir.rglob("*.json"):
                 try:
-                    json_loader = JSONLoader(
-                        file_path=str(json_file),
-                        jq_schema='.', 
-                        text_content=False
-                    )
+                    json_loader = JSONLoader(file_path=str(json_file), jq_schema=".", text_content=False)
                     json_docs = json_loader.load()
                     documents.extend(json_docs)
                 except Exception as e:
                     logger.warning(f"Error loading {json_file}: {e}")
-            logger.info(f"Loaded JSON files")
+            logger.info("Loaded JSON files")
         except Exception as e:
             logger.warning(f"Error loading JSON files: {e}")
-        
+
         logger.info(f"Total documents loaded: {len(documents)}")
         return documents
-    
-    def create_text_splitter(self, chunk_size: int = 512, chunk_overlap: int = 50, 
-                           splitter_type: str = "recursive", markdown_headers: Optional[List[str]] = None) -> Any:
+
+    def create_text_splitter(
+        self,
+        chunk_size: int = 512,
+        chunk_overlap: int = 50,
+        splitter_type: str = "recursive",
+        markdown_headers: list[str] | None = None,
+    ) -> Any:
         """Create a text splitter using LangChain."""
         if splitter_type == "recursive":
             separators = ["\n\n", "\n", " ", ""]
-            
+
             # If markdown headers are specified, add them as primary separators
             if markdown_headers:
                 logger.info(f"Using custom markdown headers as separators: {markdown_headers}")
                 # Convert markdown headers to actual header patterns
                 header_separators = []
                 for header in markdown_headers:
-                    if header.startswith('#'):
+                    if header.startswith("#"):
                         header_separators.append(f"\n{header} ")
                     else:
                         # Assume it's a header level like "##" or "###"
                         header_separators.append(f"\n{header} ")
                 separators = header_separators + separators
-            
+
             return RecursiveCharacterTextSplitter(
-                chunk_size=chunk_size,
-                chunk_overlap=chunk_overlap,
-                length_function=len,
-                separators=separators
+                chunk_size=chunk_size, chunk_overlap=chunk_overlap, length_function=len, separators=separators
             )
         elif splitter_type == "token":
-            return TokenTextSplitter(
-                chunk_size=chunk_size,
-                chunk_overlap=chunk_overlap
-            )
+            return TokenTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
         elif splitter_type == "markdown":
             # For markdown splitter, we can specify headers to split on
             if markdown_headers:
@@ -244,33 +250,30 @@ def create_text_splitter(self, chunk_size: int = 512, chunk_overlap: int = 50,
                 # Convert to the format expected by MarkdownHeaderTextSplitter
                 headers_to_split_on = []
                 for header in markdown_headers:
-                    if header.startswith('#'):
+                    if header.startswith("#"):
                         level = len(header.split()[0])  # Count the # symbols
                         headers_to_split_on.append((header.split()[0], f"Header_{level}"))
                     else:
                         # Assume it's just the # symbols
                         level = len(header)
                         headers_to_split_on.append((header, f"Header_{level}"))
-                
+
                 from langchain.text_splitter import MarkdownHeaderTextSplitter
+
                 return MarkdownHeaderTextSplitter(
-                    headers_to_split_on=headers_to_split_on,
-                    return_each_line=True,
-                    strip_headers=False
+                    headers_to_split_on=headers_to_split_on, return_each_line=True, strip_headers=False
                 )
             else:
-                return MarkdownTextSplitter(
-                    chunk_size=chunk_size,
-                    chunk_overlap=chunk_overlap
-                )
+                return MarkdownTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
         elif splitter_type == "document":
             logger.info("Using document-based splitter - each document becomes one chunk")
             return None  # We'll handle this case specially in process_and_store
         else:
             raise ValueError(f"Unknown splitter type: {splitter_type}")
-    
-    def create_vector_entity(self, name: str, content: str, document: str, 
-                           embedding: List[float], metadata: Dict[str, Any]) -> Any:
+
+    def create_vector_entity(
+        self, name: str, content: str, document: str, embedding: list[float], metadata: dict[str, Any]
+    ) -> Any:
         """Create a vector entity instance."""
         entity = self.entity_class()
         entity.name = name
@@ -280,8 +283,8 @@ def create_vector_entity(self, name: str, content: str, document: str,
         entity.metadata = json.dumps(metadata)
         entity.timestamp = int(time.time() * 1000)  # Current timestamp in milliseconds
         return entity
-    
-    def insert_vector_batch(self, entities: List[Any]) -> List[int]:
+
+    def insert_vector_batch(self, entities: list[Any]) -> list[int]:
         """Insert multiple vector entities in a batch."""
         try:
             ids = []
@@ -292,11 +295,12 @@ def insert_vector_batch(self, entities: List[Any]) -> List[int]:
         except Exception as e:
             logger.error(f"Error inserting batch: {e}")
             return []
-    
-    def process_and_store(self, documents: List[Document], text_splitter: Any, splitter_type,
-                         batch_size: int = 100) -> int:
+
+    def process_and_store(
+        self, documents: list[Document], text_splitter: Any, splitter_type, batch_size: int = 100
+    ) -> int:
         """Process documents and store in ObjectBox using custom entities."""
-        
+
         # Handle document-based splitter (no actual splitting)
         if text_splitter is None:  # document splitter case
             logger.info("Using document-based chunking - storing whole documents")
@@ -317,19 +321,21 @@ def process_and_store(self, documents: List[Document], text_splitter: Any, split
             chunks = text_splitter.split_documents(documents)
 
         logger.info(f"Created {len(chunks)} chunks from {len(documents)} documents")
-        
+
         # Process chunks in batches
         total_stored = 0
         current_timestamp = int(time.time() * 1000)
-        
+
         for i in range(0, len(chunks), batch_size):
-            batch_chunks = chunks[i:i + batch_size]
-            logger.info(f"Processing batch {i//batch_size + 1}/{(len(chunks) + batch_size - 1)//batch_size}")
-            
+            batch_chunks = chunks[i : i + batch_size]
+            logger.info(
+                f"Processing batch {i // batch_size + 1}/{(len(chunks) + batch_size - 1) // batch_size}"
+            )
+
             try:
                 # Prepare texts for embedding
                 texts = [chunk.page_content for chunk in batch_chunks]
-                
+
                 # Generate embeddings for the batch or create empty vectors
                 if not self.no_embed and self.embeddings:
                     logger.info(f"Generating embeddings for {len(texts)} chunks...")
@@ -338,27 +344,24 @@ def process_and_store(self, documents: List[Document], text_splitter: Any, split
                     logger.info(f"Creating empty vectors for {len(texts)} chunks (no-embed mode)")
                     # Create empty vectors with the correct dimension
                     embeddings = [[0.0] * self.embedding_dim for _ in range(len(texts))]
-                
+
                 # Create entity instances
                 entities = []
                 for j, (chunk, embedding) in enumerate(zip(batch_chunks, embeddings)):
                     # Extract source file name
-                    source = chunk.metadata.get('source', f'document_{i + j}')
-                    document_name = Path(source).name if source else f'document_{i + j}'
+                    source = chunk.metadata.get("source", f"document_{i + j}")
+                    document_name = Path(source).name if source else f"document_{i + j}"
+
+                    # print(chunk.page_content)
+                    # print("------------------------")
 
-                    #print(chunk.page_content)
-                    #print("------------------------")
-                    
                     # Create chunk metadata
-                    chunk_metadata = {
-                        'chunk_id': i + j,
-                        'chunk_index': j
-                    }
-                    
+                    chunk_metadata = {"chunk_id": i + j, "chunk_index": j}
+
                     # Add any existing metadata from the document
-                    if hasattr(chunk, 'metadata') and chunk.metadata:
+                    if hasattr(chunk, "metadata") and chunk.metadata:
                         chunk_metadata.update(chunk.metadata)
-                    
+
                     # Create entity
                     entity_name = document_name if text_splitter is None else f"{document_name}_chunk_{j}"
                     entity = self.create_vector_entity(
@@ -366,81 +369,90 @@ def process_and_store(self, documents: List[Document], text_splitter: Any, split
                         content=chunk.page_content,
                         document=document_name,
                         embedding=embedding,
-                        metadata=chunk_metadata
+                        metadata=chunk_metadata,
                     )
                     entities.append(entity)
-                
+
                 # Insert batch
                 logger.info(f"Inserting {len(entities)} entities into database...")
                 ids = self.insert_vector_batch(entities)
-                
+
                 if ids:
                     total_stored += len(ids)
                     logger.info(f"Successfully stored {len(ids)} chunks. Total: {total_stored}")
                 else:
-                    logger.error(f"Failed to store batch {i//batch_size + 1}")
-                
+                    logger.error(f"Failed to store batch {i // batch_size + 1}")
+
             except Exception as e:
-                logger.error(f"Error processing batch {i//batch_size + 1}: {e}")
+                logger.error(f"Error processing batch {i // batch_size + 1}: {e}")
                 continue
-        
+
         return total_stored
-    
-    def get_database_stats(self) -> Dict[str, Any]:
+
+    def get_database_stats(self) -> dict[str, Any]:
         """Get database statistics."""
         return {
             "total_vectors": self.box.count(),
             "embedding_dimension": self.embedding_dim,
             "model_name": self.model_name,
             "database_path": str(self.database_dir),
-            "no_embed_mode": self.no_embed
+            "no_embed_mode": self.no_embed,
         }
-    
+
     def close(self):
         """Close the database."""
         self.store.close()
 
-def process_documents_with_custom_entities(input_dir: Path, output_dir: Path, embedding_dim: Optional[int],
-                                         model_name: str = "all-MiniLM-L6-v2", 
-                                         chunk_size: int = 512, chunk_overlap: int = 50,
-                                         splitter_type: str = "recursive", no_embed: bool = False,
-                                         markdown_headers: Optional[List[str]] = None):
+
+def process_documents_with_custom_entities(
+    input_dir: Path,
+    output_dir: Path,
+    embedding_dim: int | None,
+    model_name: str = "all-MiniLM-L6-v2",
+    chunk_size: int = 512,
+    chunk_overlap: int = 50,
+    splitter_type: str = "recursive",
+    no_embed: bool = False,
+    markdown_headers: list[str] | None = None,
+):
     """Main processing function using custom ObjectBox entities."""
-    
+
     # Initialize processor (embedding_dim can be None for auto-inference)
-    processor = ORTMobileObjectBoxProcessor(str(output_dir), embedding_dim, model_name, no_embed)
-    
+    processor = MobileTransformersObjectBoxProcessor(str(output_dir), embedding_dim, model_name, no_embed)
+
     try:
         # Load documents using LangChain loaders
         logger.info("Loading documents...")
         documents = processor.load_documents(input_dir)
-        
+
         if not documents:
             logger.error("No documents found to process")
             return
-        
+
         # Create text splitter
         if splitter_type == "document":
             logger.info("Using document-based splitter - no chunking will be performed")
             text_splitter = None
         else:
-            logger.info(f"Creating {splitter_type} text splitter (chunk_size={chunk_size}, overlap={chunk_overlap})")
+            logger.info(
+                f"Creating {splitter_type} text splitter (chunk_size={chunk_size}, overlap={chunk_overlap})"
+            )
             if markdown_headers:
                 logger.info(f"Using custom markdown headers: {markdown_headers}")
             text_splitter = processor.create_text_splitter(
-                chunk_size=chunk_size, 
+                chunk_size=chunk_size,
                 chunk_overlap=chunk_overlap,
                 splitter_type=splitter_type,
-                markdown_headers=markdown_headers
+                markdown_headers=markdown_headers,
             )
-        
+
         # Process and store documents
         logger.info("Processing and storing documents...")
         total_stored = processor.process_and_store(documents, text_splitter, splitter_type)
-        
+
         # Get final statistics
         stats = processor.get_database_stats()
-        
+
         logger.info("Database creation completed!")
         logger.info(f"Documents processed: {len(documents)}")
         logger.info(f"Total vectors stored: {stats['total_vectors']}")
@@ -448,38 +460,39 @@ def process_documents_with_custom_entities(input_dir: Path, output_dir: Path, em
         logger.info(f"Model used: {stats['model_name']}")
         logger.info(f"No-embed mode: {stats['no_embed_mode']}")
         logger.info(f"Database location: {stats['database_path']}")
-        
+
         # Save database info
         info_file = output_dir / "database_info.json"
-        with open(info_file, 'w') as f:
+        with open(info_file, "w") as f:
             json.dump(stats, f, indent=2)
-        
+
         logger.info(f"Database info saved to {info_file}")
-        
+
         # Save processing configuration for reference
         config = {
             "chunk_size": chunk_size,
             "chunk_overlap": chunk_overlap,
             "splitter_type": splitter_type,
             "model_name": model_name,
-            "embedding_dimension": stats['embedding_dimension'],
+            "embedding_dimension": stats["embedding_dimension"],
             "total_documents": len(documents),
-            "total_vectors": stats['total_vectors'],
+            "total_vectors": stats["total_vectors"],
             "supported_file_types": [".txt", ".md", ".json"],
             "distance_type": "cosine",
             "no_embed_mode": no_embed,
-            "markdown_headers": markdown_headers
+            "markdown_headers": markdown_headers,
         }
-        
+
         config_file = output_dir / "processing_config.json"
-        with open(config_file, 'w') as f:
+        with open(config_file, "w") as f:
             json.dump(config, f, indent=2)
-        
+
         logger.info(f"Processing configuration saved to {config_file}")
-        
+
     finally:
         processor.close()
 
+
 def validate_and_prepare_schema(script_dir: Path):
     """
     Validate that default.json exists and copy it to objectbox-model/default.json
@@ -487,11 +500,11 @@ def validate_and_prepare_schema(script_dir: Path):
     """
     # Check for default.json in the same directory as the script
     kotlin_schema_path = script_dir / "default.json"
-    
+
     if not kotlin_schema_path.exists():
-        logger.error("="*60)
+        logger.error("=" * 60)
         logger.error("SCHEMA ERROR: Missing Kotlin ObjectBox schema!")
-        logger.error("="*60)
+        logger.error("=" * 60)
         logger.error(f"Required file not found: {kotlin_schema_path}")
         logger.error("")
         logger.error("SOLUTION:")
@@ -501,107 +514,131 @@ def validate_and_prepare_schema(script_dir: Path):
         logger.error("")
         logger.error("This file is required to ensure Python entities match")
         logger.error("your Kotlin ObjectBox schema (IDs, UIDs, indexes).")
-        logger.error("="*60)
+        logger.error("=" * 60)
         raise FileNotFoundError(f"Kotlin ObjectBox schema not found: {kotlin_schema_path}")
-    
+
     # Validate the JSON file
     try:
-        with open(kotlin_schema_path, 'r') as f:
+        with open(kotlin_schema_path) as f:
             schema_data = json.load(f)
-        
+
         # Basic validation
-        if 'entities' not in schema_data:
+        if "entities" not in schema_data:
             raise ValueError("Invalid ObjectBox schema: missing 'entities' field")
-        
-        if not schema_data['entities']:
+
+        if not schema_data["entities"]:
             raise ValueError("Invalid ObjectBox schema: no entities found")
-        
+
         # Check for VectorEntity classes
-        vector_entities = [e for e in schema_data['entities'] if e['name'].startswith('VectorEntity')]
+        vector_entities = [e for e in schema_data["entities"] if e["name"].startswith("VectorEntity")]
         if not vector_entities:
-            logger.warning("No VectorEntity classes found in schema. Expected VectorEntity64, VectorEntity384, etc.")
+            logger.warning(
+                "No VectorEntity classes found in schema. Expected VectorEntity64, VectorEntity384, etc."
+            )
         else:
-            entity_names = [e['name'] for e in vector_entities]
+            entity_names = [e["name"] for e in vector_entities]
             logger.info(f"Found VectorEntity classes: {', '.join(entity_names)}")
-        
+
     except json.JSONDecodeError as e:
         logger.error(f"Invalid JSON in schema file: {e}")
         raise ValueError(f"Kotlin schema file is not valid JSON: {kotlin_schema_path}")
     except Exception as e:
         logger.error(f"Error validating schema: {e}")
         raise
-    
+
     # Create objectbox-model directory in script directory
-    
+
     # Copy schema to the expected location in script directory
     target_schema_path = script_dir / "objectbox-model.json"
     shutil.copy2(kotlin_schema_path, target_schema_path)
-    
+
     logger.info(f"✅ Kotlin schema validated and copied to: {target_schema_path}")
     logger.info(f"📋 Schema contains {len(schema_data['entities'])} entities")
-    
+
     return target_schema_path, schema_data
 
+
 def main():
-    parser = argparse.ArgumentParser(description='Create ObjectBox vector database with custom entities using LangChain')
-    parser.add_argument('--input-dir', type=str, required=True,
-                       help='Directory containing documents to process')
-    parser.add_argument('--output-dir', type=str, required=True,
-                       help='Output directory for the ObjectBox database')
-    parser.add_argument('--embedding-dim', type=int, default=None,
-                       choices=[64, 128, 256, 384, 512, 768, 1024, 1536],
-                       help='Embedding dimension (default: infer from model, or 384 if --no-embed)')
-    parser.add_argument('--model', type=str, default='sentence-transformers/all-MiniLM-L6-v2',
-                       help='HuggingFace model name (default: sentence-transformers/all-MiniLM-L6-v2)')
-    parser.add_argument('--chunk-size', type=int, default=128,
-                       help='Text chunk size (default: 128)')
-    parser.add_argument('--chunk-overlap', type=int, default=32,
-                       help='Chunk overlap size (default: 32)')
-    parser.add_argument('--splitter-type', type=str, default='recursive',
-                       choices=['recursive', 'token', 'markdown', 'document'],
-                       help='Text splitter type (default: recursive)')
-    parser.add_argument('--no-embed', action='store_true',
-                       help='Skip embedding generation and store empty vectors')
-    parser.add_argument('--markdown-headers', type=str, nargs='*',
-                       help='Markdown headers to split on (e.g., "##" "###" or "## Section" "### Subsection")')
-    
+    parser = argparse.ArgumentParser(
+        description="Create ObjectBox vector database with custom entities using LangChain"
+    )
+    parser.add_argument(
+        "--input-dir", type=str, required=True, help="Directory containing documents to process"
+    )
+    parser.add_argument(
+        "--output-dir", type=str, required=True, help="Output directory for the ObjectBox database"
+    )
+    parser.add_argument(
+        "--embedding-dim",
+        type=int,
+        default=None,
+        choices=[64, 128, 256, 384, 512, 768, 1024, 1536],
+        help="Embedding dimension (default: infer from model, or 384 if --no-embed)",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="sentence-transformers/all-MiniLM-L6-v2",
+        help="HuggingFace model name (default: sentence-transformers/all-MiniLM-L6-v2)",
+    )
+    parser.add_argument("--chunk-size", type=int, default=128, help="Text chunk size (default: 128)")
+    parser.add_argument("--chunk-overlap", type=int, default=32, help="Chunk overlap size (default: 32)")
+    parser.add_argument(
+        "--splitter-type",
+        type=str,
+        default="recursive",
+        choices=["recursive", "token", "markdown", "document"],
+        help="Text splitter type (default: recursive)",
+    )
+    parser.add_argument(
+        "--no-embed", action="store_true", help="Skip embedding generation and store empty vectors"
+    )
+    parser.add_argument(
+        "--markdown-headers",
+        type=str,
+        nargs="*",
+        help='Markdown headers to split on (e.g., "##" "###" or "## Section" "### Subsection")',
+    )
+
     args = parser.parse_args()
-    
+
     input_dir = Path(args.input_dir)
     output_dir = Path(args.output_dir)
     script_dir = Path(__file__).parent.resolve()
-    
+
     if not input_dir.exists():
         logger.error(f"Input directory does not exist: {input_dir}")
         return
-    
+
     # Validate markdown headers format if provided
     markdown_headers = None
     if args.markdown_headers:
         markdown_headers = args.markdown_headers
         logger.info(f"Will use markdown headers for splitting: {markdown_headers}")
-    
+
     # Validate and prepare ObjectBox schema BEFORE anything else
     try:
         schema_path, schema_data = validate_and_prepare_schema(script_dir)
     except (FileNotFoundError, ValueError) as e:
         logger.error(f"Schema validation failed: {e}")
         return
-    
+
     # Create output directory
     output_dir.mkdir(parents=True, exist_ok=True)
-    
+
     logger.info("Starting ObjectBox vector database creation with custom entities...")
     logger.info(f"Input directory: {input_dir}")
     logger.info(f"Output directory: {output_dir}")
-    logger.info(f"Embedding dimension: {'auto-infer from model' if args.embedding_dim is None else args.embedding_dim}")
+    logger.info(
+        f"Embedding dimension: {'auto-infer from model' if args.embedding_dim is None else args.embedding_dim}"
+    )
     logger.info(f"Model: {args.model}")
     logger.info(f"Chunk size: {args.chunk_size}")
     logger.info(f"Chunk overlap: {args.chunk_overlap}")
     logger.info(f"Splitter type: {args.splitter_type}")
     logger.info(f"No-embed mode: {args.no_embed}")
     logger.info(f"Markdown headers: {markdown_headers}")
-    
+
     # Call the main processing function
     process_documents_with_custom_entities(
         input_dir=input_dir,
@@ -612,7 +649,7 @@ def main():
         chunk_overlap=args.chunk_overlap,
         splitter_type=args.splitter_type,
         no_embed=args.no_embed,
-        markdown_headers=markdown_headers
+        markdown_headers=markdown_headers,
     )
 
     logger.info("Copying the generated object-box model json to output dir")
@@ -623,5 +660,6 @@ def main():
     except Exception as e:
         logger.error(f"Failed to copy schema file: {e}")
 
+
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/database/default.json b/src/mobiletransformers/rag/default.json
similarity index 100%
rename from database/default.json
rename to src/mobiletransformers/rag/default.json
diff --git a/src/mobiletransformers/rag/json2entity.py b/src/mobiletransformers/rag/json2entity.py
new file mode 100644
index 0000000..f68c6f6
--- /dev/null
+++ b/src/mobiletransformers/rag/json2entity.py
@@ -0,0 +1,193 @@
+import json
+from pathlib import Path
+
+
+def extract_uids_from_objectbox_json(json_file_path):
+    """
+    Extract UIDs from ObjectBox default.json file and generate Python entity code
+    """
+    with open(json_file_path) as f:
+        data = json.load(f)
+
+    python_code = []
+
+    for entity in data.get("entities", []):
+        # Extract entity info
+        entity_id_uid = entity["id"]  # Format: "ID:UID"
+        entity_id, entity_uid = entity_id_uid.split(":")
+        entity_name = entity["name"]
+
+        # Extract dimensions from entity name (e.g., VectorEntity384 -> 384)
+        dimensions = "".join(filter(str.isdigit, entity_name))
+
+        # Start entity definition
+        python_code.append(f"@Entity(uid={entity_uid})")
+        python_code.append(f"class {entity_name}:")
+
+        # Extract property UIDs
+        for prop in entity.get("properties", []):
+            prop_id_uid = prop["id"]  # Format: "ID:UID"
+            prop_id, prop_uid = prop_id_uid.split(":")
+            prop_name = prop["name"]
+
+            # Generate property definition based on name
+            if prop_name == "id":
+                python_code.append(f"    {prop_name} = Id(id={prop_id}, uid={prop_uid})")
+            elif prop_name == "embedding":
+                # Check if property has indexId (HnswIndex)
+                if "indexId" in prop:
+                    python_code.append(
+                        f"    {prop_name} = Float32Vector(id={prop_id}, uid={prop_uid}, index=HnswIndex(dimensions={dimensions}, distance_type=VectorDistanceType.COSINE))"
+                    )
+                else:
+                    python_code.append(f"    {prop_name} = Float32Vector(id={prop_id}, uid={prop_uid})")
+            elif prop_name == "timestamp":
+                python_code.append(f"    {prop_name} = Property(int, id={prop_id}, uid={prop_uid})")
+            elif prop_name == "content":
+                # Always add index for content field
+                if "indexId" in prop:
+                    index_id, index_uid = prop["indexId"].split(":")
+                    python_code.append(
+                        f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE, uid={index_uid}))"
+                    )
+                else:
+                    python_code.append(
+                        f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE))"
+                    )
+            else:
+                # Other string properties (name, document, metadata)
+                if "indexId" in prop:
+                    index_id, index_uid = prop["indexId"].split(":")
+                    python_code.append(
+                        f"    {prop_name} = String(id={prop_id}, uid={prop_uid}, index=Index(type=IndexType.VALUE, uid={index_uid}))"
+                    )
+                else:
+                    python_code.append(f"    {prop_name} = String(id={prop_id}, uid={prop_uid})")
+
+        python_code.append("")  # Empty line between entities
+
+    return "\n".join(python_code)
+
+
+def extract_uids_for_kotlin(json_file_path):
+    """
+    Extract UIDs and generate Kotlin @Uid annotations
+    """
+    with open(json_file_path) as f:
+        data = json.load(f)
+
+    kotlin_annotations = []
+
+    for entity in data.get("entities", []):
+        entity_id_uid = entity["id"]
+        entity_id, entity_uid = entity_id_uid.split(":")
+        entity_name = entity["name"]
+
+        # Extract dimensions from entity name
+        dimensions = "".join(filter(str.isdigit, entity_name))
+
+        kotlin_annotations.append(f"// {entity_name}")
+        kotlin_annotations.append("@Entity")
+        kotlin_annotations.append(f"@Uid({entity_uid})")
+        kotlin_annotations.append(f"data class {entity_name}(")
+
+        for prop in entity.get("properties", []):
+            prop_id_uid = prop["id"]
+            prop_id, prop_uid = prop_id_uid.split(":")
+            prop_name = prop["name"]
+
+            if prop_name == "id":
+                kotlin_annotations.append(f"    @Id @Uid({prop_uid}) override var {prop_name}: Long = 0,")
+            elif prop_name == "embedding":
+                kotlin_annotations.append(
+                    f"    @HnswIndex(dimensions = {dimensions}, distanceType = VectorDistanceType.COSINE)"
+                )
+                kotlin_annotations.append(
+                    f"    @Uid({prop_uid}) override var {prop_name}: FloatArray = floatArrayOf(),"
+                )
+            elif prop_name == "content":
+                # Always add @Index for content field
+                kotlin_annotations.append(
+                    f'    @Index @Uid({prop_uid}) override var {prop_name}: String = "",'
+                )
+            else:
+                if prop_name == "timestamp":
+                    kotlin_annotations.append(
+                        f"    @Uid({prop_uid}) override var {prop_name}: Long = System.currentTimeMillis(),"
+                    )
+                else:
+                    kotlin_annotations.append(f'    @Uid({prop_uid}) override var {prop_name}: String = "",')
+
+        kotlin_annotations.append(")")
+        kotlin_annotations.append("")
+
+    return "\n".join(kotlin_annotations)
+
+
+def create_filtered_json_model(
+    json_file_path, entity_names_to_include, output_path="objectbox-model/default.json"
+):
+    """
+    Create a filtered ObjectBox JSON model that only includes specified entities
+    while preserving their original IDs and UIDs
+    """
+    import os
+
+    with open(json_file_path) as f:
+        data = json.load(f)
+
+    # Filter entities to only include specified ones
+    filtered_entities = []
+    for entity in data.get("entities", []):
+        if entity["name"] in entity_names_to_include:
+            filtered_entities.append(entity)
+
+    # Create filtered model
+    filtered_data = data.copy()
+    filtered_data["entities"] = filtered_entities
+
+    # Update lastEntityId to the highest ID among included entities
+    if filtered_entities:
+        last_entity = max(filtered_entities, key=lambda e: int(e["id"].split(":")[0]))
+        filtered_data["lastEntityId"] = last_entity["id"]
+
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    # Write filtered model
+    with open(output_path, "w") as f:
+        json.dump(filtered_data, f, indent=2)
+
+    print(f"✅ Filtered ObjectBox model saved to '{output_path}'")
+    print(f"📋 Included entities: {entity_names_to_include}")
+
+    return output_path
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Replace with your actual path
+    # S9: was the repo-relative "database/default.json". That root is gone and this module now
+    # ships inside the wheel, so resolve the schema beside the module instead of beside the CWD.
+    json_path = str(Path(__file__).parent / "default.json")
+
+    print("=== PYTHON ENTITIES ===")
+    python_entities = extract_uids_from_objectbox_json(json_path)
+    print(python_entities)
+
+    print("\n=== KOTLIN ANNOTATIONS ===")
+    print(extract_uids_for_kotlin(json_path))
+
+    # Save Python entities to file
+    with open("vector_entity.py", "w") as f:
+        f.write("from objectbox.model import *\n")
+        f.write("from objectbox.model.properties import Index, IndexType\n\n")
+        f.write("# Auto-generated ObjectBox entities with UIDs from Kotlin\n")
+        f.write("# Generated from: " + json_path + "\n\n")
+        f.write(python_entities)
+
+    print("\n✅ Python entities saved to 'vector_entity.py'")
+
+    # Create filtered model for Python (example: only include VectorEntity384)
+    entities_to_use = ["VectorEntity384"]  # Modify this list as needed
+    create_filtered_json_model(json_path, entities_to_use)
diff --git a/database/objectbox-model.json b/src/mobiletransformers/rag/objectbox-model.json
similarity index 100%
rename from database/objectbox-model.json
rename to src/mobiletransformers/rag/objectbox-model.json
diff --git a/database/query.py b/src/mobiletransformers/rag/query.py
similarity index 74%
rename from database/query.py
rename to src/mobiletransformers/rag/query.py
index 71003ca..8494e12 100644
--- a/database/query.py
+++ b/src/mobiletransformers/rag/query.py
@@ -9,24 +9,24 @@
     python objectbox_query.py --database-dir ./mobile_database --query "your search text"
 """
 
-import os
-import json
 import argparse
+import json
+import logging
 import time
 from pathlib import Path
-from typing import List, Optional, Dict, Any, Tuple
-import logging
+from typing import Any
+
 import numpy as np
 
 # Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 
-from objectbox import Entity, Id, Store, String, Float32Vector
+from objectbox import Store
 from objectbox.model import *
 
-from database.vector_entity import (
+from mobiletransformers.rag.vector_entity import (
     VectorEntity64,
     VectorEntity128,
     VectorEntity256,
@@ -34,7 +34,7 @@
     VectorEntity512,
     VectorEntity768,
     VectorEntity1024,
-    VectorEntity1536
+    VectorEntity1536,
 )
 
 try:
@@ -43,8 +43,10 @@
     logger.error("LangChain not installed. Install with: pip install langchain langchain-community")
     exit(1)
 
+
 class VectorSearchResult:
     """Container for search results with similarity scores."""
+
     def __init__(self, entity, score: float):
         self.id = entity.id
         self.name = entity.name
@@ -54,67 +56,72 @@ def __init__(self, entity, score: float):
         self.metadata = json.loads(entity.metadata) if entity.metadata else {}
         self.timestamp = entity.timestamp
         self.score = score
-    
-    def to_dict(self) -> Dict[str, Any]:
+
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
-            'id': self.id,
-            'name': self.name,
-            'content': self.content,
-            'document': self.document,
-            'metadata': self.metadata,
-            'timestamp': self.timestamp,
-            'similarity_score': self.score
+            "id": self.id,
+            "name": self.name,
+            "content": self.content,
+            "document": self.document,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp,
+            "similarity_score": self.score,
         }
-    
+
     def __str__(self) -> str:
         """String representation for pretty printing."""
         return f"Score: {self.score:.4f} | Document: {self.document} | Content: {self.content[:100]}..."
 
+
 class ObjectBoxQueryEngine:
-    def __init__(self, database_dir: str, model_name: Optional[str] = None):
+    def __init__(self, database_dir: str, model_name: str | None = None):
         self.database_dir = Path(database_dir)
-        
+
         if not self.database_dir.exists():
             raise FileNotFoundError(f"Database directory not found: {database_dir}")
-        
+
         # Load database info to get configuration
         info_file = self.database_dir / "database_info.json"
         if info_file.exists():
-            with open(info_file, 'r') as f:
+            with open(info_file) as f:
                 self.db_info = json.load(f)
-            self.embedding_dim = self.db_info['embedding_dimension']
-            self.model_name = model_name or self.db_info['model_name']
+            self.embedding_dim = self.db_info["embedding_dimension"]
+            self.model_name = model_name or self.db_info["model_name"]
             logger.info(f"Loaded database info: {self.embedding_dim}D embeddings, model: {self.model_name}")
         else:
             raise FileNotFoundError(f"Database info file not found: {info_file}")
-        
+
         # Initialize embeddings (for query encoding)
         if model_name or self.model_name:
             logger.info(f"Initializing embeddings with model: {self.model_name}")
             self.embeddings = HuggingFaceEmbeddings(
                 model_name=self.model_name,
-                model_kwargs={'device': 'cpu'},
-                encode_kwargs={'normalize_embeddings': True}
+                model_kwargs={"device": "cpu"},
+                encode_kwargs={"normalize_embeddings": True},
             )
         else:
             self.embeddings = None
             logger.warning("No embedding model specified. Vector similarity search will not be available.")
-        
+
         # Setup ObjectBox
         self.entity_class = self._get_entity_class(self.embedding_dim)
         self.model = Model()
         self._setup_model()
-        
+
         # Open store in read-only mode
-        self.store = Store(model=self.model, directory=str(self.database_dir), model_json_file=f"{self.database_dir}/objectbox-model.json")
+        self.store = Store(
+            model=self.model,
+            directory=str(self.database_dir),
+            model_json_file=f"{self.database_dir}/objectbox-model.json",
+        )
         self.box = self.store.box(self.entity_class)
-        
-        logger.info(f"ObjectBox query engine initialized")
+
+        logger.info("ObjectBox query engine initialized")
         logger.info(f"Database: {self.database_dir}")
         logger.info(f"Entity class: {self.entity_class}")
         logger.info(f"Total vectors: {self.box.count()}")
-    
+
     def _get_entity_class(self, embedding_dim: int):
         """Get the appropriate entity class based on embedding dimension."""
         entity_map = {
@@ -125,10 +132,10 @@ def _get_entity_class(self, embedding_dim: int):
             512: VectorEntity512,
             768: VectorEntity768,
             1024: VectorEntity1024,
-            1536: VectorEntity1536
+            1536: VectorEntity1536,
         }
         return entity_map[embedding_dim]
-    
+
     def _setup_model(self):
         """Setup the ObjectBox model."""
         entity_configs = {
@@ -139,137 +146,143 @@ def _setup_model(self):
             512: (VectorEntity512, IdUid(7, 5007), IdUid(5, 5)),
             768: (VectorEntity768, IdUid(7, 6007), IdUid(6, 6)),
             1024: (VectorEntity1024, IdUid(7, 7007), IdUid(7, 7)),
-            1536: (VectorEntity1536, IdUid(7, 8007), IdUid(8, 8))
+            1536: (VectorEntity1536, IdUid(7, 8007), IdUid(8, 8)),
         }
-        
+
         entity_class, last_prop_id, entity_id = entity_configs[self.embedding_dim]
         self.model.entity(entity_class)
         self.model.last_entity_id = entity_id
-    
-    def cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
+
+    def cosine_similarity(self, vec1: list[float], vec2: list[float]) -> float:
         """Calculate cosine similarity between two vectors."""
         vec1_np = np.array(vec1)
         vec2_np = np.array(vec2)
-        
+
         # Calculate dot product
         dot_product = np.dot(vec1_np, vec2_np)
-        
+
         # Calculate magnitudes
         magnitude1 = np.linalg.norm(vec1_np)
         magnitude2 = np.linalg.norm(vec2_np)
-        
+
         # Calculate cosine similarity
         if magnitude1 == 0 or magnitude2 == 0:
             return 0.0
-        
+
         return dot_product / (magnitude1 * magnitude2)
-    
-    def vector_similarity_search(self, query_text: str, top_k: int = 10, 
-                                min_score: float = 0.0) -> List[VectorSearchResult]:
+
+    def vector_similarity_search(
+        self, query_text: str, top_k: int = 10, min_score: float = 0.0
+    ) -> list[VectorSearchResult]:
         """
         Perform vector similarity search using query text.
-        
+
         Args:
             query_text: Text to search for
             top_k: Number of top results to return
             min_score: Minimum similarity score threshold
-            
+
         Returns:
             List of VectorSearchResult objects sorted by similarity score
         """
         if not self.embeddings:
             raise ValueError("No embedding model available for vector search")
-        
+
         # Generate query embedding
         logger.info(f"Generating embedding for query: '{query_text}'")
         query_embedding = self.embeddings.embed_query(query_text)
         logger.info(f"Query embedding dimension: {len(query_embedding)}")
-        
+
         # Get all vectors from database
         logger.info("Retrieving all vectors from database...")
         all_entities = self.box.get_all()
         logger.info(f"Found {len(all_entities)} entities in database")
-        
+
         # Log first few entities for debugging
         for i, entity in enumerate(all_entities[:3]):
-            logger.info(f"Entity {i+1}:")
+            logger.info(f"Entity {i + 1}:")
             logger.info(f"  ID: {entity.id}")
             logger.info(f"  Name: {entity.name}")
             logger.info(f"  Document: {entity.document}")
             logger.info(f"  Content length: {len(entity.content)}")
             try:
-                embedding_len = len(entity.embedding) if entity.embedding is not None else 'None'
+                embedding_len = len(entity.embedding) if entity.embedding is not None else "None"
             except:
-                embedding_len = 'Error'
+                embedding_len = "Error"
             logger.info(f"  Embedding length: {embedding_len}")
             logger.info(f"  Content preview: {entity.content[:100]}...")
-        
+
         if not all_entities:
             logger.warning("No entities found in database!")
             return []
-        
+
         # Calculate similarities
         results = []
         successful_comparisons = 0
         failed_comparisons = 0
-        
+
         for entity in all_entities:
             try:
                 if entity.embedding is None:
                     logger.warning(f"Entity {entity.id} has no embedding")
                     failed_comparisons += 1
                     continue
-                
+
                 if len(entity.embedding) != len(query_embedding):
-                    logger.warning(f"Entity {entity.id} embedding dimension mismatch: {len(entity.embedding)} vs {len(query_embedding)}")
+                    logger.warning(
+                        f"Entity {entity.id} embedding dimension mismatch: {len(entity.embedding)} vs {len(query_embedding)}"
+                    )
                     failed_comparisons += 1
                     continue
-                
+
                 similarity = self.cosine_similarity(query_embedding, entity.embedding)
                 logger.debug(f"Entity {entity.id} similarity: {similarity:.4f}")
-                
+
                 if similarity >= min_score:
                     results.append(VectorSearchResult(entity, similarity))
-                
+
                 successful_comparisons += 1
-                
+
             except Exception as e:
                 logger.warning(f"Error calculating similarity for entity {entity.id}: {e}")
                 failed_comparisons += 1
                 continue
-        
-        logger.info(f"Similarity calculations: {successful_comparisons} successful, {failed_comparisons} failed")
+
+        logger.info(
+            f"Similarity calculations: {successful_comparisons} successful, {failed_comparisons} failed"
+        )
         logger.info(f"Results above threshold ({min_score}): {len(results)}")
-        
+
         # Sort by similarity score (descending) and return top k
         results.sort(key=lambda x: x.score, reverse=True)
-        
+
         # Log top results
         for i, result in enumerate(results[:5]):
-            logger.info(f"Top result {i+1}: Score {result.score:.4f}, Document: {result.document}")
-        
+            logger.info(f"Top result {i + 1}: Score {result.score:.4f}, Document: {result.document}")
+
         return results[:top_k]
-    
-    def text_search(self, search_term: str, search_field: str = "content", 
-                   case_sensitive: bool = False) -> List[VectorSearchResult]:
+
+    def text_search(
+        self, search_term: str, search_field: str = "content", case_sensitive: bool = False
+    ) -> list[VectorSearchResult]:
         """
         Perform text-based search in document content or names.
-        
+
         Args:
             search_term: Text to search for
             search_field: Field to search in ('content', 'name', 'document')
             case_sensitive: Whether search should be case sensitive
-            
+
         Returns:
             List of VectorSearchResult objects (score = 1.0 for matches)
         """
         logger.info(f"Performing text search for '{search_term}' in field '{search_field}'")
-        
+
         all_entities = self.box.get_all()
         results = []
-        
+
         search_lower = search_term.lower() if not case_sensitive else search_term
-        
+
         for entity in all_entities:
             try:
                 if search_field == "content":
@@ -281,55 +294,55 @@ def text_search(self, search_term: str, search_field: str = "content",
                 else:
                     logger.warning(f"Unknown search field: {search_field}")
                     continue
-                
+
                 if not case_sensitive:
                     field_value = field_value.lower()
-                
+
                 if search_lower in field_value:
                     results.append(VectorSearchResult(entity, 1.0))  # Perfect match score
-                    
+
             except Exception as e:
                 logger.warning(f"Error searching entity {entity.id}: {e}")
                 continue
-        
+
         return results
-    
-    def get_by_document(self, document_name: str) -> List[VectorSearchResult]:
+
+    def get_by_document(self, document_name: str) -> list[VectorSearchResult]:
         """
         Get all chunks from a specific document.
-        
+
         Args:
             document_name: Name of the document
-            
+
         Returns:
             List of VectorSearchResult objects from the document
         """
         logger.info(f"Retrieving all chunks from document: '{document_name}'")
-        
+
         all_entities = self.box.get_all()
         results = []
-        
+
         for entity in all_entities:
             if entity.document == document_name:
                 results.append(VectorSearchResult(entity, 1.0))
-        
+
         # Sort by chunk index if available in metadata
         def get_chunk_index(result):
             try:
-                return result.metadata.get('chunk_index', 0)
+                return result.metadata.get("chunk_index", 0)
             except:
                 return 0
-        
+
         results.sort(key=get_chunk_index)
         return results
-    
-    def get_by_id(self, vector_id: int) -> Optional[VectorSearchResult]:
+
+    def get_by_id(self, vector_id: int) -> VectorSearchResult | None:
         """
         Get a specific vector by its ID.
-        
+
         Args:
             vector_id: ID of the vector entity
-            
+
         Returns:
             VectorSearchResult object or None if not found
         """
@@ -341,35 +354,35 @@ def get_by_id(self, vector_id: int) -> Optional[VectorSearchResult]:
         except Exception as e:
             logger.error(f"Error retrieving vector {vector_id}: {e}")
             return None
-    
-    def get_documents_list(self) -> List[str]:
+
+    def get_documents_list(self) -> list[str]:
         """
         Get a list of all unique document names in the database.
-        
+
         Returns:
             List of document names
         """
         all_entities = self.box.get_all()
         documents = set()
-        
+
         for entity in all_entities:
             documents.add(entity.document)
-        
+
         return sorted(list(documents))
-    
-    def get_database_stats(self) -> Dict[str, Any]:
+
+    def get_database_stats(self) -> dict[str, Any]:
         """Get database statistics."""
         all_entities = self.box.get_all()
         documents = set()
         total_content_length = 0
-        
+
         for entity in all_entities:
             documents.add(entity.document)
             total_content_length += len(entity.content)
-        
+
         # Get entity class name safely
-        entity_class_name = getattr(self.entity_class, '__name__', str(self.entity_class))
-        
+        entity_class_name = getattr(self.entity_class, "__name__", str(self.entity_class))
+
         return {
             "total_vectors": len(all_entities),
             "unique_documents": len(documents),
@@ -377,93 +390,105 @@ def get_database_stats(self) -> Dict[str, Any]:
             "model_name": self.model_name,
             "entity_class": entity_class_name,
             "average_content_length": total_content_length / len(all_entities) if all_entities else 0,
-            "database_path": str(self.database_dir)
+            "database_path": str(self.database_dir),
         }
-    
+
     def close(self):
         """Close the database connection."""
         self.store.close()
 
-def format_results(results: List[VectorSearchResult], max_content_length: int = 200) -> str:
+
+def format_results(results: list[VectorSearchResult], max_content_length: int = 200) -> str:
     """Format search results for display."""
     if not results:
         return "No results found."
-    
+
     output = []
     output.append(f"\nFound {len(results)} results:\n")
     output.append("=" * 80)
-    
+
     for i, result in enumerate(results, 1):
         content_preview = result.content[:max_content_length]
         if len(result.content) > max_content_length:
             content_preview += "..."
-        
+
         metadata_str = ", ".join([f"{k}: {v}" for k, v in result.metadata.items()][:3])
-        
+
         output.append(f"\n{i}. Score: {result.score:.4f} | ID: {result.id}")
         output.append(f"   Document: {result.document}")
         output.append(f"   Name: {result.name}")
         output.append(f"   Content: {content_preview}")
         output.append(f"   Metadata: {metadata_str}")
         output.append("-" * 80)
-    
+
     return "\n".join(output)
 
-def save_results_json(results: List[VectorSearchResult], output_file: str):
+
+def save_results_json(results: list[VectorSearchResult], output_file: str):
     """Save search results to JSON file."""
     results_data = {
         "timestamp": int(time.time() * 1000),
         "total_results": len(results),
-        "results": [result.to_dict() for result in results]
+        "results": [result.to_dict() for result in results],
     }
-    
-    with open(output_file, 'w') as f:
+
+    with open(output_file, "w") as f:
         json.dump(results_data, f, indent=2)
-    
+
     logger.info(f"Results saved to {output_file}")
 
+
 def main():
-    parser = argparse.ArgumentParser(description='Query ObjectBox vector database')
-    parser.add_argument('--database-dir', type=str, required=True,
-                       help='Directory containing the ObjectBox database')
-    parser.add_argument('--query', type=str, help='Text query for similarity search')
-    parser.add_argument('--text-search', type=str, help='Text to search for in content')
-    parser.add_argument('--document', type=str, help='Get all chunks from specific document')
-    parser.add_argument('--vector-id', type=int, help='Get specific vector by ID')
-    parser.add_argument('--list-documents', action='store_true', help='List all documents in database')
-    parser.add_argument('--stats', action='store_true', help='Show database statistics')
-    parser.add_argument('--top-k', type=int, default=10, help='Number of results to return (default: 10)')
-    parser.add_argument('--min-score', type=float, default=0.0, help='Minimum similarity score (default: 0.0)')
-    parser.add_argument('--model', type=str, help='Override embedding model (for query encoding)')
-    parser.add_argument('--output-json', type=str, help='Save results to JSON file')
-    parser.add_argument('--search-field', type=str, default='content', 
-                       choices=['content', 'name', 'document'],
-                       help='Field to search in for text search (default: content)')
-    
-    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
-    parser.add_argument('--list-all', action='store_true', help='List all vectors in database (for debugging)')
-    
+    parser = argparse.ArgumentParser(description="Query ObjectBox vector database")
+    parser.add_argument(
+        "--database-dir", type=str, required=True, help="Directory containing the ObjectBox database"
+    )
+    parser.add_argument("--query", type=str, help="Text query for similarity search")
+    parser.add_argument("--text-search", type=str, help="Text to search for in content")
+    parser.add_argument("--document", type=str, help="Get all chunks from specific document")
+    parser.add_argument("--vector-id", type=int, help="Get specific vector by ID")
+    parser.add_argument("--list-documents", action="store_true", help="List all documents in database")
+    parser.add_argument("--stats", action="store_true", help="Show database statistics")
+    parser.add_argument("--top-k", type=int, default=10, help="Number of results to return (default: 10)")
+    parser.add_argument(
+        "--min-score", type=float, default=0.0, help="Minimum similarity score (default: 0.0)"
+    )
+    parser.add_argument("--model", type=str, help="Override embedding model (for query encoding)")
+    parser.add_argument("--output-json", type=str, help="Save results to JSON file")
+    parser.add_argument(
+        "--search-field",
+        type=str,
+        default="content",
+        choices=["content", "name", "document"],
+        help="Field to search in for text search (default: content)",
+    )
+
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+    parser.add_argument(
+        "--list-all", action="store_true", help="List all vectors in database (for debugging)"
+    )
+
     args = parser.parse_args()
-    
+
     # Set debug logging if requested
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
-    
+
     database_dir = Path(args.database_dir)
     if not database_dir.exists():
         logger.error(f"Database directory not found: {database_dir}")
         return
-    
+
     # Initialize query engine
     try:
         query_engine = ObjectBoxQueryEngine(str(database_dir), args.model)
     except Exception as e:
         logger.error(f"Failed to initialize query engine: {e}")
         return
-    
+
     try:
         results = []
-        
+
         # Database statistics
         if args.stats:
             stats = query_engine.get_database_stats()
@@ -472,18 +497,18 @@ def main():
             for key, value in stats.items():
                 print(f"{key}: {value}")
             return
-        
+
         # List all vectors (debug)
         if args.list_all:
             all_entities = query_engine.box.get_all()
             print(f"\nAll vectors in database ({len(all_entities)} total):")
             print("=" * 80)
             for i, entity in enumerate(all_entities):
-                print(f"\n{i+1}. ID: {entity.id}")
+                print(f"\n{i + 1}. ID: {entity.id}")
                 print(f"   Name: {entity.name}")
                 print(f"   Document: {entity.document}")
                 print(f"   Content: {entity.content[:100]}...")
-                #print(f"   Embedding length: {len(entity.embedding) if entity.embedding else 'None'}")
+                # print(f"   Embedding length: {len(entity.embedding) if entity.embedding else 'None'}")
                 try:
                     metadata = json.loads(entity.metadata) if entity.metadata else {}
                     print(f"   Metadata: {metadata}")
@@ -495,48 +520,49 @@ def main():
                     print(f"... and {len(all_entities) - 11} more")
                     break
             return
-        
+
         # Vector similarity search
         if args.query:
             logger.info(f"Performing vector similarity search for: '{args.query}'")
             results = query_engine.vector_similarity_search(
-                args.query, 
-                top_k=args.top_k, 
-                min_score=args.min_score
+                args.query, top_k=args.top_k, min_score=args.min_score
             )
-        
+
         # Text search
         elif args.text_search:
             logger.info(f"Performing text search for: '{args.text_search}'")
             results = query_engine.text_search(args.text_search, args.search_field)
             # Limit results for text search too
-            results = results[:args.top_k]
-        
+            results = results[: args.top_k]
+
         # Document retrieval
         elif args.document:
             logger.info(f"Retrieving document: '{args.document}'")
             results = query_engine.get_by_document(args.document)
-        
+
         # Get by ID
         elif args.vector_id:
             logger.info(f"Retrieving vector ID: {args.vector_id}")
             result = query_engine.get_by_id(args.vector_id)
             if result:
                 results = [result]
-        
+
         else:
-            print("Please specify a query type: --query, --text-search, --document, --vector-id, --list-documents, or --stats")
+            print(
+                "Please specify a query type: --query, --text-search, --document, --vector-id, --list-documents, or --stats"
+            )
             return
-        
+
         # Display results
         print(format_results(results))
-        
+
         # Save to JSON if requested
         if args.output_json and results:
             save_results_json(results, args.output_json)
-    
+
     finally:
         query_engine.close()
 
+
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/database/vector_entity.py b/src/mobiletransformers/rag/vector_entity.py
similarity index 58%
rename from database/vector_entity.py
rename to src/mobiletransformers/rag/vector_entity.py
index 8ccb72d..f571def 100644
--- a/database/vector_entity.py
+++ b/src/mobiletransformers/rag/vector_entity.py
@@ -4,82 +4,132 @@
 # Auto-generated ObjectBox entities with UIDs from Kotlin
 # Generated from: database/default.json
 
+
 @Entity(uid=3616035618583444316)
 class VectorEntity1024:
     id = Id(id=1, uid=2660901179653327145)
     name = String(id=2, uid=6856925769981232309)
     content = String(id=3, uid=179843414054036048, index=Index(type=IndexType.VALUE, uid=7296155417454871405))
-    embedding = Float32Vector(id=4, uid=369938825836818176, index=HnswIndex(dimensions=1024, distance_type=VectorDistanceType.COSINE))
+    embedding = Float32Vector(
+        id=4,
+        uid=369938825836818176,
+        index=HnswIndex(dimensions=1024, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=4249614817927516900)
     timestamp = Property(int, id=6, uid=5216177833509211649)
     document = String(id=7, uid=8187095563063126218)
 
+
 @Entity(uid=2070669380000345579)
 class VectorEntity128:
     id = Id(id=1, uid=3440642330255188291)
     name = String(id=2, uid=7132069898043676772)
-    content = String(id=3, uid=1078614701445763727, index=Index(type=IndexType.VALUE, uid=1703725148714040606))
-    embedding = Float32Vector(id=4, uid=7560827336622966584, index=HnswIndex(dimensions=128, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=1078614701445763727, index=Index(type=IndexType.VALUE, uid=1703725148714040606)
+    )
+    embedding = Float32Vector(
+        id=4,
+        uid=7560827336622966584,
+        index=HnswIndex(dimensions=128, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=1578594461034605409)
     timestamp = Property(int, id=6, uid=5209582188171579796)
     document = String(id=7, uid=1746313554083619572)
 
+
 @Entity(uid=7000709663387574396)
 class VectorEntity1536:
     id = Id(id=1, uid=5191340093058569025)
     name = String(id=2, uid=5533256385720403749)
-    content = String(id=3, uid=4233813361513752915, index=Index(type=IndexType.VALUE, uid=4136246846239337743))
-    embedding = Float32Vector(id=4, uid=6332384653779176856, index=HnswIndex(dimensions=1536, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=4233813361513752915, index=Index(type=IndexType.VALUE, uid=4136246846239337743)
+    )
+    embedding = Float32Vector(
+        id=4,
+        uid=6332384653779176856,
+        index=HnswIndex(dimensions=1536, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=6594569271998485886)
     timestamp = Property(int, id=6, uid=8326824004865985967)
     document = String(id=7, uid=8395961762390350544)
 
+
 @Entity(uid=5228878220447563421)
 class VectorEntity256:
     id = Id(id=1, uid=3644592590890843602)
     name = String(id=2, uid=1965666759894323807)
-    content = String(id=3, uid=8662363688997292720, index=Index(type=IndexType.VALUE, uid=9111919132284886667))
-    embedding = Float32Vector(id=4, uid=4216566114920401960, index=HnswIndex(dimensions=256, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=8662363688997292720, index=Index(type=IndexType.VALUE, uid=9111919132284886667)
+    )
+    embedding = Float32Vector(
+        id=4,
+        uid=4216566114920401960,
+        index=HnswIndex(dimensions=256, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=1867185820949922463)
     timestamp = Property(int, id=6, uid=4768130956928245718)
     document = String(id=7, uid=4421787786747795333)
 
+
 @Entity(uid=5759397291334530001)
 class VectorEntity384:
     id = Id(id=1, uid=3995752191779281531)
     name = String(id=2, uid=8429658584629108761)
-    content = String(id=3, uid=7177388378640589383, index=Index(type=IndexType.VALUE, uid=5351510252118108820))
-    embedding = Float32Vector(id=4, uid=7475465692145108710, index=HnswIndex(dimensions=384, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=7177388378640589383, index=Index(type=IndexType.VALUE, uid=5351510252118108820)
+    )
+    embedding = Float32Vector(
+        id=4,
+        uid=7475465692145108710,
+        index=HnswIndex(dimensions=384, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=693547862910235008)
     timestamp = Property(int, id=6, uid=8172946629643359289)
     document = String(id=7, uid=7209720699072026712)
 
+
 @Entity(uid=5741478164101520808)
 class VectorEntity512:
     id = Id(id=1, uid=2928259287888584009)
     name = String(id=2, uid=3586580055118903977)
-    content = String(id=3, uid=3705505580070095385, index=Index(type=IndexType.VALUE, uid=2382896421061802420))
-    embedding = Float32Vector(id=4, uid=8704612602687791410, index=HnswIndex(dimensions=512, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=3705505580070095385, index=Index(type=IndexType.VALUE, uid=2382896421061802420)
+    )
+    embedding = Float32Vector(
+        id=4,
+        uid=8704612602687791410,
+        index=HnswIndex(dimensions=512, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=1811001360407727355)
     timestamp = Property(int, id=6, uid=8246025844161259468)
     document = String(id=7, uid=2415562500626563670)
 
+
 @Entity(uid=5652731347474038494)
 class VectorEntity64:
     id = Id(id=1, uid=8122553010226434725)
     name = String(id=2, uid=2970097330866361593)
-    content = String(id=3, uid=3234213945405272885, index=Index(type=IndexType.VALUE, uid=7169805229422572048))
-    embedding = Float32Vector(id=4, uid=1702504652196090376, index=HnswIndex(dimensions=64, distance_type=VectorDistanceType.COSINE))
+    content = String(
+        id=3, uid=3234213945405272885, index=Index(type=IndexType.VALUE, uid=7169805229422572048)
+    )
+    embedding = Float32Vector(
+        id=4, uid=1702504652196090376, index=HnswIndex(dimensions=64, distance_type=VectorDistanceType.COSINE)
+    )
     metadata = String(id=5, uid=1325344924173597267)
     timestamp = Property(int, id=6, uid=8447383474601691598)
     document = String(id=7, uid=8146090976975030625)
 
+
 @Entity(uid=1398842727202970551)
 class VectorEntity768:
     id = Id(id=1, uid=1573037040010322675)
     name = String(id=2, uid=1875010556206429126)
     content = String(id=3, uid=4026475639719700418, index=Index(type=IndexType.VALUE, uid=443802177034598622))
-    embedding = Float32Vector(id=4, uid=7215409883456044223, index=HnswIndex(dimensions=768, distance_type=VectorDistanceType.COSINE))
+    embedding = Float32Vector(
+        id=4,
+        uid=7215409883456044223,
+        index=HnswIndex(dimensions=768, distance_type=VectorDistanceType.COSINE),
+    )
     metadata = String(id=5, uid=5797340244742986745)
     timestamp = Property(int, id=6, uid=5763104868674049307)
     document = String(id=7, uid=7290423554697741641)
diff --git a/src/mobiletransformers/support/__init__.py b/src/mobiletransformers/support/__init__.py
new file mode 100644
index 0000000..26cafca
--- /dev/null
+++ b/src/mobiletransformers/support/__init__.py
@@ -0,0 +1 @@
+"""Support matrix (#20): candidate readiness reporting over the export pipeline."""
diff --git a/src/mobiletransformers/support/matrix.py b/src/mobiletransformers/support/matrix.py
new file mode 100644
index 0000000..5fa4f3b
--- /dev/null
+++ b/src/mobiletransformers/support/matrix.py
@@ -0,0 +1,205 @@
+"""Support-matrix generator (#20) — detect candidates, evaluate inherited statuses, emit the matrix.
+
+Reporting layer over #7's task discovery. Detection deps (transformers ``AutoConfig``, optimum
+``TasksManager``) are injectable so the generator is testable with no network; the real loaders are
+lazy-imported. The three ``android_*``/``rag`` statuses are read from a probe-results file the device/CI
+instrumentation writes — absent probes leave those statuses honestly ``false`` with a blocker. The
+generator never runs a device itself.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+from mobiletransformers.config.registry.architecture import resolve_architecture
+from mobiletransformers.exceptions import UnsupportedModelError
+from mobiletransformers.support.models import CandidateEntry, SupportMatrix
+from mobiletransformers.support.statuses import SupportStatus, apply_inheritance, first_blocked
+
+#: Task auto-select priority (kept in sync with export/registry.choose_task).
+_TASK_PRIORITY = ("text-generation-with-past", "text-generation", "feature-extraction", "sentence-similarity")
+
+ConfigLoader = Callable[[str, bool], Any]
+TasksLookup = Callable[[str], list[str]]
+
+
+def _default_config_loader(model_id: str, trust_remote_code: bool) -> Any:
+    from transformers import AutoConfig  # lazy: transformers is an export-profile dep
+
+    return AutoConfig.from_pretrained(model_id, trust_remote_code=trust_remote_code)
+
+
+def _default_tasks_lookup(model_type: str) -> list[str]:
+    from optimum.exporters.tasks import TasksManager  # lazy: optimum is an export-profile dep
+
+    return list(TasksManager.get_supported_tasks_for_model_type(model_type, "onnx"))
+
+
+def _default_versions() -> dict[str, str | None]:
+    from importlib.metadata import PackageNotFoundError, version
+
+    def _v(name: str) -> str | None:
+        try:
+            return version(name)
+        except PackageNotFoundError:
+            return None
+
+    return {"optimumOnnxVersion": _v("optimum-onnx"), "transformersVersion": _v("transformers")}
+
+
+def _select_task(supported: list[str], requested: str | None) -> str | None:
+    if requested:
+        return requested if requested in supported else None
+    for task in _TASK_PRIORITY:
+        if task in supported:
+            return task
+    return None
+
+
+def _mars_target_modules_known(architectures: tuple[str, ...]) -> bool:
+    if not architectures:
+        return False
+    try:
+        spec = resolve_architecture(SimpleNamespace(architectures=list(architectures)))
+    except UnsupportedModelError:
+        return False
+    return bool(spec.target_modules)
+
+
+def detect_candidate(
+    model_id: str,
+    *,
+    requested_task: str | None = None,
+    trust_remote_code: bool = False,
+    opset: int = 20,
+    config_loader: ConfigLoader | None = None,
+    tasks_lookup: TasksLookup | None = None,
+    versions: dict[str, str | None] | None = None,
+) -> CandidateEntry:
+    """Detect one candidate model's export capabilities (no status inheritance applied yet)."""
+    config_loader = config_loader or _default_config_loader
+    tasks_lookup = tasks_lookup or _default_tasks_lookup
+    versions = versions if versions is not None else _default_versions()
+
+    config = config_loader(model_id, trust_remote_code)
+    model_type = getattr(config, "model_type", None)
+    architectures = tuple(getattr(config, "architectures", ()) or ())
+    supported = tasks_lookup(model_type) if model_type else []
+    selected = _select_task(supported, requested_task)
+    return CandidateEntry(
+        model_id=model_id,
+        model_type=model_type,
+        architectures=architectures,
+        optimum_onnx_version=versions.get("optimumOnnxVersion"),
+        transformers_version=versions.get("transformersVersion"),
+        opset=opset,
+        supported_tasks=tuple(supported),
+        selected_task=selected,
+        trust_remote_code=trust_remote_code,
+        mars_target_modules_known=_mars_target_modules_known(architectures),
+    )
+
+
+def evaluate_statuses(entry: CandidateEntry, probe: dict[str, bool] | None) -> CandidateEntry:
+    """Fill ``entry.statuses`` (with inheritance) + ``entry.blockers`` from detection + a probe row."""
+    raw = {
+        SupportStatus.OPTIMUM_EXPORTABLE.value: entry.selected_task is not None,
+        # Package export is a dry-run normalization; proxied by exportability of a usable task here.
+        SupportStatus.MOBILE_PACKAGE_EXPORTABLE.value: entry.selected_task is not None,
+        SupportStatus.TRAIN_ARTIFACTS_EXPORTABLE.value: entry.mars_target_modules_known,
+        SupportStatus.ANDROID_INFERENCE_READY.value: bool(probe and probe.get("inferenceOk")),
+        SupportStatus.ANDROID_TRAINING_READY.value: bool(
+            probe and probe.get("trainStepOk") and probe.get("mergeOk")
+        ),
+        SupportStatus.RAG_READY.value: bool(probe and probe.get("ragOk")),
+    }
+    entry.statuses = apply_inheritance(raw)
+    blockers: list[str] = []
+    blocked = first_blocked(entry.statuses)
+    if blocked == SupportStatus.OPTIMUM_EXPORTABLE.value:
+        blockers.append("no supported ONNX task for this model type")
+    elif blocked == SupportStatus.TRAIN_ARTIFACTS_EXPORTABLE.value:
+        blockers.append("MARS/PEFT target modules not verified for this architecture")
+    elif blocked in {
+        SupportStatus.ANDROID_INFERENCE_READY.value,
+        SupportStatus.ANDROID_TRAINING_READY.value,
+        SupportStatus.RAG_READY.value,
+    }:
+        blockers.append(f"no android probe recorded for {blocked}")
+    entry.blockers = blockers
+    return entry
+
+
+def ingest_probes(path: str | Path | None) -> dict[str, dict[str, bool]]:
+    """Read ``android_probes.json`` (``{modelId: {inferenceOk, trainStepOk, mergeOk, ragOk}}``).
+
+    Missing file -> empty (all ready statuses fall to ``false`` with a blocker, honestly)."""
+    if path is None:
+        return {}
+    p = Path(path)
+    if not p.is_file():
+        return {}
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+def build_matrix(
+    candidates: list[dict[str, Any] | str],
+    *,
+    probes_path: str | Path | None = None,
+    generated_at: str | None = None,
+    config_loader: ConfigLoader | None = None,
+    tasks_lookup: TasksLookup | None = None,
+    versions: dict[str, str | None] | None = None,
+) -> SupportMatrix:
+    """Detect + evaluate every candidate into a :class:`SupportMatrix`.
+
+    ``candidates`` items are either a model-id string or a dict
+    ``{modelId, task?, trustRemoteCode?, opset?}``.
+    """
+    probes = ingest_probes(probes_path)
+    versions = versions if versions is not None else _default_versions()
+    entries: list[CandidateEntry] = []
+    for cand in candidates:
+        spec = {"modelId": cand} if isinstance(cand, str) else dict(cand)
+        entry = detect_candidate(
+            spec["modelId"],
+            requested_task=spec.get("task"),
+            trust_remote_code=bool(spec.get("trustRemoteCode", False)),
+            opset=int(spec.get("opset", 20)),
+            config_loader=config_loader,
+            tasks_lookup=tasks_lookup,
+            versions=versions,
+        )
+        evaluate_statuses(entry, probes.get(entry.model_id))
+        entries.append(entry)
+    return SupportMatrix(models=entries, generated_at=generated_at, toolchain=dict(versions))
+
+
+def write_matrix(matrix: SupportMatrix, path: str | Path) -> Path:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(matrix.to_json(), encoding="utf-8")
+    return path
+
+
+def write_filtered_docs(matrix: SupportMatrix, path: str | Path) -> Path:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(matrix.filtered_docs_dict(), indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    return path
+
+
+__all__ = [
+    "detect_candidate",
+    "evaluate_statuses",
+    "ingest_probes",
+    "build_matrix",
+    "write_matrix",
+    "write_filtered_docs",
+]
diff --git a/src/mobiletransformers/support/models.py b/src/mobiletransformers/support/models.py
new file mode 100644
index 0000000..268ed9a
--- /dev/null
+++ b/src/mobiletransformers/support/models.py
@@ -0,0 +1,94 @@
+"""Support-matrix dataclasses + the canonical (list-shaped) JSON envelope (#20 owns this schema).
+
+Reconciles #7's seed-row shape (``export/support_matrix.py``, a dict keyed by model id, with
+``chosenTask``/``blocker``) into the #20 contract: ``models`` is a *list*, task is ``selectedTask``,
+blockers are a ``blockers[]`` list, and each row carries the full six-status map.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from mobiletransformers.support.statuses import STATUS_ORDER, USER_FACING_STATUSES
+
+SCHEMA_VERSION = "1.0"
+MIN_READER_VERSION = "1.0"
+TRANSFORMERS_CEILING = "<4.58"
+
+
+@dataclass
+class CandidateEntry:
+    model_id: str
+    model_type: str | None = None
+    architectures: tuple[str, ...] = ()
+    optimum_onnx_version: str | None = None
+    transformers_version: str | None = None
+    opset: int = 20
+    supported_tasks: tuple[str, ...] = ()
+    selected_task: str | None = None
+    trust_remote_code: bool = False
+    mars_target_modules_known: bool = False
+    statuses: dict[str, bool] = field(default_factory=dict)
+    blockers: list[str] = field(default_factory=list)
+
+    def to_row(self) -> dict[str, Any]:
+        """The per-model wire row (camelCase, list-shaped) for ``model_support_matrix.json``."""
+        return {
+            "modelId": self.model_id,
+            "modelType": self.model_type,
+            "architectures": list(self.architectures),
+            "optimumOnnxVersion": self.optimum_onnx_version,
+            "transformersVersion": self.transformers_version,
+            "opset": self.opset,
+            "supportedTasks": list(self.supported_tasks),
+            "selectedTask": self.selected_task,
+            "trustRemoteCode": self.trust_remote_code,
+            "marsTargetModulesKnown": self.mars_target_modules_known,
+            "statuses": {k: bool(self.statuses.get(k, False)) for k in STATUS_ORDER},
+            "blockers": list(self.blockers),
+        }
+
+
+@dataclass
+class SupportMatrix:
+    models: list[CandidateEntry]
+    generated_at: str | None = None
+    toolchain: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schemaVersion": SCHEMA_VERSION,
+            "minReaderVersion": MIN_READER_VERSION,
+            "generatedAt": self.generated_at or "",
+            "toolchain": {"transformersCeiling": TRANSFORMERS_CEILING, **self.toolchain},
+            "statusOrder": list(STATUS_ORDER),
+            "userFacingStatuses": sorted(USER_FACING_STATUSES),
+            "models": [m.to_row() for m in self.models],
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
+
+    def filtered_docs_dict(self) -> dict[str, Any]:
+        """User-facing view: only models with ≥1 user-facing status true; strip contributor-only
+        (non-user-facing) statuses from each row."""
+        d = self.to_dict()
+        kept = []
+        for row in d["models"]:
+            if any(row["statuses"].get(s) for s in USER_FACING_STATUSES):
+                row = dict(row)
+                row["statuses"] = {s: row["statuses"][s] for s in sorted(USER_FACING_STATUSES)}
+                kept.append(row)
+        d["models"] = kept
+        return d
+
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "MIN_READER_VERSION",
+    "TRANSFORMERS_CEILING",
+    "CandidateEntry",
+    "SupportMatrix",
+]
diff --git a/src/mobiletransformers/support/render.py b/src/mobiletransformers/support/render.py
new file mode 100644
index 0000000..f7f4701
--- /dev/null
+++ b/src/mobiletransformers/support/render.py
@@ -0,0 +1,83 @@
+"""Render a :class:`SupportMatrix` into ``docs/COMPATIBILITY_MATRIX.md`` (#31, F6).
+
+The matrix (``model_support_matrix.json``) is the generated source of truth; the docs page is
+**rendered from it**, never hand-maintained. Axis legends are enumerated from the #6 enums/registries so
+they cannot drift from the code. A row's "evidence" is its recorded blockers (or ✅ when fully ready).
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.config.constants import MergerVariant, PEFTMethod, QuantizationType
+from mobiletransformers.support.models import SupportMatrix
+from mobiletransformers.support.statuses import STATUS_ORDER
+
+#: Canonical engines: native is the guaranteed path, genai is opt-in.
+_ENGINES = ("native", "genai")
+
+_STATUS_HEADERS = {
+    "optimum_exportable": "Optimum export",
+    "mobile_package_exportable": "Package",
+    "train_artifacts_exportable": "Train artifacts",
+    "android_inference_ready": "Android inference",
+    "android_training_ready": "Android training",
+    "rag_ready": "RAG",
+}
+
+
+def _tick(value: bool) -> str:
+    return "✅" if value else "❌"
+
+
+def _legend() -> list[str]:
+    lines = [
+        "## Axes (enumerated from the registries/enums — not hand-maintained)",
+        "",
+        f"- **PEFT method:** {', '.join(m.value for m in PEFTMethod)}",
+        f"- **Quantization:** {', '.join(q.value for q in QuantizationType)}",
+        f"- **Merger variant:** {', '.join(v.value for v in MergerVariant)}",
+        f"- **Engine:** {', '.join(_ENGINES)} (native is the guaranteed path; genai is opt-in)",
+        "- **Status pipeline (each implies all earlier ones):** "
+        + " → ".join(_STATUS_HEADERS[s] for s in STATUS_ORDER),
+        "",
+    ]
+    return lines
+
+
+def render_matrix_markdown(matrix: SupportMatrix) -> str:
+    """Render `matrix` into the COMPATIBILITY_MATRIX.md markdown body (deterministic)."""
+    out: list[str] = []
+    out.append("# Compatibility Matrix")
+    out.append("")
+    out.append(
+        "> **Generated** — rendered from `model_support_matrix.json`. Do not hand-edit. "
+        "Regenerate with `mobiletransformers support-matrix --md docs/COMPATIBILITY_MATRIX.md` "
+        "under the `export` profile (live detection needs transformers + optimum)."
+    )
+    out.append("")
+    stamp = matrix.generated_at or "(unstamped)"
+    tool = matrix.toolchain or {}
+    tool_str = ", ".join(f"{k}={v}" for k, v in sorted(tool.items())) or "n/a"
+    out.append(f"- Generated at: `{stamp}`")
+    out.append(f"- Toolchain: {tool_str}")
+    out.append("")
+    out.extend(_legend())
+
+    headers = ["Model", "Type", "Task", *(_STATUS_HEADERS[s] for s in STATUS_ORDER), "Evidence / blockers"]
+    out.append("| " + " | ".join(headers) + " |")
+    out.append("| " + " | ".join(["---"] * len(headers)) + " |")
+    for entry in matrix.models:
+        row = entry.to_row()
+        statuses = row["statuses"]
+        cells = [
+            f"`{row['modelId']}`",
+            row["modelType"] or "?",
+            row["selectedTask"] or "—",
+            *(_tick(bool(statuses.get(s, False))) for s in STATUS_ORDER),
+            "; ".join(row["blockers"]) if row["blockers"] else "fully ready",
+        ]
+        out.append("| " + " | ".join(cells) + " |")
+    out.append("")
+    return "\n".join(out) + "\n"
+
+
+__all__ = ["render_matrix_markdown"]
diff --git a/src/mobiletransformers/support/statuses.py b/src/mobiletransformers/support/statuses.py
new file mode 100644
index 0000000..e723690
--- /dev/null
+++ b/src/mobiletransformers/support/statuses.py
@@ -0,0 +1,67 @@
+"""Ordered readiness statuses + inheritance for the support matrix (#20).
+
+Six statuses along the readiness pipeline; each *implies* all earlier ones. The moment one is false,
+every later status is forced false and a blocker is recorded — so a row can never claim it trains on a
+device it cannot even export.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class SupportStatus(str, Enum):
+    OPTIMUM_EXPORTABLE = "optimum_exportable"
+    MOBILE_PACKAGE_EXPORTABLE = "mobile_package_exportable"
+    TRAIN_ARTIFACTS_EXPORTABLE = "train_artifacts_exportable"
+    ANDROID_INFERENCE_READY = "android_inference_ready"
+    ANDROID_TRAINING_READY = "android_training_ready"
+    RAG_READY = "rag_ready"
+
+
+#: Canonical order; a later status may only be true if every earlier one is true.
+STATUS_ORDER: tuple[str, ...] = tuple(s.value for s in SupportStatus)
+
+#: Statuses that surface in user-facing starter-zoo docs (earlier ones are contributor-only).
+USER_FACING_STATUSES: frozenset[str] = frozenset(
+    {
+        SupportStatus.ANDROID_INFERENCE_READY.value,
+        SupportStatus.ANDROID_TRAINING_READY.value,
+        SupportStatus.RAG_READY.value,
+    }
+)
+
+
+def apply_inheritance(statuses: dict[str, bool]) -> dict[str, bool]:
+    """Return a copy where every status after the first ``false`` is forced ``false``.
+
+    Missing keys default to ``false``. The result always has all six keys in ``STATUS_ORDER``.
+    """
+    result: dict[str, bool] = {}
+    blocked = False
+    for key in STATUS_ORDER:
+        if blocked:
+            result[key] = False
+            continue
+        value = bool(statuses.get(key, False))
+        result[key] = value
+        if not value:
+            blocked = True
+    return result
+
+
+def first_blocked(statuses: dict[str, bool]) -> str | None:
+    """Name of the earliest status that is ``false`` (the first blocker), or ``None`` if all true."""
+    for key in STATUS_ORDER:
+        if not statuses.get(key, False):
+            return key
+    return None
+
+
+__all__ = [
+    "SupportStatus",
+    "STATUS_ORDER",
+    "USER_FACING_STATUSES",
+    "apply_inheritance",
+    "first_blocked",
+]
diff --git a/src/mobiletransformers/training/__init__.py b/src/mobiletransformers/training/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mobiletransformers/training/benchmark_datasets.py b/src/mobiletransformers/training/benchmark_datasets.py
new file mode 100644
index 0000000..4d84af2
--- /dev/null
+++ b/src/mobiletransformers/training/benchmark_datasets.py
@@ -0,0 +1,58 @@
+"""The PEFT benchmark dataset registry: task name -> (HF dataset id, preprocessor id[, config name]).
+
+Migration Map S6b side-effect. This lived in ``research/offline_train_eval.py``, but
+``training/validators.py`` — now a packaged module — depends on it. A packaged module importing
+``research.`` works from a checkout and fails from an installed wheel, so the data moved rather than
+the import being allow-listed. ``research/offline_train_eval.py`` re-exports both names.
+
+Not to be confused with :data:`mobiletransformers.config.constants.TASK_NAME_TO_DATASET`, which maps
+the *export/training CLI's* task names. This one is keyed by the PEFT benchmark suite's own task ids
+and additionally carries the preprocessor id each dataset needs.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class PEFTBenchmarkDataset(Enum):
+    """Datasets the PEFT benchmark suite trains and evaluates against."""
+
+    # Easy tasks
+    BOOLQ = "boolq"
+    ARC_E = "arc_e"
+    LOGIQA = "logiqa"
+    WINOGRANDE = "winogrande"
+
+    # Complex tasks
+    HELLASWAG = "hellaswag"
+    ARC_C = "arc_c"
+
+    # Mobile tasks
+    MINI_PERSONALQA = "mini_personalqa"
+    MINI_RECOMMENDATION = "mini_recommendation"
+
+
+#: ``task -> (dataset_id, preprocess_id)`` or ``(dataset_id, preprocess_id, dataset_config_name)``.
+#: The 3-tuple form selects a named config within a multi-config HF dataset (ai2_arc's Easy/Challenge
+#: splits, winogrande's size variants); consumers must handle both arities.
+DATASET_MAPPING: dict[str, tuple[str, ...]] = {
+    # Easy tasks
+    PEFTBenchmarkDataset.BOOLQ.value: ("google/boolq", "boolq_train_deepeval"),
+    PEFTBenchmarkDataset.WINOGRANDE.value: (
+        "allenai/winogrande",
+        "winogrande_train_deepeval",
+        "winogrande_l",
+    ),
+    PEFTBenchmarkDataset.ARC_E.value: ("allenai/ai2_arc", "arc_train_deepeval", "ARC-Easy"),
+    PEFTBenchmarkDataset.LOGIQA.value: ("data/logiqa_train", "logiqa_train_deepeval"),
+    # Complex tasks
+    PEFTBenchmarkDataset.HELLASWAG.value: ("Rowan/hellaswag", "hellaswag_train_deepeval"),
+    PEFTBenchmarkDataset.ARC_C.value: ("allenai/ai2_arc", "arc_train_deepeval", "ARC-Challenge"),
+    # Mobile tasks
+    PEFTBenchmarkDataset.MINI_PERSONALQA.value: ("data/MiniPersonalQA_train", "mini_personalqa"),
+    PEFTBenchmarkDataset.MINI_RECOMMENDATION.value: (
+        "data/MiniRecommendation_train",
+        "mini_recommendation",
+    ),
+}
diff --git a/src/mobiletransformers/training/callbacks.py b/src/mobiletransformers/training/callbacks.py
new file mode 100644
index 0000000..03f1619
--- /dev/null
+++ b/src/mobiletransformers/training/callbacks.py
@@ -0,0 +1,59 @@
+"""HuggingFace ``Trainer`` callbacks.
+
+Migrated from ``tools/utils.py`` (Migration Map S1).
+
+``transformers`` is imported at module level because ``MemoryLoggerCallback`` SUBCLASSES
+``TrainerCallback`` — a base class must exist when the class body is evaluated, so there is no honest
+way to defer it. This module is therefore importable only under the ``train`` profile, and nothing in
+the package imports it eagerly (``tests/unit/test_import_weight.py`` guards the top-level import).
+torch/psutil stay function-local since those are only used inside the methods.
+"""
+
+from __future__ import annotations
+
+from transformers import TrainerCallback
+
+
+class MemoryLoggerCallback(TrainerCallback):
+    def __init__(self):
+        super().__init__()
+        self.pre_backward_memory = {}
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        import psutil  # noqa: PLC0415
+        import torch  # noqa: PLC0415
+
+        if torch.cuda.is_available():
+            # Log GPU memory usage
+            allocated = torch.cuda.memory_allocated() / 1024**2  # Convert to MB
+            reserved = torch.cuda.memory_reserved() / 1024**2  # Convert to MB
+            logs["gpu_memory_allocated_MB"] = allocated
+            logs["gpu_memory_reserved_MB"] = reserved
+
+            # Log memory usage before backward pass
+            if self.pre_backward_memory:
+                logs["gpu_memory_allocated_MB_pre_bp"] = self.pre_backward_memory[
+                    "gpu_memory_allocated_MB_pre_bp"
+                ]
+        else:
+            # Log CPU memory usage using psutil
+            mem = psutil.virtual_memory()
+            logs["cpu_memory_used_MB"] = mem.used / 1024**2  # Convert to MB
+            # Log memory usage before backward pass
+            if self.pre_backward_memory:
+                logs["cpu_memory_used_MB_pre_bp"] = self.pre_backward_memory["cpu_memory_used_MB_pre_bp"]
+
+    def on_optimizer_step(self, args, state, control, **kwargs):
+        import psutil  # noqa: PLC0415
+        import torch  # noqa: PLC0415
+
+        if torch.cuda.is_available():
+            # Log GPU memory usage
+            allocated = torch.cuda.memory_allocated() / 1024**2  # Convert to MB
+            # reserved = torch.cuda.memory_reserved() / 1024**2  # Convert to MB
+            self.pre_backward_memory["gpu_memory_allocated_MB_pre_bp"] = allocated
+            # self.pre_backward_memory["gpu_memory_reserved_MB_pre_bs"] = reserved
+        else:
+            # Log CPU memory usage using psutil
+            mem = psutil.virtual_memory()
+            self.pre_backward_memory["cpu_memory_used_MB_pre_bp"] = mem.used / 1024**2  # Convert to MB
diff --git a/src/mobiletransformers/training/data.py b/src/mobiletransformers/training/data.py
new file mode 100644
index 0000000..85482d7
--- /dev/null
+++ b/src/mobiletransformers/training/data.py
@@ -0,0 +1,175 @@
+"""Dataset loading/trimming/serialization for training.
+
+Migrated from ``tools/utils.py`` (Migration Map S1). ``datasets`` is imported lazily so importing the
+package (and the CLI) stays cheap in the core environment — see ``tests/unit/test_import_weight.py``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+
+def load_and_save_dataset(
+    dataset_name,
+    save_path=None,
+    train_file="train_dataset",
+    split=None,
+    save_format="jsonl",
+    max_dataset_length=None,
+):
+    from datasets import DatasetDict  # noqa: PLC0415
+
+    """
+    Load a dataset from Hugging Face Hub and save it locally.
+    
+    Args:
+        dataset_name (str): Name of the dataset on Hugging Face Hub
+        save_path (str, optional): Local path to save the dataset. 
+                                 If None, saves to './datasets/{dataset_name}'
+        config_name (str, optional): Configuration name for datasets with multiple configs
+        split (str, optional): Specific split to load ('train', 'test', 'validation', etc.)
+        **kwargs: Additional arguments to pass to load_dataset()
+    
+    Returns:
+        datasets.Dataset or datasets.DatasetDict: The loaded dataset
+    """
+    try:
+        # Load the dataset
+        dataset = preload_dataset(dataset_name, split)
+
+        if type(dataset) == DatasetDict:
+            dataset = dataset[split]
+
+        # Set default save path if not provided
+        if save_path is None:
+            save_path = f"./datasets/{dataset_name.replace('/', '_')}"
+
+        # Trim dataset if max_dataset_length is specified
+        if max_dataset_length is not None:
+            dataset = trim_dataset(dataset, max_dataset_length)
+
+        # Save the dataset based on format
+        if save_format.lower() == "jsonl":
+            save_as_jsonl(dataset, save_path, train_file)
+        else:
+            # Default HuggingFace format
+            print(f"Saving dataset to: {save_path}")
+            dataset.save_to_disk(save_path)
+            print(f"Dataset successfully saved to {save_path}")
+        return dataset
+
+    except Exception as e:
+        print(f"Error loading or saving dataset: {str(e)}")
+        return None
+
+
+def trim_dataset(dataset, max_length):
+    """
+    Trim dataset to maximum number of examples.
+
+    Args:
+        dataset: Dataset or DatasetDict to trim
+        max_length (int): Maximum number of examples to keep
+
+    Returns:
+        Trimmed dataset
+    """
+    from datasets import Dataset, DatasetDict
+
+    if isinstance(dataset, DatasetDict):
+        # Handle DatasetDict (multiple splits)
+        trimmed_dict = {}
+        for split_name, split_dataset in dataset.items():
+            original_length = len(split_dataset)
+            if original_length > max_length:
+                trimmed_dict[split_name] = split_dataset.select(range(max_length))
+                print(f"Trimmed {split_name} split from {original_length} to {max_length} examples")
+            else:
+                trimmed_dict[split_name] = split_dataset
+                print(f"Kept {split_name} split unchanged ({original_length} examples)")
+        return DatasetDict(trimmed_dict)
+
+    elif isinstance(dataset, Dataset):
+        # Handle single Dataset
+        original_length = len(dataset)
+        if original_length > max_length:
+            trimmed_dataset = dataset.select(range(max_length))
+            print(f"Trimmed dataset from {original_length} to {max_length} examples")
+            return trimmed_dataset
+        else:
+            print(f"Dataset unchanged ({original_length} examples)")
+            return dataset
+
+    return dataset
+
+
+def save_as_jsonl(dataset, save_path, dataset_name):
+    """
+    Save dataset as JSONL (JSON Lines) format.
+
+    Args:
+        dataset: The dataset to save
+        save_path (str): Directory path to save the files
+        dataset_name (str): Name of the dataset for file naming
+    """
+    from datasets import Dataset, DatasetDict  # noqa: PLC0415
+
+    if isinstance(dataset, DatasetDict):
+        # Handle DatasetDict (multiple splits)
+        for split_name, split_dataset in dataset.items():
+            print(f"Saving {split_name} split to: {save_path}_{split_name}.jsonl")
+
+            with open(f"{save_path}_{split_name}.jsonl", "w", encoding="utf-8") as f:
+                for example in split_dataset:
+                    f.write(json.dumps(example, ensure_ascii=False) + "\n")
+
+    elif isinstance(dataset, Dataset):
+        # Handle single Dataset
+        file_path = os.path.join(save_path, f"{dataset_name}.jsonl")
+
+        print(f"Saving dataset to: {file_path}")
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            for example in dataset:
+                f.write(json.dumps(example, ensure_ascii=False) + "\n")
+
+    print(f"Dataset successfully saved as JSONL format to {save_path}")
+
+
+def preload_dataset(dataset_id, dataset_name=None, split=None):
+    from datasets import Dataset, DatasetDict, load_dataset  # noqa: PLC0415
+
+    dataset_ids = dataset_id.split("/")
+
+    # Take local data
+    if len(dataset_ids) >= 2 and dataset_ids[-2] == "data":
+        filepath = dataset_id
+        data = None
+
+        if os.path.exists(f"./{dataset_id}.json"):
+            filepath = f"./{dataset_id}.json"
+
+            with open(filepath, encoding="utf-8") as f:
+                data = json.load(f)
+
+        elif os.path.exists(f"./{dataset_id}.jsonl"):
+            filepath = f"./{dataset_id}.jsonl"
+
+            with open(filepath, encoding="utf-8") as f:
+                data = [json.loads(line) for line in f]
+
+        # Convert to Hugging Face Dataset
+        dataset = Dataset.from_list(data)
+        empty_test = dataset.select([])
+
+        # Create a DatasetDict with the "train" split
+        dataset_dict = DatasetDict({"train": dataset, "test": empty_test})
+
+        return dataset_dict
+    ds = load_dataset(dataset_id, dataset_name, split=split)
+
+    empty_test = ds["train"].select([])
+
+    ds["test"] = empty_test
+    return ds
diff --git a/trainer/merge_validator.py b/src/mobiletransformers/training/merge_validators.py
similarity index 73%
rename from trainer/merge_validator.py
rename to src/mobiletransformers/training/merge_validators.py
index 0d2b262..e851a66 100644
--- a/trainer/merge_validator.py
+++ b/src/mobiletransformers/training/merge_validators.py
@@ -1,40 +1,38 @@
-
 import argparse
-import os
-import textwrap
-from typing import Dict, List
-import yaml
-from tools.parser_config import ARTIFACT_CONFIG, ARTIFACT_VALIDATOR_CONFIG, TASK_NAME_TO_DATASET, TRAIN_CONFIG
-from tools.utils import preload_dataset
-from trainer.utils import taskname_to_deepeval_preprocess_function
-from trainer.validator import ORTDataCurator, ORTTrainer, ORTTrainingArguments
 import json
-import numpy as np
-from typing import Dict, Any
 import os
-from onnx import numpy_helper
+import textwrap
+from typing import Any
 
-import json
 import numpy as np
-import os
 import onnxruntime as ort
 
+from mobiletransformers.artifacts.checkpoint_names import to_checkpoint_name
+from mobiletransformers.config.constants import (
+    ARTIFACT_CONFIG,
+    ARTIFACT_VALIDATOR_CONFIG,
+    TRAIN_CONFIG,
+)
+from mobiletransformers.training.validators import ORTTrainer
+from mobiletransformers.utils.yaml import load_config_from_file
+
+
 class PEFTMergeValidator:
     """
     A validator for merging PEFT adapters into quantized base layers in ONNX Runtime.
     """
-    
+
     def __init__(self, trainer: ORTTrainer, training_artifact_dir: str):
         """
         Initialize the PEFT merge validator.
-        
+
         Args:
             trainer: ORTTrainer instance with checkpoint state
             training_config_path: Path to training_config.json containing peft_mapping
         """
         self.trainer = trainer
         self.training_artifact_dir = training_artifact_dir
-        self.training_config_path = os.path.join(training_artifact_dir, 'training_config.json')
+        self.training_config_path = os.path.join(training_artifact_dir, "training_config.json")
         self.peft_mapping = None
         self.config = {}
         self.base_layer_params = {}
@@ -43,23 +41,23 @@ def __init__(self, trainer: ORTTrainer, training_artifact_dir: str):
         self.output_adapter_parameters = {}
 
         self.merger_models = {}
-        
+
         self.peft_method = None
 
         # Load the training configuration
         self._load_training_config()
-        
+
         # Extract parameters from checkpoint
         self._extract_parameters()
 
         self._build_merger_models()
-    
+
     def _load_training_config(self):
         """Load the training configuration containing PEFT mapping."""
         try:
-            with open(self.training_config_path, 'r') as f:
+            with open(self.training_config_path) as f:
                 self.config = json.load(f)
-                self.peft_mapping = self.config.get('peft_mapping', {})
+                self.peft_mapping = self.config.get("peft_mapping", {})
 
                 self.peft_method = self.config["peftMethod"]
 
@@ -68,8 +66,7 @@ def _load_training_config(self):
 
                 # get all .onnx files ending with merger_model.onnx or qmerger_model.onnx
                 all_merger_files = [
-                    f for f in os.listdir(self.training_artifact_dir)
-                    if f.endswith("merger_model.onnx")
+                    f for f in os.listdir(self.training_artifact_dir) if f.endswith("merger_model.onnx")
                 ]
 
                 for fname in all_merger_files:
@@ -91,163 +88,151 @@ def _load_training_config(self):
             raise FileNotFoundError(f"Training config file not found: {self.training_config_path}")
         except json.JSONDecodeError:
             raise ValueError(f"Invalid JSON in training config file: {self.training_config_path}")
-    
+
     def _extract_parameters(self):
         """Extract base layer and adapter parameters from checkpoint state."""
         if self.trainer.state is None:
             raise ValueError("Trainer checkpoint state is None. Make sure training has been completed.")
-        
+
         # Get parameters object from checkpoint state
         parameters = self.trainer.state.parameters
-        
+
         # Get all parameter names and objects by iterating over parameters
         # Each item is a tuple: (param_name, Parameter object)
         checkpoint_params = list(parameters)
-        
+
         print(f"[INFO] Found {len(checkpoint_params)} parameters in checkpoint")
-        
+
         # Extract base layer parameters (quantized weights, scales, zero_points)
         self._extract_base_layer_params(checkpoint_params)
-        
+
         # Extract adapter parameters
         self._extract_adapter_params(checkpoint_params)
 
         self.create_merged_parameters()
-    
+
     def _extract_base_layer_params(self, checkpoint_params: list):
         """Extract quantized base layer parameters."""
         for base_layer_name in self.peft_mapping.keys():
             base_params = {}
 
-            if base_layer_name.startswith('base_model.model.model.'):
-                base_layer_name = base_layer_name.replace('base_model.model.model.', 'backbone.model.')
-            
+            # One owner for the peft->ORT wrapper rewrite. Spelled inline it read
+            # `base_model.model.model.` -> `backbone.model.`, i.e. a DECODER's first module baked
+            # into a rule that is really about the two WRAPPERS — so it converted nothing for an
+            # encoder (`bert.encoder.layer…`) and every layer then read as missing.
+            base_layer_name = to_checkpoint_name(base_layer_name)
+
             # Look for quantized weight, scale, and zero_point parameters
             weight_quantized_name = f"{base_layer_name}.weight_quantized"
             weight_scale_name = f"{base_layer_name}.weight_scale"
             weight_zero_point_name = f"{base_layer_name}.weight_zero_point"
             weight_noquantized_name = f"{base_layer_name}.weight"
-            
+
             # Iterate through parameter tuples: (param_name, Parameter object)
             for param_name, param_obj in checkpoint_params:
                 if param_name == weight_quantized_name:
-                    base_params['weight_quantized'] = param_obj.data
+                    base_params["weight_quantized"] = param_obj.data
                     print(f"[INFO] Found quantized weight: {param_name}")
                 elif param_name == weight_scale_name:
-                    base_params['x_scale'] = param_obj.data
+                    base_params["x_scale"] = param_obj.data
                     print(f"[INFO] Found weight scale: {param_name}")
                 elif param_name == weight_zero_point_name:
-                    base_params['x_zero_point'] = param_obj.data
+                    base_params["x_zero_point"] = param_obj.data
                     print(f"[INFO] Found weight zero point: {param_name}")
                 elif param_name == weight_noquantized_name:
-                    base_params['weight'] = param_obj.data
+                    base_params["weight"] = param_obj.data
                     print(f"[INFO] Found non-quantized weights: {param_name}")
-            
+
             if base_params:
                 self.base_layer_params[base_layer_name] = base_params
                 print(f"[INFO] Extracted base layer params for: {base_layer_name}")
             else:
                 print(f"[WARNING] No quantized parameters found for base layer: {base_layer_name}")
-    
+
     def _extract_adapter_params(self, checkpoint_params: list):
         """Extract adapter parameters for merging."""
         # Get all unique adapter names from the mapping
 
         self.adapter_params = {}
         for base_layer_name, adapter_names in self.peft_mapping.items():
-
-            # Prefix renaming if needed
-            if base_layer_name.startswith('base_model.model.model.'):
-                base_layer_name = base_layer_name.replace('base_model.model.model.', 'backbone.model.')
+            base_layer_name = to_checkpoint_name(base_layer_name)
 
             if base_layer_name not in self.adapter_params:
                 self.adapter_params[base_layer_name] = {}
 
             for input_name, adapter_name in adapter_names.items():
-
                 # Do not handle non string names, just add them to adapter params
                 if not isinstance(adapter_name, str):
                     self.adapter_params[base_layer_name][input_name] = adapter_name
                     continue
 
-                # Prefix renaming if needed
-                if adapter_name.startswith('base_model.model.model.'):
-                    adapter_name = adapter_name.replace('base_model.model.model.', 'backbone.model.')
+                adapter_name = to_checkpoint_name(adapter_name)
 
-                adapter_name = f'{adapter_name}.weight'
+                adapter_name = f"{adapter_name}.weight"
                 # Iterate through parameter tuples: (param_name, Parameter object)
                 for param_name, param_obj in checkpoint_params:
-
-                    # Prefix renaming if needed
-                    if param_name.startswith('base_model.model.model.'):
-                        param_name = param_name.replace('base_model.model.model.', 'backbone.model.')
+                    param_name = to_checkpoint_name(param_name)
 
                     if adapter_name == param_name:
-
                         self.adapter_params[base_layer_name][input_name] = param_obj.data
 
                         print(f"[INFO] Found adapter param: {param_name}")
-    
-    def get_base_layer_params(self, base_layer_name: str) -> Dict[str, np.ndarray]:
+
+    def get_base_layer_params(self, base_layer_name: str) -> dict[str, np.ndarray]:
         """
         Get quantized parameters for a specific base layer.
-        
+
         Args:
             base_layer_name: Name of the base layer
-            
+
         Returns:
             Dictionary containing weight_quantized, weight_scale, weight_zero_point
         """
         return self.base_layer_params.get(base_layer_name, {})
-    
-    def get_adapter_params(self, adapter_name: str) -> Dict[str, np.ndarray]:
+
+    def get_adapter_params(self, adapter_name: str) -> dict[str, np.ndarray]:
         """
         Get parameters for a specific adapter.
-        
+
         Args:
             adapter_name: Name of the adapter
-            
+
         Returns:
             Dictionary containing adapter parameters
         """
         return self.adapter_params.get(adapter_name, {})
-    
-    def get_mapping_for_base_layer(self, base_layer_name: str) -> Dict[str, Any]:
+
+    def get_mapping_for_base_layer(self, base_layer_name: str) -> dict[str, Any]:
         """
         Get the PEFT mapping configuration for a specific base layer.
-        
+
         Args:
             base_layer_name: Name of the base layer
-            
+
         Returns:
             Dictionary containing adapter mappings for the base layer
         """
         return self.peft_mapping.get(base_layer_name, {})
-    
+
     def create_merged_parameters(self):
         self.input_adapter_parameters = {}
         self.output_adapter_parameters = {}
 
         for base_name, base_params in self.base_layer_params.items():
-            self.input_adapter_parameters[base_name] = {
-                **base_params,
-                **self.adapter_params[base_name]
-            }
+            self.input_adapter_parameters[base_name] = {**base_params, **self.adapter_params[base_name]}
 
             self.output_adapter_parameters[base_name] = {}
 
             # Quantized weight output
-            if 'weight_quantized' in self.input_adapter_parameters[base_name]:
+            if "weight_quantized" in self.input_adapter_parameters[base_name]:
                 self.output_adapter_parameters[base_name] = {
-                    'merged_weight_quantized': None,
-                    'merged_zero_point': None,
-                    'merged_scale': None
+                    "merged_weight_quantized": None,
+                    "merged_zero_point": None,
+                    "merged_scale": None,
                 }
             # Full precision weight output
-            elif 'weight' in self.input_adapter_parameters[base_name]:
-                self.output_adapter_parameters[base_name] = {
-                    'merged_weight': None
-                }
+            elif "weight" in self.input_adapter_parameters[base_name]:
+                self.output_adapter_parameters[base_name] = {"merged_weight": None}
 
             # check for None, empty, or empty numpy arrays
             for key, value in self.input_adapter_parameters[base_name].items():
@@ -263,11 +248,11 @@ def create_merged_parameters(self):
                 # convert plain Python ints or floats to numpy arrays
                 if isinstance(value, (int, np.integer)):
                     self.input_adapter_parameters[base_name][key] = np.array(value, dtype=np.int64)
-                    #print(f"[INFO]: Converted {base_name} -> {key} to numpy int64 array")
+                    # print(f"[INFO]: Converted {base_name} -> {key} to numpy int64 array")
 
                 elif isinstance(value, (float, np.floating)):
                     self.input_adapter_parameters[base_name][key] = np.array(value, dtype=np.float32)
-                    #print(f"[INFO]: Converted {base_name} -> {key} to numpy float32 array")
+                    # print(f"[INFO]: Converted {base_name} -> {key} to numpy float32 array")
 
     def _build_merger_models(self):
         """
@@ -279,7 +264,7 @@ def _build_merger_models(self):
                 print(f"Loading {precision} merger model for method {method_name} from {path}")
                 session = ort.InferenceSession(path)
                 self.merger_models[method_name][precision] = session
-    
+
     def clear_merger_models(self):
         """
         Cleanly releases and deletes all loaded merger ONNX inference sessions
@@ -295,32 +280,31 @@ def clear_merger_models(self):
                 # remove references from dictionary
                 self.merger_models[method_name].clear()
             self.merger_models.clear()
-        
+
         print("[INFO] All merger inference sessions cleared from memory.")
 
     def compute_base_layers_from_adapters(self, save_directory: str = None):
 
         for base_layer, input_layers in self.input_adapter_parameters.items():
-
             print(f"[DEBUG] Computing merge for base_layer: {base_layer}")
-            
+
             # Print input layer keys and their shapes
             for key, val in input_layers.items():
                 if isinstance(val, np.ndarray):
                     print(f"[DEBUG] Input '{key}' shape: {val.shape}")
                 else:
                     print(f"[WARNING] Input '{key}' is not a numpy array, type={type(val)}")
-            
+
             # Run the MARS merger technique
-            if 'shared_A' in input_layers:
-                self._run_merger_model(self.merger_models['mars'], base_layer, input_layers)
+            if "shared_A" in input_layers:
+                self._run_merger_model(self.merger_models["mars"], base_layer, input_layers)
             # Run the LoRA merger technique
-            elif 'adapter_A' in input_layers:
+            elif "adapter_A" in input_layers:
                 # We do not need rank input here
                 input_layers.pop("rank", None)
-                self._run_merger_model(self.merger_models['lora'], base_layer, input_layers)
+                self._run_merger_model(self.merger_models["lora"], base_layer, input_layers)
 
-        print(f"\n[DEBUG] Finished merging. Output adapter parameters:")
+        print("\n[DEBUG] Finished merging. Output adapter parameters:")
         for base_layer, output_dict in self.output_adapter_parameters.items():
             print(f"  - Base layer: {base_layer}")
             for name, arr in output_dict.items():
@@ -328,7 +312,7 @@ def compute_base_layers_from_adapters(self, save_directory: str = None):
                     print(f"      * {name}: shape={arr.shape}")
                 else:
                     print(f"      * {name}: type={type(arr)} (not a numpy array)")
-        
+
         # Optionally save to disk
         if save_directory:
             os.makedirs(save_directory, exist_ok=True)
@@ -336,7 +320,7 @@ def compute_base_layers_from_adapters(self, save_directory: str = None):
                 save_path = os.path.join(save_directory, f"{base_layer}.npz")
                 np.savez(save_path, **output_dict)
                 print(f"[INFO] Saved merged parameters for {base_layer} to {save_path}")
-    
+
     def _run_merger_model(self, merger_models: dict, base_layer: str, input_layers: dict):
         """
         Runs the quantized or full precision merger technique of the PEFT method.
@@ -344,80 +328,83 @@ def _run_merger_model(self, merger_models: dict, base_layer: str, input_layers:
 
         session = None
 
-        if 'weight_quantized' in input_layers:
-
+        if "weight_quantized" in input_layers:
             session = merger_models["quantized"]
 
             merged_weight_quantized, merged_zero_point, merged_scale = session.run(None, input_layers)
-            
+
             # Debug outputs
-            print(f"[DEBUG] merged_weight_quantized shape: {merged_weight_quantized.shape if isinstance(merged_weight_quantized, np.ndarray) else 'not ndarray'}")
-            print(f"[DEBUG] merged_zero_point shape: {merged_zero_point.shape if isinstance(merged_zero_point, np.ndarray) else 'not ndarray'}")
-            print(f"[DEBUG] merged_scale shape: {merged_scale.shape if isinstance(merged_scale, np.ndarray) else 'not ndarray'}")
-            
+            print(
+                f"[DEBUG] merged_weight_quantized shape: {merged_weight_quantized.shape if isinstance(merged_weight_quantized, np.ndarray) else 'not ndarray'}"
+            )
+            print(
+                f"[DEBUG] merged_zero_point shape: {merged_zero_point.shape if isinstance(merged_zero_point, np.ndarray) else 'not ndarray'}"
+            )
+            print(
+                f"[DEBUG] merged_scale shape: {merged_scale.shape if isinstance(merged_scale, np.ndarray) else 'not ndarray'}"
+            )
+
             if isinstance(merged_weight_quantized, np.ndarray) and merged_weight_quantized.size == 0:
-                print(f"[WARNING] merged_weight_quantized is empty!")
+                print("[WARNING] merged_weight_quantized is empty!")
             if isinstance(merged_zero_point, np.ndarray) and merged_zero_point.size == 0:
-                print(f"[WARNING] merged_zero_point is empty!")
+                print("[WARNING] merged_zero_point is empty!")
             if isinstance(merged_scale, np.ndarray) and merged_scale.size == 0:
-                print(f"[WARNING] merged_scale is empty!")
+                print("[WARNING] merged_scale is empty!")
 
             self.output_adapter_parameters[base_layer] = {
-                'weight_quantized': merged_weight_quantized,
-                'weight_scale': merged_scale,
-                'weight_zero_point': merged_zero_point
+                "weight_quantized": merged_weight_quantized,
+                "weight_scale": merged_scale,
+                "weight_zero_point": merged_zero_point,
             }
-        
-        elif 'weight' in input_layers:
 
+        elif "weight" in input_layers:
             session = merger_models["full_precision"]
 
             merged_weight = session.run(None, input_layers)[0]
-            
+
             # Debug output
             print(f"[DEBUG] merged_weight type: {type(merged_weight)}")
             if isinstance(merged_weight, np.ndarray):
                 print(f"[DEBUG] merged_weight shape: {merged_weight.shape}")
                 if merged_weight.size == 0:
-                    print(f"[WARNING] merged_weight is empty!")
+                    print("[WARNING] merged_weight is empty!")
             else:
-                print(f"[WARNING] merged_weight is not a numpy array")
+                print("[WARNING] merged_weight is not a numpy array")
 
-            self.output_adapter_parameters[base_layer] = {
-                'weight': merged_weight
-            }
+            self.output_adapter_parameters[base_layer] = {"weight": merged_weight}
 
     def print_summary(self):
         """Print a summary of extracted parameters."""
-        print("\n" + "="*50)
+        print("\n" + "=" * 50)
         print("PEFT Merge Validator Summary")
-        print("="*50)
-        
+        print("=" * 50)
+
         print(f"Base layers found: {len(self.base_layer_params)}")
         for base_layer_name, params in self.base_layer_params.items():
             print(f"  - {base_layer_name}: {list(params.keys())}")
-        
+
         print(f"\nAdapters found: {len(self.adapter_params)}")
         for adapter_name, params in self.adapter_params.items():
             print(f"  - {adapter_name}: {list(params.keys())}")
-        
+
         print(f"\nPEFT mappings: {len(self.peft_mapping)}")
 
 
 def create_peft_merge_validator(trainer: ORTTrainer, training_artifact_dir: str) -> PEFTMergeValidator:
     """
     Create a PEFT merge validator instance.
-    
+
     Args:
         trainer: ORTTrainer instance with checkpoint state
         training_config_path: Path to training_config.json containing peft_mapping
-        
+
     Returns:
         PEFTMergeValidator instance
     """
     return PEFTMergeValidator(trainer, training_artifact_dir)
 
-def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
+
+def parse_extra_options(extra_options: list[str]) -> dict[str, str]:
     """
     Parse additional options in KEY=VALUE format into a dictionary.
     """
@@ -428,34 +415,24 @@ def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
             options_dict[key] = value
         else:
             raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
-        
+
     print(f"Extra options: {options_dict}")
     return options_dict
 
-def load_config_from_file(config_file: str):
-    """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
-        config = yaml.safe_load(file)
-    return config
 
 def parse_arguments():
-    parser = argparse.ArgumentParser(description="Validator for exported ONNX artifacts for on-device training.", formatter_class=argparse.RawTextHelpFormatter)
-
-    parser.add_argument(
-        "--model_id",
-        type=str,
-        help="Identifier for the model to be converted."
+    parser = argparse.ArgumentParser(
+        description="Validator for exported ONNX artifacts for on-device training.",
+        formatter_class=argparse.RawTextHelpFormatter,
     )
+
+    parser.add_argument("--model_id", type=str, help="Identifier for the model to be converted.")
     parser.add_argument(
         "--config_file",
         type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
-    )
-    parser.add_argument(
-        "--training_artifact_dir",
-        type=str,
-        help="Path to training artifact directory."
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
     )
+    parser.add_argument("--training_artifact_dir", type=str, help="Path to training artifact directory.")
     parser.add_argument(
         "--test_training_config",
         type=str,
@@ -465,8 +442,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ...
-            """
-            )
+            """),
     )
     parser.add_argument(
         "--test_scheduler_config",
@@ -477,8 +453,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ...
-            """
-            )
+            """),
     )
     args = parser.parse_args()
 
@@ -498,17 +473,17 @@ def parse_arguments():
         "testRatio": 0.1,
         "split": True,
         "shuffle": True,
-        "schedulerType": "cosine"
+        "schedulerType": "cosine",
     }
 
     user_scheduler_generation_config = {}
     default_scheduler_generation_config = {
-       "minLearningRate": 0,
-       "cosineLearningRate": 0.0001,
-       "warmupSteps": 10,
-       "linearLearningRate": 0.0001,
-       "startFactor": 1,
-       "endFactor": 0.333
+        "minLearningRate": 0,
+        "cosineLearningRate": 0.0001,
+        "warmupSteps": 10,
+        "linearLearningRate": 0.0001,
+        "startFactor": 1,
+        "endFactor": 0.333,
     }
 
     config_dict = None
@@ -517,13 +492,14 @@ def parse_arguments():
         config_dict = load_config_from_file(args.config_file)
 
         # Specific
-        setattr(args, "model_id", config_dict[TRAIN_CONFIG]["model_id"])
-        setattr(args, "training_artifact_dir", os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "train"))
-        setattr(args, "test_scheduler_config", config_dict[ARTIFACT_VALIDATOR_CONFIG]["test_training_config"]["schedulerOptions"])
-        
+        args.model_id = config_dict[TRAIN_CONFIG]["model_id"]
+        args.training_artifact_dir = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "train")
+        args.test_scheduler_config = config_dict[ARTIFACT_VALIDATOR_CONFIG]["test_training_config"][
+            "schedulerOptions"
+        ]
+
         # Override any command-line argument with values from the config file
         for key, value in config_dict[ARTIFACT_VALIDATOR_CONFIG].items():
-            
             # Convert to the correct type
             if hasattr(args, key):
                 setattr(args, key, value)
@@ -532,17 +508,22 @@ def parse_arguments():
         user_train_generation_config = parse_extra_options(args.test_training_config)
         args.test_training_config = {**default_train_generation_config, **user_train_generation_config}
         user_scheduler_generation_config = parse_extra_options(args.test_scheduler_config)
-        args.test_scheduler_config = {**default_scheduler_generation_config, **user_scheduler_generation_config}
+        args.test_scheduler_config = {
+            **default_scheduler_generation_config,
+            **user_scheduler_generation_config,
+        }
 
     return args
 
+
 # Example usage
 if __name__ == "__main__":
-
     trainer = ORTTrainer("build/train", load_from_state=True)
 
     trainer.train()
 
     validator = create_peft_merge_validator(trainer, "")
 
-    validator.compute_base_layers_from_adapters(save_directory=os.path.join('training_artifact_dir', 'temp_weights/'))
\ No newline at end of file
+    validator.compute_base_layers_from_adapters(
+        save_directory=os.path.join("training_artifact_dir", "temp_weights/")
+    )
diff --git a/src/mobiletransformers/training/preprocessing.py b/src/mobiletransformers/training/preprocessing.py
new file mode 100644
index 0000000..5b6d3c3
--- /dev/null
+++ b/src/mobiletransformers/training/preprocessing.py
@@ -0,0 +1,521 @@
+"""Dataset preprocessing + the supervised data collator.
+
+Migrated from ``trainer/utils.py`` (Migration Map S4).
+
+The ``deepeval.benchmarks.*`` template imports are FUNCTION-LOCAL: deepeval is an eval-extra dependency,
+and importing it at module level here would make the whole training package unimportable in the core
+environment (it was a top-level import in the original).
+"""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # annotations only — `from __future__ import annotations` keeps them lazy
+    import numpy as np
+    import torch
+    from transformers import PreTrainedTokenizer
+
+
+def _torch():  # noqa: ANN202
+    """Lazy torch handle — this module must import in the core env (no torch installed)."""
+    import torch  # noqa: PLC0415
+
+    return torch
+
+
+@dataclass
+class DataCollatorForSupervisedDataset:
+    """Dynamically pads input sequences for supervised fine-tuning."""
+
+    tokenizer: PreTrainedTokenizer
+
+    def __call__(self, instances: list[dict], return_tensors="pt") -> dict[str, torch.Tensor]:
+
+        input_ids, labels = tuple(
+            [instance[key] for instance in instances] for key in ("input_ids", "labels")
+        )
+
+        # Convert to tensors
+        input_ids = [_torch().tensor(x, dtype=_torch().long) for x in input_ids]
+        labels = [_torch().tensor(x, dtype=_torch().long) for x in labels]
+
+        pad_token_id = (
+            self.tokenizer.pad_token_id or self.tokenizer.eos_token_id
+        )  # Default to EOS if PAD is missing
+
+        # Pad sequences dynamically
+        input_ids = _torch().nn.utils.rnn.pad_sequence(
+            input_ids, batch_first=True, padding_value=pad_token_id
+        )
+        labels = _torch().nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=-100)
+
+        # Construct attention mask dynamically: 1 for non-pad tokens, 0 for pad tokens
+        attention_mask = input_ids.ne(pad_token_id).long()
+
+        # Convert to requested tensor format
+        if return_tensors == "np":
+            return {
+                "input_ids": input_ids.numpy(),
+                "labels": labels.numpy(),
+                "attention_mask": attention_mask.numpy(),
+            }
+        elif return_tensors == "pt":
+            return {"input_ids": input_ids, "labels": labels, "attention_mask": attention_mask}
+        else:
+            raise ValueError(f"return_tensors must be 'pt' or 'np', got {return_tensors}")
+
+    def numpy_call(self, instances: list[dict]) -> dict[str, np.ndarray]:
+        """Convenience method that returns NumPy arrays."""
+        return self.__call__(instances, return_tensors="np")
+
+    def pytorch_call(self, instances: list[dict]) -> dict[str, torch.Tensor]:
+        """Convenience method that returns PyTorch tensors."""
+        return self.__call__(instances, return_tensors="pt")
+
+
+def process_sample_minirecommendation(samples, tokenizer, batched=True):
+
+    def format_question(data_point):
+        """Format the recommendation prompt"""
+        user_query = data_point["prompt"]
+        category = data_point["category"]
+
+        # Build the formatted question
+        formatted = f"Recommend best actions based on this user query: {user_query}"
+
+        return formatted
+
+    def format_answer(data_point):
+        """Format the recommendation answer"""
+        return data_point["recommendation"]
+
+    def generate_prompt(data_point):
+        question = format_question(data_point) + "\n\nAnswer: "
+        answer = format_answer(data_point)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["prompt"])):
+            sample = {
+                "type": samples["type"][i],
+                "category": samples["category"][i],
+                "prompt": samples["prompt"][i],
+                "recommendation": samples["recommendation"][i],
+            }
+
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tk = generate_prompt(samples)
+
+    return tk
+
+
+def process_sample_minipersonalqa(samples, tokenizer, batched=True):
+
+    def format_question(data_point):
+        """Format the question with multiple choice options"""
+        question_text = data_point["question"]
+        choices = data_point["choices"]
+
+        # Build the formatted question
+        formatted = f"Question: {question_text}\n\n"
+        for choice_key, choice_value in choices.items():
+            formatted += f"{choice_key}: {choice_value}\n"
+
+        return formatted
+
+    def format_answer(data_point):
+        """Format just the answer"""
+        return data_point["correct_answer"]
+
+    def generate_prompt(data_point):
+        question = format_question(data_point) + "\n\nAnswer: "
+        answer = format_answer(data_point)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["question"])):
+            sample = {
+                "type": samples["type"][i],
+                "category": samples["category"][i],
+                "question": samples["question"][i],
+                "choices": samples["choices"][i],
+                "correct_answer": samples["correct_answer"][i],
+            }
+
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tk = generate_prompt(samples)
+
+    return tk
+
+
+def process_sample_winogrande_deepeval(samples, tokenizer, batched=True):
+    from deepeval.benchmarks.winogrande.template import WinograndeTemplate  # noqa: PLC0415
+
+    def generate_prompt(data_point):
+
+        question = WinograndeTemplate.format_question(data_point, include_answer=False) + "\n\n "
+        answer = WinograndeTemplate.format_answer(data_point)
+
+        if tokenizer.chat_template is not None:
+            messages = [
+                {"role": "user", "content": question},
+                {"role": "assistant", "content": f" {WinograndeTemplate.format_answer(data_point)}\n\n"},
+            ]
+            return tokenizer.apply_chat_template(messages, tokenize=False)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["sentence"])):
+            sample = {
+                "sentence": samples["sentence"][i],
+                "option1": samples["option1"][i],
+                "option2": samples["option2"][i],
+                "answer": samples["answer"][i],
+            }
+
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tk = generate_prompt(samples)
+
+    return tk
+
+
+def process_sample_logiqa_deepeval(samples, tokenizer, batched=True):
+    from deepeval.benchmarks.logi_qa.template import LogiQATemplate  # noqa: PLC0415
+
+    def generate_prompt(data_point):
+
+        question = LogiQATemplate.format_question(data_point) + "\n\n "
+        answer = LogiQATemplate.format_output(data_point)
+
+        if tokenizer.chat_template is not None:
+            messages = [
+                {"role": "user", "content": question},
+                {"role": "assistant", "content": f" {answer}\n\n"},
+            ]
+            return tokenizer.apply_chat_template(messages, tokenize=False)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["question"])):
+            sample = {
+                "question": samples["question"][i],
+                "text": samples["text"][i],
+                "options": samples["options"][i],
+                "answer": samples["answer"][i],
+            }
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tp = generate_prompt(samples)
+        tk = {"input_ids": tp[0], "labels": tp[1]}
+
+    return tk
+
+
+def process_sample_arc_deepeval(samples, tokenizer, batched=True):
+    from deepeval.benchmarks.arc.template import ARCTemplate  # noqa: PLC0415
+
+    def generate_prompt(data_point):
+
+        question = ARCTemplate.format_question(data_point, include_answer=False) + "\n\n "
+        answer = ARCTemplate.format_answer(data_point)
+
+        if tokenizer.chat_template is not None:
+            messages = [
+                {"role": "user", "content": question},
+                {"role": "assistant", "content": f" {ARCTemplate.format_answer(data_point)}\n\n"},
+            ]
+            return tokenizer.apply_chat_template(messages, tokenize=False)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["question"])):
+            sample = {
+                "question": samples["question"][i],
+                "choices": samples["choices"][i],
+                "answerKey": samples["answerKey"][i],
+            }
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tk = generate_prompt(samples)
+
+    return tk
+
+
+def process_sample_boolq_deepeval(samples, tokenizer, batched=True):
+    from deepeval.benchmarks.bool_q.template import BoolQTemplate  # noqa: PLC0415
+
+    def generate_prompt(data_point):
+
+        question = BoolQTemplate.format_question(data_point) + "\n\n "
+        answer = BoolQTemplate.format_answer(data_point)
+
+        if tokenizer.chat_template is not None:
+            messages = [
+                {"role": "user", "content": question},
+                {"role": "assistant", "content": f" {answer}\n\n"},
+            ]
+            return tokenizer.apply_chat_template(messages, tokenize=False)
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        # Concatenate the token sequences
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["question"])):
+            sample = {
+                "question": samples["question"][i],
+                "passage": samples["passage"][i],
+                "answer": samples["answer"][i],
+            }
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tk = generate_prompt(samples)
+
+    return tk
+
+
+def process_sample_hellaswag_deepeval(samples, tokenizer, batched=True):
+    from deepeval.benchmarks.hellaswag.template import HellaSwagTemplate  # noqa: PLC0415
+
+    def generate_prompt(data_point):
+
+        base_prompt = f"The following are multiple choice sentence completion problems about {data_point['activity_label']}.\n\n"
+        choices = ["A", "B", "C", "D"]
+
+        if tokenizer.chat_template is not None:
+            gen_output = HellaSwagTemplate.format_question(data_point, include_answer=False)
+            messages = [
+                {"role": "user", "content": base_prompt + gen_output},
+                {"role": "assistant", "content": " {}\n\n".format(choices[int(data_point["label"])])},
+            ]
+            return tokenizer.apply_chat_template(messages, tokenize=False)
+
+        question = base_prompt + HellaSwagTemplate.format_question(data_point, include_answer=False) + "\n\n "
+
+        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
+
+        answer = "{}".format(choices[int(data_point["label"])])
+        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)[
+            "input_ids"
+        ][0]
+
+        input_ids = _torch().cat([question_tokens, answer_tokens], dim=0)
+        labels = input_ids.clone()
+        labels[: len(question_tokens)] = -100
+
+        return (input_ids.squeeze(0), labels.squeeze(0))
+
+    if batched:
+        batch = {"input_ids": [], "labels": []}
+        for i in range(len(samples["ctx"])):
+            sample = {
+                "ctx": samples["ctx"][i],
+                "endings": samples["endings"][i],
+                "label": samples["label"][i],
+                "activity_label": samples["activity_label"][i],
+            }
+            input_ids, labels = generate_prompt(sample)
+            batch["input_ids"].append(input_ids)
+            batch["labels"].append(labels)
+
+        return batch
+    else:
+        tp = generate_prompt(samples)
+        tk = {"input_ids": tp[0], "labels": tp[1]}
+
+    return tk
+
+
+def process_sample_dolly(sample, tokenizer):
+
+    chat = [
+        {"role": "user", "content": sample["instruction"]},
+        {"role": "assistant", "content": sample["response"]},
+    ]
+
+    # TODO: This is wrong formatting
+    if sample["context"]:
+        chat.insert(0, {"role": "system", "content": sample["context"]})
+
+    # Tokenize the prompt text
+    text = tokenizer.apply_chat_template(
+        chat, return_dict=True, tokenize=True, return_tensors="pt", padding=True, add_generation_prompt=False
+    )
+    return {"input_ids": text["input_ids"][0], "attention_mask": text["attention_mask"][0]}
+
+
+def process_sample_alpaca(sample, tokenizer):
+
+    def prompt_no_input(row):
+        return (
+            "Below is an instruction that describes a task. "
+            "Write a response that appropriately completes the request.\n\n"
+            "### Instruction:\n{instruction}\n\n### Response:\n{output}"
+        ).format_map(row)
+
+    def prompt_input(row):
+        return (
+            "Below is an instruction that describes a task, paired with an input that provides further context. "
+            "Write a response that appropriately completes the request.\n\n"
+            "### Instruction:\n{instruction}\n\n### Input:\n{input}\n\n### Response:\n{output}"
+        ).format_map(row)
+
+    chat = ""
+
+    if len(sample["input"]) == 0:
+        chat = prompt_no_input(sample)
+    else:
+        chat = prompt_input(sample)
+
+    # Tokenize the prompt text
+    text = tokenizer(chat, return_tensors="pt", padding=True)
+    return text
+
+
+def process_sample_hellaswag(samples, tokenizer, batched=True):
+    def generate_prompt(data_point):
+
+        endings = "\n".join([f"{i + 1}. {e}" for i, e in enumerate(data_point["endings"])])
+
+        return inspect.cleandoc(f"""
+        Context: {data_point["ctx"]}
+
+        Options:
+        {endings}
+
+        Which option best completes the context?
+        Answer: {data_point["label"] + 1}
+        """).strip()
+
+    if batched:
+        text = [
+            generate_prompt(
+                {"ctx": samples["ctx"][i], "endings": samples["endings"][i], "label": samples["label"][i]}
+            )
+            for i in range(len(list(samples.values())[0]))
+        ]
+    else:
+        text = generate_prompt(samples)
+
+    tk = tokenizer(text, return_tensors="pt", padding=True)
+    return tk
+
+
+def taskname_to_deepeval_preprocess_function(preprocess_id):
+
+    if preprocess_id == "hellaswag":
+        return process_sample_hellaswag_deepeval
+    elif preprocess_id == "boolq":
+        return process_sample_boolq_deepeval
+    elif preprocess_id == "arc_e" or preprocess_id == "arc_c":
+        return process_sample_arc_deepeval
+    elif preprocess_id == "logiqa":
+        return process_sample_logiqa_deepeval
+    elif preprocess_id == "winogrande":
+        return process_sample_winogrande_deepeval
+    elif preprocess_id == "mini_personalqa":
+        return process_sample_minipersonalqa
+    elif preprocess_id == "mini_recommendation":
+        print("USING RECOMMENDATRION")
+        return process_sample_minirecommendation
+
+    return None
diff --git a/trainer/validator.py b/src/mobiletransformers/training/validators.py
similarity index 73%
rename from trainer/validator.py
rename to src/mobiletransformers/training/validators.py
index f51797a..7c4c2d4 100644
--- a/trainer/validator.py
+++ b/src/mobiletransformers/training/validators.py
@@ -1,35 +1,47 @@
+# DECOMPOSE(#5): split validation rules vs. graph ops vs. quantization into
+# src/mobiletransformers/{training/validators,artifacts/validation} as touched (#6/#9). ~51 KB.
 import argparse
+import gc
+import json
+import os
 import random
 import textwrap
-from typing import Dict, List
-import onnx, time, os, gc, json
-import onnxruntime as ort
+import time
+from collections import defaultdict
+from datetime import datetime
 
+import numpy as np
+import onnx
+import onnxruntime as ort
+import onnxruntime as rt
 import psutil
 import torch
+from datasets import Dataset
+from onnxruntime import SessionOptions
+from onnxruntime.training.api import CheckpointState, LinearLRScheduler, Module, Optimizer
+from torch.utils.data import DataLoader
 from tqdm import tqdm
 from transformers import AutoTokenizer
-import numpy as np
-from onnxruntime.training.api import CheckpointState, Module, Optimizer, LinearLRScheduler
-import onnxruntime as rt
-from onnxruntime import SessionOptions
-from datasets import Dataset
-from datetime import datetime
-from collections import defaultdict
 
-from torch.utils.data import DataLoader
-import yaml
-from research.offline_train_eval import DATASET_MAPPING, PEFTBenchmarkDataset
-from tools.utils import preload_dataset
-from trainer.utils import DataCollatorForSupervisedDataset, taskname_to_deepeval_preprocess_function
-from tools.parser_config import TASK_NAME_TO_DATASET, TRAIN_CONFIG, ARTIFACT_CONFIG, ARTIFACT_VALIDATOR_CONFIG
+from mobiletransformers.artifacts.checkpoint_names import to_checkpoint_name
+from mobiletransformers.config.constants import (
+    ARTIFACT_CONFIG,
+    ARTIFACT_VALIDATOR_CONFIG,
+    TRAIN_CONFIG,
+)
+from mobiletransformers.config.settings import get_settings
+from mobiletransformers.training.benchmark_datasets import DATASET_MAPPING, PEFTBenchmarkDataset
+from mobiletransformers.training.data import preload_dataset
+from mobiletransformers.training.preprocessing import (
+    DataCollatorForSupervisedDataset,
+    taskname_to_deepeval_preprocess_function,
+)
+from mobiletransformers.utils.yaml import load_config_from_file
 
-import numpy as np
-import json
-import os
 
 class CosineLRScheduler:
     """Cosine Learning Rate Scheduler for ONNX Runtime Training."""
+
     def __init__(self, optimizer, warmup_steps, total_steps, min_lr=0.0, initial_lr=0.001):
         self.optimizer = optimizer
         self.total_steps = total_steps
@@ -37,7 +49,7 @@ def __init__(self, optimizer, warmup_steps, total_steps, min_lr=0.0, initial_lr=
         self.min_lr = min_lr
         self.initial_lr = initial_lr
         self.current_step = 0
-        
+
         # Set initial learning rate
         if warmup_steps > 0:
             initial_warmup_lr = 0.0  # Start from 0 during warmup
@@ -57,7 +69,7 @@ def step(self, increment=True):
             # Cosine decay after warmup
             decay_step = self.current_step - self.warmup_steps
             decay_total = self.total_steps - self.warmup_steps
-            
+
             # Handle edge case where decay_total might be 0
             if decay_total <= 0:
                 new_lr = self.min_lr
@@ -68,54 +80,54 @@ def step(self, increment=True):
         # Ensure LR doesn't go below min_lr
         new_lr = max(new_lr, self.min_lr)
         self.optimizer.set_learning_rate(new_lr)
-        
+
     def get_learning_rate(self):
         """Get current learning rate from optimizer."""
         return self.optimizer.get_learning_rate()
-    
+
     def state_dict(self):
         """Return the state of the scheduler as a dictionary."""
         return {
-            'total_steps': self.total_steps,
-            'warmup_steps': self.warmup_steps,
-            'min_lr': self.min_lr,
-            'initial_lr': self.initial_lr,
-            'current_step': self.current_step,
+            "total_steps": self.total_steps,
+            "warmup_steps": self.warmup_steps,
+            "min_lr": self.min_lr,
+            "initial_lr": self.initial_lr,
+            "current_step": self.current_step,
         }
-    
+
     def load_state_dict(self, state_dict, update_total_steps=None):
         """Load the scheduler state from a dictionary."""
-        self.warmup_steps = state_dict['warmup_steps']
-        self.min_lr = state_dict['min_lr']
-        self.initial_lr = state_dict['initial_lr']
-        self.current_step = state_dict['current_step']
-        
+        self.warmup_steps = state_dict["warmup_steps"]
+        self.min_lr = state_dict["min_lr"]
+        self.initial_lr = state_dict["initial_lr"]
+        self.current_step = state_dict["current_step"]
+
         # Handle total_steps change
         if update_total_steps is not None:
             print(f"Updating total_steps from {state_dict['total_steps']} to {update_total_steps}")
             self.total_steps = update_total_steps
         else:
-            self.total_steps = state_dict['total_steps']
-        
+            self.total_steps = state_dict["total_steps"]
+
         # Update optimizer with current learning rate without incrementing step
         self.step(increment=False)
-    
+
     def save_checkpoint(self, filepath):
         """Save scheduler state to a file."""
         state = self.state_dict()
-        
+
         # Ensure directory exists
         os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        
-        with open(filepath, 'w') as f:
+
+        with open(filepath, "w") as f:
             json.dump(state, f, indent=2)
-    
+
     def load_checkpoint(self, filepath):
         """Load scheduler state from a file."""
-        with open(filepath, 'r') as f:
+        with open(filepath) as f:
             state = json.load(f)
         self.load_state_dict(state)
-    
+
     def reset(self):
         """Reset the scheduler to initial state."""
         self.current_step = 0
@@ -124,32 +136,35 @@ def reset(self):
         else:
             initial_lr = self.initial_lr
         self.optimizer.set_learning_rate(initial_lr)
-    
+
     def get_last_lr(self):
         """Get the last computed learning rate (for compatibility with PyTorch schedulers)."""
         return [self.get_learning_rate()]
-    
+
     def __repr__(self):
-        return (f"CosineLRScheduler(warmup_steps={self.warmup_steps}, "
-                f"total_steps={self.total_steps}, min_lr={self.min_lr}, "
-                f"initial_lr={self.initial_lr}, current_step={self.current_step})")
+        return (
+            f"CosineLRScheduler(warmup_steps={self.warmup_steps}, "
+            f"total_steps={self.total_steps}, min_lr={self.min_lr}, "
+            f"initial_lr={self.initial_lr}, current_step={self.current_step})"
+        )
 
 
 class ORTDataCurator:
+    def __init__(
+        self,
+        model_id,
+        task_name,
+        max_dataset_length=None,
+        remove_long_samples=True,
+        max_context_length=512,
+        test_ratio=0.1,
+        batch_size=4,
+        split=True,
+        shuffle=False,
+    ) -> None:
 
-    def __init__(self,
-                 model_id,
-                 task_name,
-                 max_dataset_length = None,
-                 remove_long_samples = True,
-                 max_context_length=512,
-                 test_ratio=0.1,
-                 batch_size=4,
-                 split=True,
-                 shuffle=False) -> None:
-        
         self.model_id = model_id
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id, token=os.environ['HF_TOKEN'])
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id, token=get_settings().require_hf_token())
         self.collator = DataCollatorForSupervisedDataset(self.tokenizer)
 
         self.max_dataset_length = max_dataset_length
@@ -165,20 +180,24 @@ def __init__(self,
         self._setup_dataset(task_name)
 
         ds = preload_dataset(self.dataset_id, self.dataset_name)
-        self.prepare_dataset(ds, custom_preprocess=taskname_to_deepeval_preprocess_function(self.dataset_config.value))
+        self.prepare_dataset(
+            ds, custom_preprocess=taskname_to_deepeval_preprocess_function(self.dataset_config.value)
+        )
 
     def _setup_dataset(self, dataset_input):
         """Setup dataset configuration from simple string identifier or enum."""
         # Handle both string and enum inputs
 
         if isinstance(dataset_input, PEFTBenchmarkDataset):
-            self.dataset_config = dataset_input    
+            self.dataset_config = dataset_input
         else:
             if dataset_input.lower() not in list(DATASET_MAPPING.keys()):
-                raise ValueError(f"Unsupported dataset: {dataset_input}. Choose from: {list(DATASET_MAPPING.keys())}")
-            
+                raise ValueError(
+                    f"Unsupported dataset: {dataset_input}. Choose from: {list(DATASET_MAPPING.keys())}"
+                )
+
             self.dataset_config = PEFTBenchmarkDataset[dataset_input.upper()]
-        
+
         self.dataset_id = DATASET_MAPPING[self.dataset_config.value][0]
         self.preprocess_id = DATASET_MAPPING[self.dataset_config.value][1]
 
@@ -188,22 +207,39 @@ def _setup_dataset(self, dataset_input):
             self.dataset_name = None
 
     # Define preprocessing function for tokenization
-    def prepare_dataset(self, dataset : Dataset, custom_preprocess = None):
+    def prepare_dataset(self, dataset: Dataset, custom_preprocess=None):
 
         raw_columns = dataset["train"].column_names
 
         if self.split:
-            test_size = self.test_ratio if self.max_dataset_length == None else int(self.max_dataset_length * self.test_ratio)
-            train_size = (1 - self.test_ratio) if self.max_dataset_length == None else int(self.max_dataset_length * (1 - self.test_ratio))
-            dataset = dataset["train"].train_test_split(test_size=test_size, train_size=train_size, shuffle=self.shuffle)    
+            test_size = (
+                self.test_ratio
+                if self.max_dataset_length == None
+                else int(self.max_dataset_length * self.test_ratio)
+            )
+            train_size = (
+                (1 - self.test_ratio)
+                if self.max_dataset_length == None
+                else int(self.max_dataset_length * (1 - self.test_ratio))
+            )
+            dataset = dataset["train"].train_test_split(
+                test_size=test_size, train_size=train_size, shuffle=self.shuffle
+            )
 
         def process_sample(sample):
-            
+
             if custom_preprocess:
                 return custom_preprocess(sample, self.tokenizer, (self.batch_size > 1))
 
-            return self.tokenizer(sample, return_dict=True, tokenize=True, return_tensors="np", padding=True, add_generation_prompt=False)
-        
+            return self.tokenizer(
+                sample,
+                return_dict=True,
+                tokenize=True,
+                return_tensors="np",
+                padding=True,
+                add_generation_prompt=False,
+            )
+
         def filter_sample(sample):
             return len(sample["input_ids"]) < self.max_context_length
 
@@ -217,39 +253,41 @@ def filter_sample(sample):
 
         self.dataset = dataset
 
+
 class ORTTrainingArguments:
+    def __init__(
+        self,
+        model_id=None,
+        peft_method=None,
+        peft_rank=None,
+        peft_alpha=None,
+        peft_target=None,
+        export_inference=False,
+        test_inference=False,
+        test_evaluate=False,
+        batch_size=1,
+        learning_rate=1e-3,
+        min_learning_rate=0,
+        max_sequence_length=100,
+        max_dataset_length=100,
+        num_train_epochs=1,
+        warmup_steps=10,
+        max_steps=10,
+        save_steps=100,
+        remove_long_samples=True,
+        dataset_split: bool = False,
+        dataset_shuffle: bool = False,
+        dataset_test_ratio: bool = 0.1,
+        scheduler_type="linear",
+        grad_accum_steps=4,
+    ) -> None:
 
-    def __init__(self,
-                model_id=None,
-                peft_method=None,
-                peft_rank = None,
-                peft_alpha = None,
-                peft_target = None,
-                export_inference=False,
-                test_inference=False,
-                test_evaluate=False,
-                batch_size=1,
-                learning_rate=1e-3,
-                min_learning_rate=0,
-                max_sequence_length=100,
-                max_dataset_length=100,
-                num_train_epochs=1,
-                warmup_steps=10,
-                max_steps=10,
-                save_steps=100,
-                remove_long_samples=True,
-                dataset_split : bool = False,
-                dataset_shuffle : bool = False,
-                dataset_test_ratio : bool = 0.1,
-                scheduler_type="linear",
-                grad_accum_steps=4) -> None:
-        
         self.model_id = model_id
         self.peft_method = peft_method
         self.export_inference = export_inference
         self.test_inference = test_inference
         self.test_evaluate = test_evaluate
-        
+
         self.max_sequence_length = max_sequence_length
         self.max_dataset_length = max_dataset_length
         self.remove_long_samples = remove_long_samples
@@ -272,9 +310,9 @@ def __init__(self,
         self.peft_alpha = peft_alpha
         self.peft_target = peft_target
         self.trainable_parameter_count = 0
-    
+
     def load_from_json(self, train_dir):
-        with open(f"{train_dir}/training_config.json", "r") as f:
+        with open(f"{train_dir}/training_config.json") as f:
             data = json.load(f)
 
         self.export_inference = False
@@ -321,7 +359,7 @@ def load_from_json(self, train_dir):
 
             if self.dataset_batch_size is None:
                 self.dataset_batch_size = 64
-        
+
         # Peft method
         self.peft_method = data.get("peftMethod", None)
         self.peft_rank = data.get("rank", None)
@@ -332,17 +370,18 @@ def load_from_json(self, train_dir):
 
         return self
 
+
 class ORTTrainer:
+    def __init__(
+        self,
+        training_model_dir,
+        args: ORTTrainingArguments = None,
+        load_from_state=False,
+        inference_model_path="inference_model.onnx",
+        callbacks=None,
+        seed=42,
+    ) -> None:
 
-    def __init__(self,
-                training_model_dir,
-                args : ORTTrainingArguments = None,
-                load_from_state=False,
-                inference_model_path="inference_model.onnx",
-                callbacks=None,
-                seed=42
-                ) -> None:
-        
         self.training_model_dir = training_model_dir
         self.inference_model_path = inference_model_path
         self.callbacks = callbacks
@@ -357,7 +396,7 @@ def __init__(self,
 
         if self.load_from_state:
             try:
-                with open(f"{self.training_model_dir}/training_state.json", "r") as f:
+                with open(f"{self.training_model_dir}/training_state.json") as f:
                     self.state = json.load(f)
             except FileNotFoundError:
                 print("No training state found.")
@@ -367,32 +406,41 @@ def __init__(self,
 
         self._set_seed()
 
-        self.data_curator = ORTDataCurator(model_id=self.args.model_id,
-                                            task_name=self.args.task_name,
-                                            max_dataset_length=self.args.max_dataset_length,
-                                            remove_long_samples=self.args.remove_long_samples,
-                                            max_context_length=self.args.max_sequence_length,
-                                            test_ratio=self.args.dataset_test_ratio,
-                                            split=self.args.dataset_split,
-                                            shuffle=self.args.dataset_shuffle,
-                                            batch_size=self.args.dataset_batch_size
-                                            )
-        
+        self.data_curator = ORTDataCurator(
+            model_id=self.args.model_id,
+            task_name=self.args.task_name,
+            max_dataset_length=self.args.max_dataset_length,
+            remove_long_samples=self.args.remove_long_samples,
+            max_context_length=self.args.max_sequence_length,
+            test_ratio=self.args.dataset_test_ratio,
+            split=self.args.dataset_split,
+            shuffle=self.args.dataset_shuffle,
+            batch_size=self.args.dataset_batch_size,
+        )
+
         self.train_model_name = self._create_model_name()
-        
+
     def _load_train_config(self):
 
         if self.args is not None:
             return
-        
+
         self.args = ORTTrainingArguments().load_from_json(self.training_model_dir)
 
     def set_scheduler_type(self, total_steps):
 
         if self.args.scheduler_type == "linear":
-            return LinearLRScheduler(self.optimizer, self.args.warmup_steps, total_steps, initial_lr=self.args.learning_rate)
+            return LinearLRScheduler(
+                self.optimizer, self.args.warmup_steps, total_steps, initial_lr=self.args.learning_rate
+            )
         elif self.args.scheduler_type == "cosine":
-            return CosineLRScheduler(self.optimizer, self.args.warmup_steps, total_steps, min_lr=self.args.min_learning_rate, initial_lr=self.args.learning_rate)
+            return CosineLRScheduler(
+                self.optimizer,
+                self.args.warmup_steps,
+                total_steps,
+                min_lr=self.args.min_learning_rate,
+                initial_lr=self.args.learning_rate,
+            )
         else:
             raise ValueError("Unsupported scheduler type. Use 'linear' or 'cosine'.")
 
@@ -403,14 +451,19 @@ def load_onnx_trainer(self):
         sess_options = SessionOptions()
         sess_options.enable_profiling = False
         sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_ALL
-        sess_options.execution_mode = rt.ExecutionMode.ORT_SEQUENTIAL#ORT_PARALLEL
+        sess_options.execution_mode = rt.ExecutionMode.ORT_SEQUENTIAL  # ORT_PARALLEL
         sess_options.intra_op_num_threads = 4
         sess_options.inter_op_num_threads = 4
         sess_options.enable_cpu_mem_arena = False
         sess_options.add_session_config_entry("session.intra_op.allow_spinning", "0")
         sess_options.add_session_config_entry("session.inter_op.allow_spinning", "0")
 
-        self.model = Module(f"{self.training_model_dir}/training_model.onnx", self.checkpoint_state, f"{self.training_model_dir}/eval_model.onnx", session_options=sess_options)
+        self.model = Module(
+            f"{self.training_model_dir}/training_model.onnx",
+            self.checkpoint_state,
+            f"{self.training_model_dir}/eval_model.onnx",
+            session_options=sess_options,
+        )
         self.optimizer = Optimizer(f"{self.training_model_dir}/optimizer_model.onnx", self.model)
 
     def train(self):
@@ -421,9 +474,9 @@ def train(self):
 
         # Save the training config
         self.save_training_config()
-        
+
         self.load_onnx_trainer()
-        
+
         train_dataset = self.data_curator.dataset["train"]
 
         total_samples = len(train_dataset)
@@ -445,16 +498,16 @@ def train(self):
             train_dataset,
             batch_size=self.args.batch_size,
             shuffle=self.args.dataset_shuffle,
-            collate_fn=self.data_curator.collator.numpy_call
+            collate_fn=self.data_curator.collator.numpy_call,
         )
 
         # Calculate total steps
         steps_per_epoch = len(dataloader)
         total_epoch_steps = self.args.num_train_epochs * steps_per_epoch
-        
+
         # Determine whether to use steps or epochs
         total_steps = self.args.max_steps if self.args.max_steps is not None else total_epoch_steps
-        
+
         # Scheduler
         self.scheduler = self.set_scheduler_type(total_steps)
 
@@ -464,29 +517,29 @@ def train(self):
 
         if self.load_from_state:
             # Load checkpoint and get the step/epoch we're resuming from
-            resume_from_step = self.state.get('current_global_step', 0)
-            resume_from_epoch = self.state.get('current_epoch', 0)
-            
+            resume_from_step = self.state.get("current_global_step", 0)
+            resume_from_epoch = self.state.get("current_epoch", 0)
+
             # Load scheduler state
-            if 'scheduler_state' in self.state:
+            if "scheduler_state" in self.state:
                 # Option 1: Strict loading (assumes total_steps hasn't changed)
-                self.scheduler.load_state_dict(self.state['scheduler_state'])
-                
+                self.scheduler.load_state_dict(self.state["scheduler_state"])
+
                 # Option 2: Allow total_steps to change
                 # self.scheduler.load_state_dict(checkpoint_data['scheduler_state'], strict=False)
-                
+
                 # Option 3: Update total_steps and preserve progress
-                # self.scheduler.load_state_dict(checkpoint_data['scheduler_state'], 
-                #                               update_total_steps=total_steps, 
+                # self.scheduler.load_state_dict(checkpoint_data['scheduler_state'],
+                #                               update_total_steps=total_steps,
                 #                               preserve_progress=True)
-            
+
             print(f"Resuming training from step {resume_from_step}, epoch {resume_from_epoch}")
 
         # Main training loop
         global_step = resume_from_step
         epoch = resume_from_epoch
         pbar = tqdm(total=total_steps, desc="ONNX Runtime Training")
-        
+
         accumulated_loss = 0.0
         start_time = time.time()
 
@@ -496,7 +549,6 @@ def train(self):
             total_steps += self.args.max_steps
 
         while global_step < total_steps:
-
             # Skip to the right epoch if resuming
             if epoch < resume_from_epoch:
                 epoch += 1
@@ -509,16 +561,18 @@ def train(self):
                 # Skip batches if we're resuming mid-epoch
                 if epoch == resume_from_epoch and batch_idx < (resume_from_step % steps_per_epoch):
                     continue
-                
+
                 pbar.write(f"[INFO] Epoch {epoch}, Step {global_step}")
-                input_ids_np = batch['input_ids']
-                position_ids = self.create_position_ids(input_ids_np, padding_idx=self.data_curator.tokenizer.pad_token_id)
+                input_ids_np = batch["input_ids"]
+                position_ids = self.create_position_ids(
+                    input_ids_np, padding_idx=self.data_curator.tokenizer.pad_token_id
+                )
 
                 inputs = {
                     "input_ids": batch["input_ids"],
                     "attention_mask": batch["attention_mask"],
                     "position_ids": position_ids,
-                    "labels": batch['labels']
+                    "labels": batch["labels"],
                 }
 
                 self.model.train()
@@ -529,7 +583,6 @@ def train(self):
                 accumulated_loss += current_loss
 
                 if (global_step + 1) % self.args.grad_accum_steps == 0:
-
                     self.optimizer.step()
                     self.model.lazy_reset_grad()
 
@@ -540,7 +593,7 @@ def train(self):
 
                     # Reset accumulated loss
                     accumulated_loss = 0.0
-                
+
                 self.scheduler.step()
 
                 global_step += 1
@@ -552,22 +605,19 @@ def train(self):
                     "loss": current_loss.item(),
                     "cpu_mem": psutil.Process().memory_info().rss / 1e9,
                     "gpu_mem": torch.cuda.memory_allocated() / 1e9,
-                    "learning_rate": self.optimizer.get_learning_rate()
+                    "learning_rate": self.optimizer.get_learning_rate(),
                 }
 
                 pbar.write(str(step_info))
                 logs.append(step_info)
 
                 if self.args.save_steps and (global_step + 1) % self.args.save_steps == 0:
-                    self.save_checkpoint({
-                        "scheduler_state": self.scheduler.state_dict()
-                    })
+                    self.save_checkpoint({"scheduler_state": self.scheduler.state_dict()})
 
-                
                 if global_step >= total_steps:
                     break
-            
-            if global_step >= total_steps:     
+
+            if global_step >= total_steps:
                 epoch += 1
 
         pbar.close()
@@ -581,35 +631,41 @@ def train(self):
         print(f"\n[INFO] Total training time: {total_runtime:.4f} seconds")
         print(f"[INFO] Training steps per second: {steps_per_second:.4f}")
 
-        logs.append({
-                    "step": global_step,
-                    "epoch": epoch,
-                    "loss": current_loss.item(),
-                    "cpu_mem": psutil.Process().memory_info().rss / 1e9,
-                    "gpu_mem": torch.cuda.memory_allocated() / 1e9,
-                    "train_runtime": total_runtime,
-                    "train_steps_per_second": steps_per_second
-                })
-        
+        logs.append(
+            {
+                "step": global_step,
+                "epoch": epoch,
+                "loss": current_loss.item(),
+                "cpu_mem": psutil.Process().memory_info().rss / 1e9,
+                "gpu_mem": torch.cuda.memory_allocated() / 1e9,
+                "train_runtime": total_runtime,
+                "train_steps_per_second": steps_per_second,
+            }
+        )
+
         # Save logs
         with open(f"{self.training_model_dir}/training_logs.json", mode="w", encoding="utf-8") as f:
             json.dump(logs, f, ensure_ascii=False)
-        
+
         # Training state
 
         # Save the checkpoint and state
-        self.save_checkpoint({
-            "scheduler_state": self.scheduler.state_dict(),
-            "current_global_step": global_step,
-            "current_epoch": epoch,
-        })
+        self.save_checkpoint(
+            {
+                "scheduler_state": self.scheduler.state_dict(),
+                "current_global_step": global_step,
+                "current_epoch": epoch,
+            }
+        )
 
         if self.args.export_inference:
-
             exclude_nodes = ["loss"]
 
             # Model inference: we want to get only logits and hidden states for decoding
-            self.model.export_model_for_inferencing(f"{self.training_model_dir}/{self.inference_model_path}", [ out_name for out_name in self.model.output_names() if out_name not in exclude_nodes])
+            self.model.export_model_for_inferencing(
+                f"{self.training_model_dir}/{self.inference_model_path}",
+                [out_name for out_name in self.model.output_names() if out_name not in exclude_nodes],
+            )
 
             del self.model
             del self.checkpoint_state
@@ -628,11 +684,13 @@ def create_position_ids(self, input_ids: np.ndarray, padding_idx: int = 0):
     def _create_model_name(self) -> str:
         """Create a unique model name based on configuration."""
         # Extract model name from model_id (e.g., "TinyLlama/TinyLlama_v1.1" -> "TinyLlama_v1.1")
-        model_short_name = self.args.model_id.split('/')[-1] if '/' in self.args.model_id else self.args.model_id
-        
+        model_short_name = (
+            self.args.model_id.split("/")[-1] if "/" in self.args.model_id else self.args.model_id
+        )
+
         # Create name pattern: {model_name}-{peft_method}-{dataset}-r{rank}-a{alpha_ratio}
         alpha_ratio = self.args.peft_alpha // self.args.peft_rank if self.args.peft_rank > 0 else 1
-        
+
         return f"{model_short_name}-{self.args.peft_method}-{self.data_curator.dataset_config.value.lower()}-r{self.args.peft_rank}-a{alpha_ratio}"
 
     def save_checkpoint(self, state_data=None):
@@ -655,14 +713,14 @@ def save_training_config(self):
             "dataset": {
                 "name": self.data_curator.dataset_config.name,
                 "dataset_id": self.data_curator.dataset_id,
-                "preprocess_id": self.data_curator.preprocess_id
+                "preprocess_id": self.data_curator.preprocess_id,
             },
             "peft_config": {
                 "method": self.args.peft_method,
                 "rank": self.args.peft_rank,
                 "alpha": self.args.peft_alpha,
                 "target_modules": self.args.peft_target,
-                "trainable_parameter_count": self.args.trainable_parameter_count
+                "trainable_parameter_count": self.args.trainable_parameter_count,
             },
             "training_config": {
                 "max_dataset_length": self.data_curator.max_dataset_length,
@@ -671,178 +729,166 @@ def save_training_config(self):
                 "gradient_accumulation_steps": self.args.grad_accum_steps,
                 "learning_rate": self.args.learning_rate,
                 "num_epochs": self.args.num_train_epochs,
-                "warmup_steps": self.args.warmup_steps
+                "warmup_steps": self.args.warmup_steps,
             },
             "model_name": self.train_model_name,
             "output_dir": self.training_model_dir,
             "seed": self.seed,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
-        
+
         os.makedirs(self.training_model_dir, exist_ok=True)
         config_path = os.path.join(self.training_model_dir, "training_information.json")
-        
-        with open(config_path, 'w') as f:
+
+        with open(config_path, "w") as f:
             json.dump(config, f, indent=2)
-        
+
         print(f"Training information saved to: {config_path}")
 
     def _extract_parameters(self):
         """Extract base layer and adapter parameters from checkpoint state."""
         if self.checkpoint_state is None:
             raise ValueError("Trainer checkpoint state is None. Make sure training has been completed.")
-        
+
         # Get parameters object from checkpoint state
         parameters = self.checkpoint_state.parameters
-        
+
         # Get all parameter names and objects by iterating over parameters
         # Each item is a tuple: (param_name, Parameter object)
         checkpoint_params = list(parameters)
-        
+
         print(f"[INFO] Found {len(checkpoint_params)} parameters in checkpoint")
-        
+
         # Extract base layer parameters (quantized weights, scales, zero_points)
         self._extract_base_layer_params(checkpoint_params)
-        
+
         # Extract adapter parameters
         self._extract_adapter_params(checkpoint_params)
 
         self.create_merged_parameters()
-    
+
     def _extract_base_layer_params(self, checkpoint_params: list):
         """Extract quantized base layer parameters."""
         for base_layer_name in self.peft_mapping.keys():
             base_params = {}
 
-            if base_layer_name.startswith('base_model.model.model.'):
-                base_layer_name = base_layer_name.replace('base_model.model.model.', 'backbone.model.')
-            
+            # One owner for the peft->ORT wrapper rewrite. Spelled inline it read
+            # `base_model.model.model.` -> `backbone.model.`, i.e. a DECODER's first module baked
+            # into a rule that is really about the two WRAPPERS — so it converted nothing for an
+            # encoder (`bert.encoder.layer…`) and every layer then read as missing.
+            base_layer_name = to_checkpoint_name(base_layer_name)
+
             # Look for quantized weight, scale, and zero_point parameters
             weight_quantized_name = f"{base_layer_name}.weight_quantized"
             weight_scale_name = f"{base_layer_name}.weight_scale"
             weight_zero_point_name = f"{base_layer_name}.weight_zero_point"
             weight_noquantized_name = f"{base_layer_name}.weight"
-            
+
             # Iterate through parameter tuples: (param_name, Parameter object)
             for param_name, param_obj in checkpoint_params:
                 if param_name == weight_quantized_name:
-                    base_params['weight_quantized'] = param_obj.data
+                    base_params["weight_quantized"] = param_obj.data
                     print(f"[INFO] Found quantized weight: {param_name}")
                 elif param_name == weight_scale_name:
-                    base_params['x_scale'] = param_obj.data
+                    base_params["x_scale"] = param_obj.data
                     print(f"[INFO] Found weight scale: {param_name}")
                 elif param_name == weight_zero_point_name:
-                    base_params['x_zero_point'] = param_obj.data
+                    base_params["x_zero_point"] = param_obj.data
                     print(f"[INFO] Found weight zero point: {param_name}")
                 elif param_name == weight_noquantized_name:
-                    base_params['weight'] = param_obj.data
+                    base_params["weight"] = param_obj.data
                     print(f"[INFO] Found non-quantized weights: {param_name}")
-            
+
             if base_params:
                 self.base_layer_params[base_layer_name] = base_params
                 print(f"[INFO] Extracted base layer params for: {base_layer_name}")
             else:
                 print(f"[WARNING] No quantized parameters found for base layer: {base_layer_name}")
-    
+
     def _extract_adapter_params(self, checkpoint_params: list):
         """Extract adapter parameters for merging."""
         # Get all unique adapter names from the mapping
 
         self.adapter_params = {}
         for base_layer_name, adapter_names in self.peft_mapping.items():
-
-            # Prefix renaming if needed
-            if base_layer_name.startswith('base_model.model.model.'):
-                base_layer_name = base_layer_name.replace('base_model.model.model.', 'backbone.model.')
+            base_layer_name = to_checkpoint_name(base_layer_name)
 
             if base_layer_name not in self.adapter_params:
                 self.adapter_params[base_layer_name] = {}
 
             for input_name, adapter_name in adapter_names.items():
-
                 # Do not handle non string names, just add them to adapter params
                 if not isinstance(adapter_name, str):
                     self.adapter_params[base_layer_name][input_name] = adapter_name
                     continue
 
-                # Prefix renaming if needed
-                if adapter_name.startswith('base_model.model.model.'):
-                    adapter_name = adapter_name.replace('base_model.model.model.', 'backbone.model.')
+                adapter_name = to_checkpoint_name(adapter_name)
 
-                adapter_name = f'{adapter_name}.weight'
+                adapter_name = f"{adapter_name}.weight"
                 # Iterate through parameter tuples: (param_name, Parameter object)
                 for param_name, param_obj in checkpoint_params:
-
-                    # Prefix renaming if needed
-                    if param_name.startswith('base_model.model.model.'):
-                        param_name = param_name.replace('base_model.model.model.', 'backbone.model.')
+                    param_name = to_checkpoint_name(param_name)
 
                     if adapter_name == param_name:
-
                         self.adapter_params[base_layer_name][input_name] = param_obj.data
 
                         print(f"[INFO] Found adapter param: {param_name}")
-    
-    def get_base_layer_params(self, base_layer_name: str) -> Dict[str, np.ndarray]:
+
+    def get_base_layer_params(self, base_layer_name: str) -> dict[str, np.ndarray]:
         """
         Get quantized parameters for a specific base layer.
-        
+
         Args:
             base_layer_name: Name of the base layer
-            
+
         Returns:
             Dictionary containing weight_quantized, weight_scale, weight_zero_point
         """
         return self.base_layer_params.get(base_layer_name, {})
-    
-    def get_adapter_params(self, adapter_name: str) -> Dict[str, np.ndarray]:
+
+    def get_adapter_params(self, adapter_name: str) -> dict[str, np.ndarray]:
         """
         Get parameters for a specific adapter.
-        
+
         Args:
             adapter_name: Name of the adapter
-            
+
         Returns:
             Dictionary containing adapter parameters
         """
         return self.adapter_params.get(adapter_name, {})
-    
+
     def get_mapping_for_base_layer(self, base_layer_name: str):
         """
         Get the PEFT mapping configuration for a specific base layer.
-        
+
         Args:
             base_layer_name: Name of the base layer
-            
+
         Returns:
             Dictionary containing adapter mappings for the base layer
         """
         return self.peft_mapping.get(base_layer_name, {})
-    
+
     def create_merged_parameters(self):
         self.input_adapter_parameters = {}
         self.output_adapter_parameters = {}
 
         for base_name, base_params in self.base_layer_params.items():
-            self.input_adapter_parameters[base_name] = {
-                **base_params,
-                **self.adapter_params[base_name]
-            }
+            self.input_adapter_parameters[base_name] = {**base_params, **self.adapter_params[base_name]}
 
             self.output_adapter_parameters[base_name] = {}
 
             # Quantized weight output
-            if 'weight_quantized' in self.input_adapter_parameters[base_name]:
+            if "weight_quantized" in self.input_adapter_parameters[base_name]:
                 self.output_adapter_parameters[base_name] = {
-                    'merged_weight_quantized': None,
-                    'merged_zero_point': None,
-                    'merged_scale': None
+                    "merged_weight_quantized": None,
+                    "merged_zero_point": None,
+                    "merged_scale": None,
                 }
             # Full precision weight output
-            elif 'weight' in self.input_adapter_parameters[base_name]:
-                self.output_adapter_parameters[base_name] = {
-                    'merged_weight': None
-                }
+            elif "weight" in self.input_adapter_parameters[base_name]:
+                self.output_adapter_parameters[base_name] = {"merged_weight": None}
 
             # check for None, empty, or empty numpy arrays
             for key, value in self.input_adapter_parameters[base_name].items():
@@ -858,16 +904,15 @@ def create_merged_parameters(self):
                 # convert plain Python ints or floats to numpy arrays
                 if isinstance(value, (int, np.integer)):
                     self.input_adapter_parameters[base_name][key] = np.array(value, dtype=np.int64)
-                    #print(f"[INFO]: Converted {base_name} -> {key} to numpy int64 array")
+                    # print(f"[INFO]: Converted {base_name} -> {key} to numpy int64 array")
 
                 elif isinstance(value, (float, np.floating)):
                     self.input_adapter_parameters[base_name][key] = np.array(value, dtype=np.float32)
-                    #print(f"[INFO]: Converted {base_name} -> {key} to numpy float32 array")
+                    # print(f"[INFO]: Converted {base_name} -> {key} to numpy float32 array")
 
     def _load_peft_mapping(self):
         """Load the training configuration containing PEFT mapping."""
         try:
-            
             self.peft_mapping = self.args.peft_mapping
 
             # 1. Populate self.merger_models
@@ -875,8 +920,7 @@ def _load_peft_mapping(self):
 
             # get all .onnx files ending with merger_model.onnx or qmerger_model.onnx
             all_merger_files = [
-                f for f in os.listdir(self.training_model_dir)
-                if f.endswith("merger_model.onnx")
+                f for f in os.listdir(self.training_model_dir) if f.endswith("merger_model.onnx")
             ]
 
             for fname in all_merger_files:
@@ -909,7 +953,7 @@ def _build_merger_models(self):
                 print(f"Loading {precision} merger model for method {method_name} from {path}")
                 session = ort.InferenceSession(path)
                 self.merger_models[method_name][precision] = session
-    
+
     def clear_merger_models(self):
         """
         Cleanly releases and deletes all loaded merger ONNX inference sessions
@@ -925,10 +969,10 @@ def clear_merger_models(self):
                 # remove references from dictionary
                 self.merger_models[method_name].clear()
             self.merger_models.clear()
-        
+
         print("[INFO] All merger inference sessions cleared from memory.")
 
-    def export_model_for_inference(self, merged_weight_quantized = True, save_directory: str = None):
+    def export_model_for_inference(self, merged_weight_quantized=True, save_directory: str = None):
 
         self.merged_weight_quantized = merged_weight_quantized
         self.merger_models = {}
@@ -942,33 +986,32 @@ def export_model_for_inference(self, merged_weight_quantized = True, save_direct
 
         if self.model is None:
             self.load_onnx_trainer()
-        
+
         # Extract parameters from checkpoint
         self._extract_parameters()
 
         self._build_merger_models()
 
         for base_layer, input_layers in self.input_adapter_parameters.items():
-
             print(f"[DEBUG] Computing merge for base_layer: {base_layer}")
-            
+
             # Print input layer keys and their shapes
             for key, val in input_layers.items():
                 if isinstance(val, np.ndarray):
                     print(f"[DEBUG] Input '{key}' shape: {val.shape}")
                 else:
                     print(f"[WARNING] Input '{key}' is not a numpy array, type={type(val)}")
-            
+
             # Run the MARS merger technique
-            if 'shared_A' in input_layers:
-                self._run_merger_model(self.merger_models['mars'], base_layer, input_layers)
+            if "shared_A" in input_layers:
+                self._run_merger_model(self.merger_models["mars"], base_layer, input_layers)
             # Run the LoRA merger technique
-            elif 'adapter_A' in input_layers:
+            elif "adapter_A" in input_layers:
                 # We do not need rank input here
                 input_layers.pop("rank", None)
-                self._run_merger_model(self.merger_models['lora'], base_layer, input_layers)
+                self._run_merger_model(self.merger_models["lora"], base_layer, input_layers)
 
-        print(f"\n[DEBUG] Finished merging. Output adapter parameters:")
+        print("\n[DEBUG] Finished merging. Output adapter parameters:")
         for base_layer, output_dict in self.output_adapter_parameters.items():
             print(f"  - Base layer: {base_layer}")
             for name, arr in output_dict.items():
@@ -976,111 +1019,111 @@ def export_model_for_inference(self, merged_weight_quantized = True, save_direct
                     print(f"      * {name}: shape={arr.shape}")
                 else:
                     print(f"      * {name}: type={type(arr)} (not a numpy array)")
-        
+
         # Save to disk
         if not save_directory:
             save_directory = os.path.join(self.training_model_dir, "merged")
-        
+
         os.makedirs(save_directory, exist_ok=True)
         for base_layer, output_dict in self.output_adapter_parameters.items():
             save_path = os.path.join(save_directory, f"{base_layer}.npz")
             np.savez(save_path, **output_dict)
             print(f"[INFO] Saved merged parameters for {base_layer} to {save_path}")
-    
+
     def _run_merger_model(self, merger_models: dict, base_layer: str, input_layers: dict):
         """
         Runs the quantized or full precision merger technique of the PEFT method.
         """
 
         session = None
-        
-        if 'weight_quantized' in input_layers:
 
+        if "weight_quantized" in input_layers:
             session = merger_models["quantized"]
 
             if self.merged_weight_quantized:
                 merged_weight_quantized, merged_zero_point, merged_scale = session.run(None, input_layers)
 
-                are_equal = np.array_equal(input_layers['weight_quantized'], merged_weight_quantized)
+                are_equal = np.array_equal(input_layers["weight_quantized"], merged_weight_quantized)
                 print(f"weight quantized are exactly equal: {are_equal}")
 
-                are_equal = np.array_equal(input_layers['x_scale'], merged_scale)
+                are_equal = np.array_equal(input_layers["x_scale"], merged_scale)
                 print(f"x scale are exactly equal: {are_equal}")
 
-                are_equal = np.array_equal(input_layers['x_zero_point'], merged_zero_point)
+                are_equal = np.array_equal(input_layers["x_zero_point"], merged_zero_point)
                 print(f"zero point are exactly equal: {are_equal}")
 
-                #print(input_layers)
+                # print(input_layers)
 
                 # Debug outputs
-                print(f"[DEBUG] merged_weight_quantized shape: {merged_weight_quantized.shape if isinstance(merged_weight_quantized, np.ndarray) else 'not ndarray'}")
-                print(f"[DEBUG] merged_zero_point shape: {merged_zero_point.shape if isinstance(merged_zero_point, np.ndarray) else 'not ndarray'}")
-                print(f"[DEBUG] merged_scale shape: {merged_scale.shape if isinstance(merged_scale, np.ndarray) else 'not ndarray'}")
-                
+                print(
+                    f"[DEBUG] merged_weight_quantized shape: {merged_weight_quantized.shape if isinstance(merged_weight_quantized, np.ndarray) else 'not ndarray'}"
+                )
+                print(
+                    f"[DEBUG] merged_zero_point shape: {merged_zero_point.shape if isinstance(merged_zero_point, np.ndarray) else 'not ndarray'}"
+                )
+                print(
+                    f"[DEBUG] merged_scale shape: {merged_scale.shape if isinstance(merged_scale, np.ndarray) else 'not ndarray'}"
+                )
+
                 if isinstance(merged_weight_quantized, np.ndarray) and merged_weight_quantized.size == 0:
-                    print(f"[WARNING] merged_weight_quantized is empty!")
+                    print("[WARNING] merged_weight_quantized is empty!")
                 if isinstance(merged_zero_point, np.ndarray) and merged_zero_point.size == 0:
-                    print(f"[WARNING] merged_zero_point is empty!")
+                    print("[WARNING] merged_zero_point is empty!")
                 if isinstance(merged_scale, np.ndarray) and merged_scale.size == 0:
-                    print(f"[WARNING] merged_scale is empty!")
+                    print("[WARNING] merged_scale is empty!")
 
                 self.output_adapter_parameters[base_layer] = {
-                    'weight_quantized': merged_weight_quantized,
-                    'weight_scale': merged_scale,
-                    'weight_zero_point': merged_zero_point
+                    "weight_quantized": merged_weight_quantized,
+                    "weight_scale": merged_scale,
+                    "weight_zero_point": merged_zero_point,
                 }
             else:
-
                 merged_weight = session.run(None, input_layers)[0]
-                
+
                 # Debug output
                 print(f"[DEBUG] merged_weight type: {type(merged_weight)}")
                 if isinstance(merged_weight, np.ndarray):
                     print(f"[DEBUG] merged_weight shape: {merged_weight.shape}")
                     if merged_weight.size == 0:
-                        print(f"[WARNING] merged_weight is empty!")
+                        print("[WARNING] merged_weight is empty!")
                 else:
-                    print(f"[WARNING] merged_weight is not a numpy array")
+                    print("[WARNING] merged_weight is not a numpy array")
 
-                self.output_adapter_parameters[base_layer] = {
-                    'weight': merged_weight
-                }
-        
-        elif 'weight' in input_layers:
+                self.output_adapter_parameters[base_layer] = {"weight": merged_weight}
 
+        elif "weight" in input_layers:
             session = merger_models["full_precision"]
 
             merged_weight = session.run(None, input_layers)[0]
-            
+
             # Debug output
             print(f"[DEBUG] merged_weight type: {type(merged_weight)}")
             if isinstance(merged_weight, np.ndarray):
                 print(f"[DEBUG] merged_weight shape: {merged_weight.shape}")
                 if merged_weight.size == 0:
-                    print(f"[WARNING] merged_weight is empty!")
+                    print("[WARNING] merged_weight is empty!")
             else:
-                print(f"[WARNING] merged_weight is not a numpy array")
+                print("[WARNING] merged_weight is not a numpy array")
 
-            self.output_adapter_parameters[base_layer] = {
-                'weight': merged_weight
-            }
+            self.output_adapter_parameters[base_layer] = {"weight": merged_weight}
 
     def print_summary(self):
         """Print a summary of extracted parameters."""
-        print("\n" + "="*50)
+        print("\n" + "=" * 50)
         print("PEFT Merge Validator Summary")
-        print("="*50)
-        
+        print("=" * 50)
+
         print(f"Base layers found: {len(self.base_layer_params)}")
         for base_layer_name, params in self.base_layer_params.items():
             print(f"  - {base_layer_name}: {list(params.keys())}")
-        
+
         print(f"\nAdapters found: {len(self.adapter_params)}")
         for adapter_name, params in self.adapter_params.items():
             print(f"  - {adapter_name}: {list(params.keys())}")
-        
+
         print(f"\nPEFT mappings: {len(self.peft_mapping)}")
 
+
 def check_duplicate_initializers(onnx_model_path):
     """
     Loads an ONNX model and checks if there are duplicate initializers
@@ -1099,16 +1142,16 @@ def check_duplicate_initializers(onnx_model_path):
     duplicate_names = [name for name, count in name_counts.items() if count > 1]
     if duplicate_names:
         print(f"[WARNING] Duplicate initializer names found: {duplicate_names}")
-    
+
     # Check for duplicate initializers with same shape and values
     initializer_dict = defaultdict(list)
     for initializer in model.graph.initializer:
         shape = tuple(initializer.dims)
         values = onnx.numpy_helper.to_array(initializer)
-        
+
         # Convert values to bytes for efficient comparison
         values_bytes = values.tobytes()
-        
+
         initializer_dict[(shape, values_bytes)].append(initializer.name)
 
     duplicate_initializers = {key: names for key, names in initializer_dict.items() if len(names) > 1}
@@ -1120,7 +1163,8 @@ def check_duplicate_initializers(onnx_model_path):
     else:
         print("[INFO] No duplicate initializers with the same shape and values found.")
 
-def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
+
+def parse_extra_options(extra_options: list[str]) -> dict[str, str]:
     """
     Parse additional options in KEY=VALUE format into a dictionary.
     """
@@ -1131,34 +1175,24 @@ def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
             options_dict[key] = value
         else:
             raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
-        
+
     print(f"Extra options: {options_dict}")
     return options_dict
 
-def load_config_from_file(config_file: str):
-    """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
-        config = yaml.safe_load(file)
-    return config
 
 def parse_arguments():
-    parser = argparse.ArgumentParser(description="Validator for exported ONNX artifacts for on-device training.", formatter_class=argparse.RawTextHelpFormatter)
-
-    parser.add_argument(
-        "--model_id",
-        type=str,
-        help="Identifier for the model to be converted."
+    parser = argparse.ArgumentParser(
+        description="Validator for exported ONNX artifacts for on-device training.",
+        formatter_class=argparse.RawTextHelpFormatter,
     )
+
+    parser.add_argument("--model_id", type=str, help="Identifier for the model to be converted.")
     parser.add_argument(
         "--config_file",
         type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
-    )
-    parser.add_argument(
-        "--training_artifact_dir",
-        type=str,
-        help="Path to training artifact directory."
+        help="Path to configuration file to load additional options. This config file will overwrite all other arguments.",
     )
+    parser.add_argument("--training_artifact_dir", type=str, help="Path to training artifact directory.")
     parser.add_argument(
         "--test_training_config",
         type=str,
@@ -1168,8 +1202,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ...
-            """
-            )
+            """),
     )
     parser.add_argument(
         "--test_scheduler_config",
@@ -1180,8 +1213,7 @@ def parse_arguments():
         help=textwrap.dedent("""\
          Key value pairs for various options. Currently supports:
             ...
-            """
-            )
+            """),
     )
     args = parser.parse_args()
 
@@ -1201,17 +1233,17 @@ def parse_arguments():
         "testRatio": 0.1,
         "split": True,
         "shuffle": True,
-        "schedulerType": "cosine"
+        "schedulerType": "cosine",
     }
 
     user_scheduler_generation_config = {}
     default_scheduler_generation_config = {
-       "minLearningRate": 0,
-       "cosineLearningRate": 0.0001,
-       "warmupSteps": 10,
-       "linearLearningRate": 0.0001,
-       "startFactor": 1,
-       "endFactor": 0.333
+        "minLearningRate": 0,
+        "cosineLearningRate": 0.0001,
+        "warmupSteps": 10,
+        "linearLearningRate": 0.0001,
+        "startFactor": 1,
+        "endFactor": 0.333,
     }
 
     config_dict = None
@@ -1220,13 +1252,14 @@ def parse_arguments():
         config_dict = load_config_from_file(args.config_file)
 
         # Specific
-        setattr(args, "model_id", config_dict[TRAIN_CONFIG]["model_id"])
-        setattr(args, "training_artifact_dir", os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "train"))
-        setattr(args, "test_scheduler_config", config_dict[ARTIFACT_VALIDATOR_CONFIG]["test_training_config"]["schedulerOptions"])
-        
+        args.model_id = config_dict[TRAIN_CONFIG]["model_id"]
+        args.training_artifact_dir = os.path.join(config_dict[ARTIFACT_CONFIG]["build_path"], "train")
+        args.test_scheduler_config = config_dict[ARTIFACT_VALIDATOR_CONFIG]["test_training_config"][
+            "schedulerOptions"
+        ]
+
         # Override any command-line argument with values from the config file
         for key, value in config_dict[ARTIFACT_VALIDATOR_CONFIG].items():
-            
             # Convert to the correct type
             if hasattr(args, key):
                 setattr(args, key, value)
@@ -1235,15 +1268,17 @@ def parse_arguments():
         user_train_generation_config = parse_extra_options(args.test_training_config)
         args.test_training_config = {**default_train_generation_config, **user_train_generation_config}
         user_scheduler_generation_config = parse_extra_options(args.test_scheduler_config)
-        args.test_scheduler_config = {**default_scheduler_generation_config, **user_scheduler_generation_config}
+        args.test_scheduler_config = {
+            **default_scheduler_generation_config,
+            **user_scheduler_generation_config,
+        }
 
     return args
 
 
 if __name__ == "__main__":
-    
     trainer = ORTTrainer("build/train-tinyllama-lora-r8", load_from_state=False)
 
     trainer.train()
 
-    #trainer.export_model_for_inference(merged_weight_quantized=False)
\ No newline at end of file
+    # trainer.export_model_for_inference(merged_weight_quantized=False)
diff --git a/src/mobiletransformers/utils/__init__.py b/src/mobiletransformers/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mobiletransformers/utils/logging.py b/src/mobiletransformers/utils/logging.py
new file mode 100644
index 0000000..1424f0e
--- /dev/null
+++ b/src/mobiletransformers/utils/logging.py
@@ -0,0 +1,40 @@
+"""Structured, module-level logging for library code.
+
+Use ``logger = get_logger(__name__)`` per module and log at levels — never ``print()`` inside the
+library (user-facing CLI output stays in ``cli/``). The library attaches a ``NullHandler`` to its
+root logger (PEP-recommended) so importing it never configures the application's logging; apps opt in
+via ``configure_logging()`` or their own handlers.
+"""
+
+from __future__ import annotations
+
+import logging
+
+_ROOT_NAME = "mobiletransformers"
+
+# PEP 282 / library best practice: a NullHandler so we never emit unless the app configures logging.
+logging.getLogger(_ROOT_NAME).addHandler(logging.NullHandler())
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a module logger under the ``mobiletransformers`` namespace.
+
+    Pass ``__name__``; a non-package name is namespaced under ``mobiletransformers.`` so all library
+    loggers share one configurable root.
+    """
+    if name == "__main__" or not name.startswith(_ROOT_NAME):
+        name = f"{_ROOT_NAME}.{name}"
+    return logging.getLogger(name)
+
+
+def configure_logging(level: int = logging.INFO) -> None:
+    """Opt-in convenience: attach a basic stream handler to the library root (for CLI/dev use)."""
+    root = logging.getLogger(_ROOT_NAME)
+    if not any(not isinstance(h, logging.NullHandler) for h in root.handlers):
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+        root.addHandler(handler)
+    root.setLevel(level)
+
+
+__all__ = ["get_logger", "configure_logging"]
diff --git a/src/mobiletransformers/utils/paths.py b/src/mobiletransformers/utils/paths.py
new file mode 100644
index 0000000..e4155a6
--- /dev/null
+++ b/src/mobiletransformers/utils/paths.py
@@ -0,0 +1,76 @@
+"""Filesystem helpers for moving/removing exported artifacts.
+
+Migrated from ``tools/utils.py`` (Migration Map S1). Deliberately dependency-free — these are used by
+the export path, which must stay importable in the core environment.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+
+
+def move_onnx_model(model_path, destination_dir, delete=False):
+    """
+    Move or copy ONNX model and its data file to a new destination directory.
+
+    Args:
+        model_path (str): Path to the .onnx model file
+        destination_dir (str): Destination directory path
+        delete (bool): If True, move files (delete from source). If False, copy files.
+
+    Returns:
+        str: Path to the .onnx file in the new location
+    """
+    # Create destination directory if it doesn't exist
+    os.makedirs(destination_dir, exist_ok=True)
+
+    # Get the model filename
+    model_filename = os.path.basename(model_path)
+    destination_model_path = os.path.join(destination_dir, model_filename)
+
+    # Move or copy the .onnx file
+    if os.path.exists(model_path):
+        if delete:
+            shutil.move(model_path, destination_model_path)
+            print(f"✓ Moved {model_filename} to {destination_dir}")
+        else:
+            shutil.copy2(model_path, destination_model_path)
+            print(f"✓ Copied {model_filename} to {destination_dir}")
+    else:
+        raise FileNotFoundError(f"Model file not found: {model_path}")
+
+    # Check for and move/copy .onnx.data file
+    data_path = model_path + ".data"
+    if os.path.exists(data_path):
+        data_filename = os.path.basename(data_path)
+        destination_data_path = os.path.join(destination_dir, data_filename)
+        if delete:
+            shutil.move(data_path, destination_data_path)
+            print(f"✓ Moved {data_filename} to {destination_dir}")
+        else:
+            shutil.copy2(data_path, destination_data_path)
+            print(f"✓ Copied {data_filename} to {destination_dir}")
+
+    return destination_model_path
+
+
+def move_files_excluding(source_dir, target_dir, exclude_files):
+    os.makedirs(target_dir, exist_ok=True)
+
+    for filename in os.listdir(source_dir):
+        source_file = os.path.join(source_dir, filename)
+        target_file = os.path.join(target_dir, filename)
+
+        if os.path.isfile(source_file) and not any(ef in filename for ef in exclude_files):
+            shutil.move(source_file, target_file)
+
+
+def delete_directory(directory_path):
+    if os.path.exists(directory_path) and os.path.isdir(directory_path):
+        try:
+            shutil.rmtree(directory_path)
+        except Exception as e:
+            print(f"Error: {e}")
+    else:
+        print(f"Directory '{directory_path}' does not exist.")
diff --git a/src/mobiletransformers/utils/templating.py b/src/mobiletransformers/utils/templating.py
new file mode 100644
index 0000000..f68f03d
--- /dev/null
+++ b/src/mobiletransformers/utils/templating.py
@@ -0,0 +1,36 @@
+"""Chat-template rendering (Jinja).
+
+Migrated from ``tools/utils.py`` (Migration Map S1).
+"""
+
+from __future__ import annotations
+
+
+def create_chat_input(query_prompt, config, add_generation_prompt=True):
+
+    # Extract key parts of the config
+    chat_template = config["chat_template"]
+    eos_token = config["eos_token"]
+
+    # Construct messages for template rendering
+    # Simulating a simple conversation setup here with roles: system, user, assistant
+    messages = [{"role": "user", "content": query_prompt}]
+
+    # Define a rendering context for the chat template
+    rendering_context = {
+        "messages": messages,
+        "add_generation_prompt": add_generation_prompt,
+        "eos_token": eos_token,
+    }
+
+    # Render the chat template using the rendering context
+    chat_input = render_template(chat_template, rendering_context)
+    return chat_input
+
+
+def render_template(template_str, context):
+    """Render the chat template string with Jinja-style template logic"""
+    from jinja2 import Template  # noqa: PLC0415
+
+    template = Template(template_str)
+    return template.render(context)
diff --git a/src/mobiletransformers/utils/yaml.py b/src/mobiletransformers/utils/yaml.py
new file mode 100644
index 0000000..0eac6a8
--- /dev/null
+++ b/src/mobiletransformers/utils/yaml.py
@@ -0,0 +1,28 @@
+"""Shared YAML loading helper — the single ``load_config_from_file``.
+
+The consolidation is **done** (2026-08-14). Four byte-identical private copies
+(``artifacts/builder.py``, ``artifacts/validation.py``, ``training/merge_validators.py``,
+``training/validators.py``) now import this one.
+
+Two copies deliberately did not merge:
+
+* ``export/training_export.py`` pre-indexed into ``config[TRAIN_CONFIG]``, so it returned the *train
+  section* rather than the whole document. Silently repointing it here would have changed what every
+  call site receives, which is what the config-layering deferral note warned about. It is renamed
+  ``load_train_config_from_file`` and is now a thin wrapper over this loader.
+* ``inference/builder.py`` keeps its own copy: it is the vendored GenAI graph builder, treated as
+  upstream (and allow-listed as such in ``tests/unit/test_guards.py``).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def load_config_from_file(config_file: str | Path) -> dict[str, Any]:
+    """Load a YAML file into a dict (raw ``yaml.safe_load`` of the whole document)."""
+    with open(config_file) as f:
+        return yaml.safe_load(f)
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/adapter/__init__.py b/tests/adapter/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/adapter/_helpers.py b/tests/adapter/_helpers.py
new file mode 100644
index 0000000..f82eee3
--- /dev/null
+++ b/tests/adapter/_helpers.py
@@ -0,0 +1,60 @@
+"""Build synthetic materialized-cache dirs for #22 adapter tests (the tiny_package train/ is too thin)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mobiletransformers.artifacts.handoff_map import HandoffEntry, HandoffMap
+
+TRAINABLE = "model.layers.0.attn.q_proj.MatMul.weight"
+BASE_LAYER = "backbone.model.layers.0.self_attn.q_proj.base_layer"
+
+
+def make_cache(
+    root: Path,
+    *,
+    peft_method: str,
+    component_roles: dict[str, str],
+    rank: int | None = 8,
+    alpha: float | None = 16.0,
+    model_id: str = "org/base-model",
+) -> Path:
+    """Create ``<root>/{train,inference}`` with a training_config, handoff map, and one merged .bin.
+
+    ``component_roles`` maps adapter-role -> checkpoint tensor name (e.g. {"adapter_A": "...lora_A"}).
+    Include them to simulate a checkpoint that still carries the A/B factors (Mode-1 eligible).
+    """
+    (root / "train").mkdir(parents=True, exist_ok=True)
+    (root / "inference").mkdir(parents=True, exist_ok=True)
+
+    checkpoint_names = {"weight": f"{BASE_LAYER}.weight", **component_roles}
+    entry = HandoffEntry(
+        training_base_layer_name=BASE_LAYER,
+        dtype="float32",
+        shape=(4, 3),
+        checkpoint_names=checkpoint_names,
+        merger_output_names={"weight": "merged_weight"},
+        merged_tensor_names={"weight": TRAINABLE},
+        inference_initializer_names={"weight": TRAINABLE},
+        external_data_location={"weight": f"{TRAINABLE}.bin"},
+    )
+    (root / "train" / "weight_handoff_map.json").write_text(HandoffMap(entries=[entry]).to_json())
+
+    cfg: dict = {
+        "modelId": model_id,
+        "peftMethod": peft_method,
+        "peft_target": ["q_proj"],
+        "trainable_parameter_count": 42,
+    }
+    if rank is not None:
+        cfg["rank"] = rank
+    if alpha is not None:
+        cfg["alpha"] = alpha
+    if peft_method == "mars":
+        cfg["optimization_level"] = 2
+    (root / "train" / "training_config.json").write_text(json.dumps(cfg, indent=2))
+
+    (root / "inference" / f"{TRAINABLE}.bin").write_text("MERGED_TENSOR_BYTES\n")
+    (root / "inference" / f"{TRAINABLE}.bin.sha256").write_text("0" * 64 + "\n")
+    return root
diff --git a/tests/adapter/test_convert.py b/tests/adapter/test_convert.py
new file mode 100644
index 0000000..4d84b6b
--- /dev/null
+++ b/tests/adapter/test_convert.py
@@ -0,0 +1,117 @@
+"""#22 export + PEFT-vs-native gate + adapter card (pure Python, no torch/peft)."""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.adapter.convert import materialize_peft_weights, to_peft_layout
+from mobiletransformers.adapter.export import export_adapter_from_cache
+from mobiletransformers.adapter.model_card import assert_required_sections, render_adapter_card
+from mobiletransformers.exceptions import ExportError
+from tests.adapter._helpers import TRAINABLE, make_cache
+
+_LORA_ROLES = {"adapter_A": "l.lora_A", "adapter_B": "l.lora_B"}
+_MARS_ROLES = {"shared_A": "m.shared_A", "adapter_B": "m.mars_B"}
+
+
+def test_export_builds_package_from_cache(tmp_path):
+    cache = make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    pkg = export_adapter_from_cache(cache)
+    assert pkg.base_model_id == "org/base-model"
+    assert pkg.peft_method == "lora" and pkg.rank == 8 and pkg.alpha == 16.0
+    assert set(pkg.checkpoint_component_roles) == {"adapter_A", "adapter_B"}
+    assert any(t.external_data_location == f"{TRAINABLE}.bin" for t in pkg.tensors)
+
+
+def test_lora_with_factors_gates_to_peft(tmp_path):
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    )
+    layout = to_peft_layout(pkg)
+    assert layout is not None
+    assert layout.adapter_config["peft_type"] == "LORA"
+    assert layout.adapter_config["r"] == 8 and layout.adapter_config["lora_alpha"] == 16.0
+    assert layout.adapter_config["base_model_name_or_path"] == "org/base-model"
+
+
+def test_lora_without_factors_falls_to_native(tmp_path):
+    # Checkpoint no longer carries A/B factors (only the merged weight) -> None (native mode).
+    pkg = export_adapter_from_cache(make_cache(tmp_path / "c", peft_method="lora", component_roles={}))
+    assert to_peft_layout(pkg) is None
+
+
+def test_mars_never_peft(tmp_path):
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="mars", component_roles=_MARS_ROLES)
+    )
+    assert pkg.mars_optimization_level == 2
+    assert to_peft_layout(pkg) is None
+
+
+def test_missing_rank_alpha_falls_to_native(tmp_path):
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES, rank=None, alpha=None)
+    )
+    assert to_peft_layout(pkg) is None
+
+
+def test_adapter_card_has_mandatory_sections(tmp_path):
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    )
+    card = render_adapter_card(pkg, mode="peft", base_model_license="Apache-2.0")
+    assert "Privacy warning" in card
+    assert "Apache-2.0" in card
+    assert "lora" in card and "Rank: 8" in card
+    assert_required_sections(card, pkg)  # no raise
+
+
+def test_adapter_card_assert_fails_on_missing_section(tmp_path):
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    )
+    with pytest.raises(ExportError, match="privacy warning"):
+        assert_required_sections("no disclosures here", pkg)
+
+
+def test_materialize_peft_weights_writes_safetensors(tmp_path):
+    """The numpy->torch->safetensors path with an injected factor reader (no ORT checkpoint needed)."""
+    np = pytest.importorskip("numpy")
+    st = pytest.importorskip("safetensors")  # ensures torch+safetensors present
+    pytest.importorskip("torch")
+
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    )
+    layout = to_peft_layout(pkg)
+    assert layout is not None
+
+    factors = {
+        "l.lora_A": np.arange(8 * 3, dtype=np.float32).reshape(8, 3),  # (rank, in_features)
+        "l.lora_B": np.arange(4 * 8, dtype=np.float32).reshape(4, 8),  # (out_features, rank)
+    }
+    dest = tmp_path / "out"
+    materialize_peft_weights(pkg, layout, str(dest), factor_reader=lambda _dir, _names: factors)
+
+    from safetensors.numpy import load_file
+
+    loaded = load_file(str(dest / "adapter_model.safetensors"))
+    prefix = "base_model.model.model.layers.0.self_attn.q_proj"
+    assert set(loaded) == {f"{prefix}.lora_A.weight", f"{prefix}.lora_B.weight"}
+    assert np.array_equal(loaded[f"{prefix}.lora_A.weight"], factors["l.lora_A"])
+    assert np.array_equal(loaded[f"{prefix}.lora_B.weight"], factors["l.lora_B"])
+    _ = st
+
+
+def test_materialize_peft_weights_fails_closed_on_missing_factor(tmp_path):
+    pytest.importorskip("numpy")
+    pytest.importorskip("safetensors")
+    pytest.importorskip("torch")
+
+    pkg = export_adapter_from_cache(
+        make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA_ROLES)
+    )
+    layout = to_peft_layout(pkg)
+    assert layout is not None
+    with pytest.raises(ExportError, match="missing required LoRA factor"):
+        materialize_peft_weights(pkg, layout, str(tmp_path / "out"), factor_reader=lambda _d, _n: {})
diff --git a/tests/adapter/test_push_adapter.py b/tests/adapter/test_push_adapter.py
new file mode 100644
index 0000000..ead2280
--- /dev/null
+++ b/tests/adapter/test_push_adapter.py
@@ -0,0 +1,92 @@
+"""#22 push-adapter CLI: PEFT (Mode 1) / native (Mode 2) / --peft-only / injected upload."""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.cli import push_adapter as pa
+from mobiletransformers.cli.main import build_parser
+from mobiletransformers.exceptions import MobileTransformersError
+from tests.adapter._helpers import TRAINABLE, make_cache
+
+_LORA = {"adapter_A": "l.lora_A", "adapter_B": "l.lora_B"}
+_MARS = {"shared_A": "m.shared_A", "adapter_B": "m.mars_B"}
+
+
+def _args(cache, repo="org/adp", extra=None):
+    argv = ["push-adapter", "--cache-repo", str(cache), "--repo-id", repo, "--base-license", "Apache-2.0"]
+    argv += extra or []
+    return build_parser().parse_args(argv)
+
+
+def test_lora_dry_run_builds_peft_adapter(tmp_path):
+    cache = make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA)
+    args = _args(cache, extra=["--dry-run"])
+    assert args.func(args) == 0
+    out = cache / ".adapter-push"
+    assert (out / "adapter_config.json").is_file()
+    assert (out / "README.md").is_file()
+    assert "Privacy warning" in (out / "README.md").read_text()
+
+
+def test_lora_dry_run_reports_unmaterialized_weights(tmp_path, capsys):
+    """In the core env (no torch/safetensors) the dry run must SAY the weights are missing."""
+    cache = make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA)
+    args = _args(cache, extra=["--dry-run"])
+    assert args.func(args) == 0
+    out = cache / ".adapter-push"
+    if not (out / "adapter_model.safetensors").is_file():
+        assert "adapter_model.safetensors NOT materialized" in capsys.readouterr().out
+
+
+def test_peft_upload_without_weights_fails_closed(tmp_path):
+    """#22 regression: a Mode-1 push used to publish adapter_config.json with NO weights.
+
+    `PeftModel.from_pretrained` cannot load such a repo, and the failure was invisible because the
+    materialization step was simply skipped with a comment. Outside the `train` profile the upload
+    must now refuse rather than publish an unusable adapter.
+    """
+    if _train_profile_available():
+        pytest.skip("train profile present; materialization succeeds, see test_convert.py")
+    cache = make_cache(tmp_path / "c", peft_method="lora", component_roles=_LORA)
+    args = _args(cache)  # no --dry-run
+    with pytest.raises(MobileTransformersError, match="without adapter_model.safetensors"):
+        pa.run(args, uploader=lambda **kw: None)
+
+
+def _train_profile_available() -> bool:
+    return (
+        importlib.util.find_spec("torch") is not None and importlib.util.find_spec("safetensors") is not None
+    )
+
+
+def test_mars_dry_run_builds_native_adapter(tmp_path):
+    cache = make_cache(tmp_path / "c", peft_method="mars", component_roles=_MARS)
+    args = _args(cache, extra=["--dry-run"])
+    assert args.func(args) == 0
+    out = cache / ".adapter-push"
+    assert (out / "mobiletransformers_adapter.json").is_file()
+    assert (out / f"{TRAINABLE}.bin").is_file()  # merged tensor copied
+    assert (out / "weight_handoff_map.json").is_file()
+    assert not (out / "adapter_config.json").exists()
+
+
+def test_peft_only_errors_on_mars(tmp_path):
+    cache = make_cache(tmp_path / "c", peft_method="mars", component_roles=_MARS)
+    args = _args(cache, extra=["--dry-run", "--peft-only"])
+    assert args.func(args) == 1
+
+
+def test_upload_via_injected_uploader(tmp_path):
+    # Mode 2 (native): copies merged .bin files straight out of the cache, so the upload path is
+    # exercisable in the core env. Mode 1 needs the train profile to produce its weights.
+    cache = make_cache(tmp_path / "c", peft_method="mars", component_roles=_MARS)
+    args = _args(cache)  # no --dry-run
+    calls = {}
+    rc = pa.run(args, uploader=lambda **kw: calls.update(kw))
+    assert rc == 0
+    assert calls["repo_id"] == "org/adp"
+    assert Path(calls["folder_path"]) == cache / ".adapter-push"
diff --git a/tests/cli/__init__.py b/tests/cli/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/cli/test_cli.py b/tests/cli/test_cli.py
new file mode 100644
index 0000000..dd6d399
--- /dev/null
+++ b/tests/cli/test_cli.py
@@ -0,0 +1,317 @@
+"""#15 CLI: export dry-run + push validate/dry-run/upload (injected). No network, no heavy deps."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from mobiletransformers.cli import export as export_cli
+from mobiletransformers.cli import push as push_cli
+from mobiletransformers.cli.main import build_parser, main
+
+PKG = Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package"
+
+
+def test_export_dry_run_prints_plan(tmp_path, capsys):
+    code = main(
+        [
+            "export",
+            "--model",
+            "org/tiny",
+            "--output",
+            str(tmp_path / "out"),
+            "--task",
+            "text-generation-with-past",
+            "--peft",
+            "mars-opt1",
+            "--quant",
+            "int4",
+            "--dry-run",
+        ]
+    )
+    assert code == 0
+    out = capsys.readouterr().out
+    assert "[dry-run]" in out and "cpu-int4" in out
+    assert not (tmp_path / "out").exists()
+
+
+def test_export_registers_push_and_help_lists_it():
+    parser = build_parser()
+    # push subcommand is registered
+    ns = parser.parse_args(["push", "--package", "p", "--repo", "r", "--dry-run"])
+    assert ns.command == "push" and ns.func is push_cli.run
+
+
+def test_push_dry_run_validates_and_writes_card(tmp_path):
+    pkg = tmp_path / "pkg"
+    shutil.copytree(PKG, pkg)
+    args = build_parser().parse_args(["push", "--package", str(pkg), "--repo", "org/x", "--dry-run"])
+    assert args.func(args) == 0
+    assert (pkg / "README.md").exists()
+    assert "MobileTransformers package" in (pkg / "README.md").read_text()
+
+
+def test_push_uploads_via_injected_uploader(tmp_path):
+    pkg = tmp_path / "pkg"
+    shutil.copytree(PKG, pkg)
+    args = build_parser().parse_args(["push", "--package", str(pkg), "--repo", "org/x"])
+    calls = {}
+    push_cli.run(args, uploader=lambda **kw: calls.update(kw))
+    assert calls["repo_id"] == "org/x" and Path(calls["folder_path"]) == pkg
+
+
+def test_push_aborts_on_invalid_package(tmp_path):
+    pkg = tmp_path / "pkg"
+    shutil.copytree(PKG, pkg)
+    # Corrupt: point defaultVariant at a nonexistent variant.
+    mpath = pkg / "mobiletransformers_manifest.json"
+    data = json.loads(mpath.read_text())
+    data["defaultVariant"] = "ghost"
+    mpath.write_text(json.dumps(data))
+    args = build_parser().parse_args(["push", "--package", str(pkg), "--repo", "org/x", "--dry-run"])
+    assert args.func(args) == 1  # fail closed before upload
+
+
+# --- federated (#35) — the subcommand had zero CLI coverage ---------------------------------------
+def test_federated_is_registered_in_the_parser():
+    """`cli/main.py` registers it, but `docs/PUBLIC_API.md`'s table omitted it — pin the wiring."""
+    parser = build_parser()
+    args = parser.parse_args(
+        ["federated", "simulate", "--package", "pkg", "--output", "out", "--clients", "3"]
+    )
+    assert args.clients == 3
+    assert args.output == "out"
+    assert callable(args.func)
+
+
+def test_federated_simulate_fails_closed_on_a_missing_package(tmp_path, capsys):
+    parser = build_parser()
+    args = parser.parse_args(
+        ["federated", "simulate", "--package", str(tmp_path / "nope"), "--output", str(tmp_path / "o")]
+    )
+    assert args.func(args) == 1
+    assert "federated simulate failed" in capsys.readouterr().out
+
+
+def test_federated_simulate_rejects_an_unknown_strategy(tmp_path, capsys):
+    """v1 supports fedavg only; anything else must fail rather than silently fall back."""
+    parser = build_parser()
+    args = parser.parse_args(
+        [
+            "federated",
+            "simulate",
+            "--package",
+            str(tmp_path),
+            "--output",
+            str(tmp_path / "o"),
+            "--strategy",
+            "fedprox",
+        ]
+    )
+    assert args.func(args) == 1
+
+
+# --- export --config overlay + --validate (#15) ---------------------------------------------------
+def _export_args(argv):
+    return build_parser().parse_args(["export", *argv])
+
+
+def test_export_config_overlay_supplies_unset_knobs(tmp_path):
+    """`--config` was accepted and silently dropped while docs/EXPORT.md documented it as working.
+
+    Exercised through the pure overlay rather than a full dry-run: task discovery imports
+    `transformers`, which the core env deliberately does not install.
+    """
+    cfg = tmp_path / "export.yml"
+    cfg.write_text("export:\n  model: org/from-yaml\n  output: out-from-yaml\n  peft: mars\n  rank: 16\n")
+    args = _export_args(["--config", str(cfg)])
+    export_cli._apply_config_overlay(args)
+    assert args.model == "org/from-yaml"
+    assert args.output == "out-from-yaml"
+    assert args.peft == "mars"
+    assert args.rank == 16
+
+
+def test_export_config_accepts_a_top_level_mapping_too(tmp_path):
+    cfg = tmp_path / "export.yml"
+    cfg.write_text("model: org/flat\noutput: o\nquant: fp16\n")
+    args = _export_args(["--config", str(cfg)])
+    export_cli._apply_config_overlay(args)
+    assert args.model == "org/flat"
+    assert args.quant == "fp16"
+
+
+def test_export_cli_flags_win_over_the_config(tmp_path):
+    """Documented precedence is CLI > YAML > default."""
+    cfg = tmp_path / "export.yml"
+    cfg.write_text("export:\n  model: org/from-yaml\n  output: o\n  peft: mars\n  rank: 32\n")
+    args = _export_args(["--config", str(cfg), "--model", "org/from-cli", "--peft", "lora-xs"])
+    export_cli._apply_config_overlay(args)
+    assert args.model == "org/from-cli"
+    assert args.peft == "lora-xs"
+    assert args.rank == 32  # not passed on the CLI, so the YAML value still applies
+
+
+def test_export_config_rejects_unknown_keys(tmp_path, capsys):
+    cfg = tmp_path / "export.yml"
+    cfg.write_text("export:\n  model: m\n  output: o\n  nonsense: 1\n")
+    args = _export_args(["--config", str(cfg), "--dry-run"])
+    assert args.func(args) == 1
+    assert "unknown export key" in capsys.readouterr().out
+
+
+def test_export_requires_model_from_some_source(capsys):
+    args = _export_args(["--output", "o", "--dry-run"])
+    assert args.func(args) == 1
+    assert "--model is required" in capsys.readouterr().out
+
+
+def test_validate_subcommand_reports_a_missing_package(tmp_path, capsys):
+    """The stub used to print 'not yet wired' and return 0 for ANY input, including nonexistent ones."""
+    args = build_parser().parse_args(["validate", "--package", str(tmp_path / "absent")])
+    assert args.func(args) == 1
+    assert "validation failed" in capsys.readouterr().out
+
+
+def test_validate_subcommand_accepts_the_tiny_fixture_package(capsys):
+    pkg = Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package"
+    args = build_parser().parse_args(["validate", "--package", str(pkg)])
+    assert args.func(args) == 0
+    assert "package OK" in capsys.readouterr().out
+
+
+def test_validate_rejects_a_directory_without_a_manifest(tmp_path, capsys):
+    (tmp_path / "empty").mkdir()
+    args = build_parser().parse_args(["validate", "--package", str(tmp_path / "empty")])
+    assert args.func(args) == 1
+    assert "no mobiletransformers_manifest.json" in capsys.readouterr().out
+
+
+# --- package-model: was a stub that printed "not yet wired" and returned 0 --------------------
+
+
+def test_package_model_fails_closed_on_a_missing_package(tmp_path, capsys):
+    """The whole point of the rewrite: a package that does not exist must NOT report success."""
+    code = main(["package-model", "--package", str(tmp_path / "nope")])
+    assert code == 1
+    assert "not a package directory" in capsys.readouterr().out
+
+
+def test_package_model_fails_closed_without_a_manifest(tmp_path, capsys):
+    bare = tmp_path / "bare"
+    bare.mkdir()
+    code = main(["package-model", "--package", str(bare)])
+    assert code == 1
+    assert "mobiletransformers_manifest.json" in capsys.readouterr().out
+
+
+def test_package_model_requires_a_package_argument(capsys):
+    assert main(["package-model"]) == 2
+    assert "--package" in capsys.readouterr().out
+
+
+def test_package_model_dry_run_writes_nothing(tmp_path, capsys):
+    pkg = tmp_path / "pkg"
+    shutil.copytree(PKG, pkg)
+    before = json.loads((pkg / "mobiletransformers_manifest.json").read_text())
+    assert main(["package-model", "--package", str(pkg), "--dry-run"]) == 0
+    assert json.loads((pkg / "mobiletransformers_manifest.json").read_text()) == before
+    assert "would re-emit" in capsys.readouterr().out
+
+
+def test_package_model_reemits_the_integrity_block(tmp_path):
+    """Re-emitting over an unchanged tree is a no-op; over a changed one it re-hashes."""
+    pkg = tmp_path / "pkg"
+    shutil.copytree(PKG, pkg)
+    manifest_path = pkg / "mobiletransformers_manifest.json"
+    original = json.loads(manifest_path.read_text())
+
+    assert main(["package-model", "--package", str(pkg)]) == 0
+    unchanged = json.loads(manifest_path.read_text())
+    assert unchanged["sha256"] == original["sha256"]
+    assert unchanged["baseModelId"] == original["baseModelId"]
+
+    # Change a file the manifest hashes; the re-emit must notice.
+    target = next(rel for rel in original["sha256"] if rel.endswith("generation_config.json"))
+    (pkg / target).write_text('{"max_length": 999}\n')
+    assert main(["package-model", "--package", str(pkg)]) == 0
+    rehashed = json.loads(manifest_path.read_text())
+    assert rehashed["sha256"][target] != original["sha256"][target]
+    assert rehashed["fileSizes"][target] == (pkg / target).stat().st_size
+
+
+# --- agent-dataset (#37): import a tool-call corpus, or synthesise a per-user one -------------
+
+AGENT_FIXTURE = Path(__file__).resolve().parents[1] / "fixtures" / "agent" / "mobile_actions_sample.jsonl"
+
+
+def test_agent_dataset_imports_a_corpus(tmp_path, capsys):
+    code = main(["agent-dataset", "--source", str(AGENT_FIXTURE), "--output", str(tmp_path)])
+    assert code == 0
+
+    rows = [json.loads(line) for line in (tmp_path / "mobile_actions.jsonl").read_text().splitlines()]
+    assert rows and all(set(r) == {"prompt", "completion"} for r in rows)
+
+    schema = json.loads((tmp_path / "action_schema.json").read_text())
+    assert {a["actionName"] for a in schema} >= {"send_email", "show_map"}
+
+    out = capsys.readouterr().out
+    assert "wrote" in out
+    # Unmapped actions are announced, not silently emitted with an empty intent.
+    assert "no Android intent mapped" in out and "flashlight" in out
+
+
+def test_agent_dataset_dry_run_writes_nothing(tmp_path, capsys):
+    assert (
+        main(["agent-dataset", "--source", str(AGENT_FIXTURE), "--output", str(tmp_path), "--dry-run"]) == 0
+    )
+    assert not list(tmp_path.iterdir())
+    assert "[dry-run]" in capsys.readouterr().out
+
+
+def test_agent_dataset_limit_is_deterministic(tmp_path):
+    def build(where):
+        main(["agent-dataset", "--source", str(AGENT_FIXTURE), "--output", str(where), "--limit", "2"])
+        return (where / "mobile_actions.jsonl").read_text()
+
+    assert build(tmp_path / "a") == build(tmp_path / "b")
+    assert len(build(tmp_path / "c").strip().splitlines()) == 2
+
+
+def test_agent_dataset_generated_requires_an_allowlist(tmp_path, capsys):
+    assert main(["agent-dataset", "--source", "generated", "--output", str(tmp_path)]) == 1
+    assert "requires --allowlist" in capsys.readouterr().out
+
+
+def test_agent_dataset_generated_round_trips_through_the_schema(tmp_path):
+    """The imported schema drives the synthetic generator — the per-user layer on the same boundary."""
+    main(["agent-dataset", "--source", str(AGENT_FIXTURE), "--output", str(tmp_path / "corpus")])
+    schema = tmp_path / "corpus" / "action_schema.json"
+
+    code = main(
+        [
+            "agent-dataset",
+            "--source",
+            "generated",
+            "--allowlist",
+            str(schema),
+            "--output",
+            str(tmp_path / "user"),
+            "--per-action",
+            "2",
+        ]
+    )
+    assert code == 0
+    rows = [
+        json.loads(line) for line in (tmp_path / "user" / "mobile_actions.jsonl").read_text().splitlines()
+    ]
+    assert len(rows) == 2 * len(json.loads(schema.read_text()))
+
+
+def test_agent_dataset_reports_an_empty_result_instead_of_writing_nothing(tmp_path, capsys):
+    assert (
+        main(["agent-dataset", "--source", str(AGENT_FIXTURE), "--output", str(tmp_path), "--split", "nope"])
+        == 1
+    )
+    assert "no rows produced" in capsys.readouterr().out
diff --git a/tests/export/__init__.py b/tests/export/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/export/test_embedding_stage.py b/tests/export/test_embedding_stage.py
new file mode 100644
index 0000000..11e445e
--- /dev/null
+++ b/tests/export/test_embedding_stage.py
@@ -0,0 +1,56 @@
+"""#26/#27 embedding (RAG) stage: the pure decisions that gate the on-device retriever.
+
+The stage body itself needs optimum + a network fetch, so it runs under the `export` profile. What is
+testable here — and what actually broke the device leg — is the contract the stage must honour: the
+pooled vector width the graph will emit, and the fail-closed check that this width is one the Android
+vector store can index. A package that pools to an unindexable width installs fine and only fails at
+first ingest on device, which is exactly the failure mode the check exists to prevent.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.exceptions import ConfigValidationError
+from mobiletransformers.export.pipeline import (
+    SUPPORTED_EMBEDDING_DIMENSIONS,
+    _pooled_embedding_dimension,
+)
+
+
+def test_single_pooling_mode_keeps_the_word_dimension():
+    config = {"word_embedding_dimension": 384, "pooling_mode_mean_tokens": True}
+    assert _pooled_embedding_dimension(config) == 384
+
+
+def test_concatenated_modes_multiply_the_width():
+    """sentence-transformers concatenates every enabled mode, so two modes emit 2x the word width.
+
+    Reading `word_embedding_dimension` alone would declare 384 in `rag_config.json` while the graph
+    emitted 768 — the store would reject every vector at insert time.
+    """
+    config = {
+        "word_embedding_dimension": 384,
+        "pooling_mode_mean_tokens": True,
+        "pooling_mode_cls_token": True,
+    }
+    assert _pooled_embedding_dimension(config) == 768
+
+
+def test_no_active_mode_falls_back_to_the_word_dimension():
+    assert _pooled_embedding_dimension({"word_embedding_dimension": 512}) == 512
+
+
+@pytest.mark.parametrize("config", [{}, {"word_embedding_dimension": 0}, {"word_embedding_dimension": "x"}])
+def test_unusable_pooling_config_fails_closed(config):
+    with pytest.raises(ConfigValidationError):
+        _pooled_embedding_dimension(config)
+
+
+def test_supported_dimensions_mirror_the_kotlin_registry():
+    """Pinned against `rag/VectorStoreRegistry.kt`'s `DimensionRegistry.SUPPORTED_DIMENSIONS`.
+
+    These two lists are the same contract in two languages: the exporter refuses to write a package the
+    device cannot index, so they must not drift.
+    """
+    assert set(SUPPORTED_EMBEDDING_DIMENSIONS) == {64, 128, 256, 384, 512, 768, 1024, 1536}
diff --git a/tests/export/test_external_data_idempotent.py b/tests/export/test_external_data_idempotent.py
new file mode 100644
index 0000000..b544386
--- /dev/null
+++ b/tests/export/test_external_data_idempotent.py
@@ -0,0 +1,62 @@
+"""#9: re-exporting into an existing package directory must not corrupt its external data.
+
+`onnx.write_external_data_tensors` APPENDS to an existing blob and records each tensor's
+`(offset, length)` into the graph. A second export into the same directory therefore doubles every
+per-tensor `.bin` and points the graph at the second copy. The result is self-consistent as an ONNX
+model, so nothing on the host complains — but #23's on-disk contract is one raw tensor per file at
+offset 0, and the device rejects it with a size mismatch at load. This test pins the invariant that
+made that failure reachable at all.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import onnx
+from onnx import helper, numpy_helper
+
+from mobiletransformers.export.inference_package import _split_external_data
+
+
+def _tiny_model() -> onnx.ModelProto:
+    w = numpy_helper.from_array(np.arange(6, dtype=np.float32).reshape(2, 3), name="layer.MatMul.weight")
+    frozen = numpy_helper.from_array(np.ones((2, 2), dtype=np.float32), name="frozen.weight")
+    node = helper.make_node("Identity", ["layer.MatMul.weight"], ["out"])
+    graph = helper.make_graph(
+        [node],
+        "g",
+        [],
+        [helper.make_tensor_value_info("out", onnx.TensorProto.FLOAT, [2, 3])],
+        initializer=[w, frozen],
+    )
+    return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 20)])
+
+
+def test_repeated_split_leaves_one_tensor_per_bin(tmp_path):
+    trainable = {"layer.MatMul.weight"}
+    expected = 2 * 3 * 4  # 6 float32 elements
+
+    for _ in range(3):
+        _split_external_data(_tiny_model(), tmp_path, trainable)
+
+        blob = tmp_path / "layer.MatMul.weight.bin"
+        assert blob.stat().st_size == expected, (
+            f"per-tensor blob grew to {blob.stat().st_size} bytes after a re-export "
+            "(onnx appended instead of replacing)"
+        )
+
+    # The graph must reference the tensor at offset 0 — the device reads the whole file as one tensor.
+    model = _tiny_model()
+    _split_external_data(model, tmp_path, trainable)
+    init = next(i for i in model.graph.initializer if i.name == "layer.MatMul.weight")
+    entries = {e.key: e.value for e in init.external_data}
+    assert entries.get("offset", "0") == "0"
+    assert entries["length"] == str(expected)
+
+
+def test_repeated_split_does_not_grow_the_frozen_base_blob(tmp_path):
+    trainable = {"layer.MatMul.weight"}
+    sizes = []
+    for _ in range(3):
+        _split_external_data(_tiny_model(), tmp_path, trainable)
+        sizes.append((tmp_path / "frozen_base.onnx.data").stat().st_size)
+    assert len(set(sizes)) == 1, f"frozen base blob grew across re-exports: {sizes}"
diff --git a/tests/export/test_full_export_orchestration.py b/tests/export/test_full_export_orchestration.py
new file mode 100644
index 0000000..0c83168
--- /dev/null
+++ b/tests/export/test_full_export_orchestration.py
@@ -0,0 +1,177 @@
+"""#15 real-export orchestration: stage-gated `_full_export` with injected builders (no heavy deps).
+
+The heavy stage builders (optimum/ORT-training) run only under their profiles; here we inject fakes that
+write tiny synthetic stage dirs, and assert the orchestration: stage selection, effective features honest
+to what's on disk, GenAI feature gating, a valid #13 manifest, and fail-closed on an unavailable stage.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.export.pipeline import (
+    StageOutput,
+    _default_builders,
+    _full_export,
+    plan_export,
+)
+
+
+def _fake_inference(with_genai: bool):
+    def build(plan, dest, *, token, embedding_model):
+        inf = Path(dest) / "inference"
+        tok = Path(dest) / "tokenizer"
+        inf.mkdir(parents=True, exist_ok=True)
+        tok.mkdir(parents=True, exist_ok=True)
+        (inf / "model.onnx").write_bytes(b"\x00")
+        (inf / "model.onnx_data").write_bytes(b"\x00")
+        HandoffMap(entries=[]).save(inf / "weight_handoff_map.json")  # all-frozen base, valid + empty
+        if with_genai and "genai" in plan.supported_engines:
+            (inf / "genai_config.json").write_text("{}\n")
+        (inf / "generation_config.json").write_text("{}\n")
+        (tok / "tokenizer.json").write_text("{}\n")
+        return StageOutput(
+            stage_dirs={"inference": inf, "tokenizer": tok},
+            report={"architectures": ["LlamaForCausalLM"], "supportedTasks": [plan.task]},
+        )
+
+    return build
+
+
+def _plan(tmp_path, *, engines):
+    return plan_export(
+        model="org/tiny",
+        output=tmp_path / "pkg",
+        quant="int4",
+        engines=engines,
+        discover=lambda m: "text-generation-with-past",
+    )
+
+
+def _variant_features(pkg):
+    manifest = MobileTransformersManifest.load(pkg.manifest_path)
+    manifest.validate(pkg.output_dir)  # the #13 checkpoint
+    return set(manifest.variants[0]["features"])
+
+
+def test_inference_only_yields_valid_package_without_train(tmp_path):
+    plan = _plan(tmp_path, engines=("native", "genai"))
+    builders = {**_default_builders(), "inference": _fake_inference(with_genai=True)}
+    pkg = _full_export(plan, token=None, embedding_model=None, stages={"inference"}, builders=builders)
+
+    feats = _variant_features(pkg)
+    assert "inference" in feats
+    assert "train" not in feats  # nothing on disk claims train
+    assert "genai" in feats
+    assert (pkg.output_dir / "variants/cpu-int4/inference/model.onnx").is_file()
+    assert (pkg.output_dir / "variants/cpu-int4/inference/weight_handoff_map.json").is_file()
+    assert (pkg.output_dir / "shared/tokenizer/tokenizer.json").is_file()
+
+
+def test_genai_feature_requires_both_engine_and_config(tmp_path):
+    # genai requested but no genai_config.json emitted -> feature dropped (Native-only).
+    plan = _plan(tmp_path, engines=("native", "genai"))
+    builders = {**_default_builders(), "inference": _fake_inference(with_genai=False)}
+    pkg = _full_export(plan, token=None, embedding_model=None, stages={"inference"}, builders=builders)
+    assert "genai" not in _variant_features(pkg)
+
+
+def test_native_only_engine_never_claims_genai(tmp_path):
+    plan = _plan(tmp_path, engines=("native",))
+    builders = {**_default_builders(), "inference": _fake_inference(with_genai=True)}
+    pkg = _full_export(plan, token=None, embedding_model=None, stages={"inference"}, builders=builders)
+    assert "genai" not in _variant_features(pkg)
+
+
+def test_unavailable_training_stage_fails_closed(tmp_path):
+    plan = _plan(tmp_path, engines=("native",))
+    with pytest.raises(ExportError, match="training stage"):
+        _full_export(plan, token=None, embedding_model=None, stages={"training"})
+
+
+def test_unknown_stage_rejected(tmp_path):
+    from mobiletransformers.exceptions import ConfigValidationError
+
+    plan = _plan(tmp_path, engines=("native",))
+    with pytest.raises(ConfigValidationError, match="unknown export stage"):
+        _full_export(plan, token=None, embedding_model=None, stages={"bogus"})
+
+
+# --- provenance across the two-profile export (#15/#33 debt) ----------------
+
+
+def _fake_training(plan, dest, *, token, embedding_model):
+    """A training stage that reports what the real one reports: nothing about the inference graph."""
+    train = Path(dest) / "train"
+    train.mkdir(parents=True, exist_ok=True)
+    (train / "training_config.json").write_text("{}\n")
+    (train / "checkpoint").write_bytes(b"\x00")
+    return StageOutput(stage_dirs={"train": train}, report={"trainableTensorCount": 4})
+
+
+def test_training_only_reexport_keeps_the_inference_provenance(tmp_path):
+    """A `--stages training` run must not erase what the inference run recorded.
+
+    Producing a train-capable package REQUIRES two profile-scoped runs (the onnxruntime profiles cannot
+    co-install), and the second rebuilds the manifest. It used to rebuild it from a report that knows
+    nothing about the graph, so every pushed device package carried `transformersVersion: null` — the
+    field that attributes a package to a transformers line, which is exactly what diagnosing an export
+    regression needs.
+    """
+    plan = _plan(tmp_path, engines=("native",))
+    builders = {**_default_builders(), "inference": _fake_inference(with_genai=False)}
+    inference_pkg = _full_export(
+        plan, token=None, embedding_model=None, stages={"inference"}, builders=builders
+    )
+    # The real inference stage writes this side-car next to the graph it describes.
+    (inference_pkg.output_dir / "variants/cpu-int4/inference/optimum_config.json").write_text(
+        '{"modelId": "org/tiny", "task": "text-generation-with-past", "modelType": "llama",'
+        ' "optimumOnnxVersion": "0.1.0", "transformersVersion": "4.46.2", "trustRemoteCode": true}\n'
+    )
+
+    pkg = _full_export(
+        plan,
+        token=None,
+        embedding_model=None,
+        stages={"training"},
+        builders={**_default_builders(), "training": _fake_training},
+    )
+
+    manifest = MobileTransformersManifest.load(pkg.manifest_path)
+    assert manifest.data["transformersVersion"] == "4.46.2"
+    assert manifest.data["optimumOnnxVersion"] == "0.1.0"
+    assert manifest.data["architectures"] == ["llama"]
+    assert manifest.data["trustRemoteCode"] is True
+    # ... and the stage this run DID build is still there.
+    assert "train" in set(manifest.variants[0]["features"])
+
+
+def test_an_inference_run_wins_over_the_recorded_side_car(tmp_path):
+    """Carrying forward must never overwrite what THIS run's inference stage reported."""
+    plan = _plan(tmp_path, engines=("native",))
+    (tmp_path / "pkg/variants/cpu-int4/inference").mkdir(parents=True)
+    (tmp_path / "pkg/variants/cpu-int4/inference/optimum_config.json").write_text(
+        '{"modelType": "stale-arch", "transformersVersion": "0.0.1"}\n'
+    )
+
+    def inference_with_versions(plan, dest, *, token, embedding_model):
+        out = _fake_inference(with_genai=False)(plan, dest, token=token, embedding_model=embedding_model)
+        out.report.update({"architectures": ["LlamaForCausalLM"], "transformersVersion": "4.46.2"})
+        return out
+
+    pkg = _full_export(
+        plan,
+        token=None,
+        embedding_model=None,
+        stages={"inference"},
+        builders={**_default_builders(), "inference": inference_with_versions},
+    )
+
+    manifest = MobileTransformersManifest.load(pkg.manifest_path)
+    assert manifest.data["architectures"] == ["LlamaForCausalLM"]
+    assert manifest.data["transformersVersion"] == "4.46.2"
diff --git a/tests/export/test_genai_config_compat.py b/tests/export/test_genai_config_compat.py
new file mode 100644
index 0000000..9b7dd12
--- /dev/null
+++ b/tests/export/test_genai_config_compat.py
@@ -0,0 +1,112 @@
+"""genai_config.json must stay parseable by the bundled onnxruntime-genai.
+
+An unsupported `session_options` key is not ignored by GenAI — it is a hard parse error that rejects the
+whole config. The package then still "works" because `ModelRuntimeFactory` falls back to Native, so the
+damage is invisible on device: the dual-engine parity test compares Native with Native and passes.
+
+That is exactly what shipped. `config_entries` (documented by onnxruntime.ai, rejected by 0.14.1) was
+injected into every package, pointing at a *host* path that would not have existed on a device anyway.
+
+These tests pin both halves so it cannot recur.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from mobiletransformers.export.inference_package import (
+    GENAI_CONFIG_FILENAME,
+    GENAI_SESSION_OPTION_KEYS,
+    _sanitize_genai_session_options,
+)
+
+
+def _write(tmp_path, session_options):
+    config = {"model": {"type": "llama", "decoder": {"session_options": session_options}}}
+    (tmp_path / GENAI_CONFIG_FILENAME).write_text(json.dumps(config, indent=2), encoding="utf-8")
+    return tmp_path / GENAI_CONFIG_FILENAME
+
+
+def _session_options(path):
+    return json.loads(path.read_text(encoding="utf-8"))["model"]["decoder"]["session_options"]
+
+
+def test_config_entries_is_stripped(tmp_path):
+    """The specific key that made every training-stage package GenAI-unloadable."""
+    path = _write(
+        tmp_path,
+        {
+            "provider_options": [],
+            "config_entries": [["session.model_external_initializers_file_folder_path", "/host/path"]],
+        },
+    )
+
+    assert _sanitize_genai_session_options(tmp_path) == ["config_entries"]
+    assert _session_options(path) == {"provider_options": []}
+
+
+def test_supported_keys_are_preserved(tmp_path):
+    kept = {"log_id": "mobiletransformers", "intra_op_num_threads": 4, "provider_options": []}
+    path = _write(tmp_path, dict(kept))
+
+    assert _sanitize_genai_session_options(tmp_path) == []
+    assert _session_options(path) == kept
+
+
+def test_unknown_keys_are_stripped_not_just_config_entries(tmp_path):
+    """The guard is an allow-list, so a *future* bad key is caught too — not just the one that bit us."""
+    path = _write(tmp_path, {"log_id": "x", "use_env_allocators": True, "disable_cpu_ep_fallback": True})
+
+    assert _sanitize_genai_session_options(tmp_path) == [
+        "disable_cpu_ep_fallback",
+        "use_env_allocators",
+    ]
+    assert _session_options(path) == {"log_id": "x"}
+
+
+def test_no_host_paths_leak_into_the_package(tmp_path):
+    """A package is relocatable: it is exported on a host and pushed to a device.
+
+    The old code embedded `str(output_dir)` in the config. Nothing may write an absolute host path into
+    genai_config.json — external data resolves relative to the model file's directory (#23).
+    """
+    path = _write(tmp_path, {"config_entries": [["k", str(tmp_path)]], "log_id": "x"})
+    _sanitize_genai_session_options(tmp_path)
+
+    assert str(tmp_path) not in path.read_text(encoding="utf-8")
+
+
+def test_missing_config_is_not_an_error(tmp_path):
+    """genai_config.json is optional — produced upstream, only augmented here."""
+    assert _sanitize_genai_session_options(tmp_path) == []
+
+
+def test_allowlist_matches_the_bundled_runtime():
+    """Pin the probed set. If a genai bump changes it, re-probe rather than editing this by hand.
+
+    Derived by feeding each key to `og.Model()` alone against onnxruntime-genai 0.14.1 and recording
+    whether the config parsed — not by reading the docs, which are wrong about `config_entries`.
+    """
+    assert GENAI_SESSION_OPTION_KEYS == {
+        "log_id",
+        "log_severity_level",
+        "enable_profiling",
+        "enable_cpu_mem_arena",
+        "enable_mem_pattern",
+        "intra_op_num_threads",
+        "inter_op_num_threads",
+        "graph_optimization_level",
+        "custom_ops_library",
+        "provider",
+        "provider_options",
+        "external_data_file",
+    }
+    assert "config_entries" not in GENAI_SESSION_OPTION_KEYS
+
+
+@pytest.mark.parametrize("key", ["config_entries", "use_env_allocators", "disable_cpu_ep_fallback"])
+def test_known_rejected_keys_stay_out_of_the_allowlist(key):
+    """Probed as REJECTED by genai 0.14.1. Adding one back re-breaks GenAI loading silently."""
+    assert key not in GENAI_SESSION_OPTION_KEYS
diff --git a/tests/export/test_id2label_export.py b/tests/export/test_id2label_export.py
new file mode 100644
index 0000000..e6f7523
--- /dev/null
+++ b/tests/export/test_id2label_export.py
@@ -0,0 +1,172 @@
+"""The classification head's label names, and when the export records them.
+
+A classification graph predicts an **index**, and an index is not an answer. ``_read_id2label`` copies
+the HF config's ``id2label`` into ``inference/optimum_config.json`` so the device can say ``spam``
+rather than ``LABEL_3``; ``classify()`` fails closed without it, by design.
+
+It shipped with no test at all, which matters more than the size of the function suggests: it is
+best-effort by construction — every failure path returns ``{}`` rather than raising — so a mistake
+here is silent. An export would succeed, the package would look complete, and the labels would simply
+be missing on device. These tests pin each of those quiet paths.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.export.pipeline import ExportPlan, _read_id2label
+
+
+class FakeConfig:
+    """A stand-in for a transformers config: attributes only, nothing else is used."""
+
+    def __init__(self, **fields):
+        for key, value in fields.items():
+            setattr(self, key, value)
+
+
+class RecordingLog:
+    def __init__(self):
+        self.warnings: list[str] = []
+
+    def warning(self, msg, *args):
+        self.warnings.append(msg % args if args else msg)
+
+
+def plan(task: str) -> ExportPlan:
+    return ExportPlan(
+        model_id="acme/sentiment",
+        task=task,
+        peft_method=PEFTMethod.LORA,
+        optimization_level=None,
+        rank=8,
+        quant="int4",
+        variant_id="cpu-int4",
+        output_dir=Path("/tmp/does-not-matter"),
+        features=("inference",),
+        supported_engines=("native",),
+    )
+
+
+@pytest.fixture
+def patch_autoconfig(monkeypatch):
+    """Stand a fake ``transformers`` module up in ``sys.modules``.
+
+    ``transformers`` is deliberately absent from the dev profile — it lives in ``export`` and
+    ``ort-training-local``, which cannot co-install — so there is no real ``AutoConfig`` to patch here.
+    ``_read_id2label`` imports it *inside* the function, which is exactly what makes injection work:
+    the import resolves against ``sys.modules`` at call time. Same approach as
+    ``tests/fixtures/gen_merger_golden.py``'s ``onnxruntime`` stub.
+
+    This keeps the test in the profile ``make check`` actually runs, rather than stranding it behind
+    an ``importorskip`` that would skip in CI and never be seen to fail.
+    """
+
+    def apply(result):
+        def fake_from_pretrained(model_id, **kwargs):
+            if isinstance(result, Exception):
+                raise result
+            return result
+
+        module = types.ModuleType("transformers")
+        module.AutoConfig = types.SimpleNamespace(from_pretrained=fake_from_pretrained)
+        monkeypatch.setitem(sys.modules, "transformers", module)
+
+    return apply
+
+
+def test_records_labels_for_a_classification_task(patch_autoconfig):
+    patch_autoconfig(FakeConfig(id2label={0: "negative", 1: "positive"}))
+
+    assert _read_id2label(plan("text-classification"), token=None, log=RecordingLog()) == {
+        "0": "negative",
+        "1": "positive",
+    }
+
+
+def test_keys_and_values_are_stringified(patch_autoconfig):
+    """HF hands back int keys; JSON carries strings, and ``PackageTask.kt`` parses them back to ints.
+
+    Leaving ints here would still serialise (json coerces dict keys), but the contract is stated in
+    the return type and the Kotlin reader depends on it, so it is asserted rather than assumed.
+    """
+    patch_autoconfig(FakeConfig(id2label={0: 1, 2: "x"}))
+
+    result = _read_id2label(plan("text-classification"), token=None, log=RecordingLog())
+
+    assert result == {"0": "1", "2": "x"}
+    assert all(isinstance(k, str) and isinstance(v, str) for k, v in result.items())
+
+
+def test_an_absent_transformers_records_nothing_instead_of_raising(monkeypatch):
+    """The dev profile's real state: no ``transformers`` at all.
+
+    The function-local import means an export run without the export extra hits ``ImportError`` here,
+    and the same fail-open path must swallow it. This is why the tests above have to inject a module
+    rather than patch one.
+    """
+    monkeypatch.setitem(sys.modules, "transformers", None)
+    log = RecordingLog()
+
+    assert _read_id2label(plan("text-classification"), token=None, log=log) == {}
+    assert len(log.warnings) == 1
+
+
+def test_a_decoder_task_records_nothing(patch_autoconfig):
+    """A decoder's ``id2label`` is a leftover from some other head.
+
+    Recording it would tell the device this package classifies — and `Tasks.resolve` would then offer
+    a Classify path on a model with no classification head.
+    """
+    patch_autoconfig(FakeConfig(id2label={0: "LABEL_0"}))
+
+    assert _read_id2label(plan("text-generation"), token=None, log=RecordingLog()) == {}
+
+
+def test_feature_extraction_records_nothing(patch_autoconfig):
+    patch_autoconfig(FakeConfig(id2label={0: "LABEL_0"}))
+
+    assert _read_id2label(plan("feature-extraction"), token=None, log=RecordingLog()) == {}
+
+
+def test_an_unknown_task_records_nothing_instead_of_raising():
+    """``get_task_spec`` fails closed on an unknown task; the label read must not turn that into a
+    failed export, because it is a convenience for one task and irrelevant to every other."""
+    assert _read_id2label(plan("not-a-real-task"), token=None, log=RecordingLog()) == {}
+
+
+def test_an_unreachable_config_warns_and_records_nothing(patch_autoconfig):
+    """A private or offline repo must not fail an otherwise-good export — but must say so."""
+    patch_autoconfig(OSError("401 Unauthorized"))
+    log = RecordingLog()
+
+    assert _read_id2label(plan("text-classification"), token=None, log=log) == {}
+    assert len(log.warnings) == 1
+    assert "401 Unauthorized" in log.warnings[0]
+
+
+@pytest.mark.parametrize(
+    "mapping",
+    [None, {}, "LABEL_0", ["a", "b"], 3],
+    ids=["absent", "empty", "string", "list", "int"],
+)
+def test_a_missing_or_malformed_mapping_records_nothing(patch_autoconfig, mapping):
+    """Anything that is not a non-empty dict is not a label map.
+
+    Without the ``isinstance`` guard a string ``id2label`` would be enumerated character by character
+    and written to the package as a label set.
+    """
+    patch_autoconfig(FakeConfig(id2label=mapping))
+
+    assert _read_id2label(plan("text-classification"), token=None, log=RecordingLog()) == {}
+
+
+def test_a_config_without_the_attribute_at_all_records_nothing(patch_autoconfig):
+    patch_autoconfig(FakeConfig())
+
+    assert _read_id2label(plan("text-classification"), token=None, log=RecordingLog()) == {}
diff --git a/tests/export/test_model_card_peft.py b/tests/export/test_model_card_peft.py
new file mode 100644
index 0000000..764a8cf
--- /dev/null
+++ b/tests/export/test_model_card_peft.py
@@ -0,0 +1,153 @@
+"""What a published model page says about how the package was fine-tuned.
+
+The card used to name the PEFT method in exactly one place — a `PEFT methods: mars` bullet buried in
+Provenance — and tag only `lora` in the Hub frontmatter, from a hardcoded string test. So a **MARS**
+package, which is this project's own research contribution, published with no tag naming it and
+nothing on the page explaining what it is. Someone browsing the org could not tell a MARS export from
+a LoRA one, and Hub tag search could not find it at all.
+
+Rank and adapted modules are the other half, and they are **not in the manifest** — they live beside
+the training graph in `train/trainable_parameters.json` and `train/training_config.json`. Reading them
+is best-effort by construction, which is exactly why it needs tests: every failure path returns `{}`
+and the lines are silently omitted, so a mistake here is invisible on a page that still looks complete.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mobiletransformers.export.model_card import render_model_card
+
+
+def _manifest(**overrides) -> dict:
+    base = {
+        "baseModelId": "HuggingFaceTB/SmolLM2-135M-Instruct",
+        "selectedTask": "text-generation-with-past",
+        "peftMethods": ["mars"],
+        "quantization": ["int4"],
+        "license": {"baseModelWeights": "apache-2.0", "framework": None},
+        "androidRuntime": {},
+        "variants": [{"id": "cpu-int4", "features": ["core", "inference", "train", "rag"]}],
+        "defaultVariant": "cpu-int4",
+    }
+    base.update(overrides)
+    return base
+
+
+def _write_train_stage(root: Path, **payloads) -> None:
+    stage = root / "variants" / "cpu-int4" / "train"
+    stage.mkdir(parents=True, exist_ok=True)
+    for name, payload in payloads.items():
+        (stage / f"{name}.json").write_text(json.dumps(payload), encoding="utf-8")
+
+
+# --- the frontmatter tag ----------------------------------------------------------------------
+
+
+def test_every_peft_method_becomes_a_hub_tag():
+    """A `mars` package must be findable by tag. The old code tagged `lora` or nothing."""
+    card = render_model_card(_manifest(peftMethods=["mars"]))
+    frontmatter = card.split("---")[1]
+    assert "  - mars" in frontmatter, f"no `mars` tag in frontmatter:\n{frontmatter}"
+
+
+def test_multiple_methods_are_all_tagged():
+    card = render_model_card(_manifest(peftMethods=["lora", "lora-xs"]))
+    frontmatter = card.split("---")[1]
+    assert "  - lora" in frontmatter
+    assert "  - lora-xs" in frontmatter
+
+
+# --- the named section ------------------------------------------------------------------------
+
+
+def test_mars_is_named_and_explained_in_its_own_section():
+    card = render_model_card(_manifest(peftMethods=["mars"]))
+    assert "## Fine-tuning method" in card
+    assert "**mars**" in card
+    assert "Multi-Adapter Rank Sharing" in card, "MARS is named but never explained"
+
+
+def test_rank_and_targets_are_read_from_the_train_stage(tmp_path):
+    """They are NOT in the manifest — this asserts the package is actually read."""
+    _write_train_stage(
+        tmp_path,
+        trainable_parameters={"peftMethod": "mars", "rank": 16},
+        training_config={"rank": 16, "peft_target": ["q_proj", "v_proj"]},
+    )
+    card = render_model_card(_manifest(), str(tmp_path))
+    assert "Rank: `16`" in card
+    assert "`q_proj`" in card and "`v_proj`" in card
+
+
+def test_a_missing_rank_omits_the_line_rather_than_printing_none(tmp_path):
+    """`None` rendered as text is worse than silence — the "Framework: None" mistake, repeated."""
+    card = render_model_card(_manifest(), str(tmp_path))  # no train stage at all
+    assert "## Fine-tuning method" in card, "the method is known even with no train stage"
+    assert "Rank:" not in card
+    assert "None" not in card.split("## Fine-tuning method")[1].split("##")[0]
+
+
+def test_an_unreadable_train_stage_does_not_fail_the_card(tmp_path):
+    """Best-effort: a corrupt file must not block a push."""
+    stage = tmp_path / "variants" / "cpu-int4" / "train"
+    stage.mkdir(parents=True)
+    (stage / "trainable_parameters.json").write_text("{not json", encoding="utf-8")
+    card = render_model_card(_manifest(), str(tmp_path))
+    assert "## Fine-tuning method" in card
+    assert "Rank:" not in card
+
+
+def test_no_peft_methods_means_no_section():
+    card = render_model_card(_manifest(peftMethods=[]))
+    assert "## Fine-tuning method" not in card
+
+
+# --- the capability section -------------------------------------------------------------------
+
+
+def test_features_are_listed_so_a_reader_knows_what_the_package_supports():
+    card = render_model_card(_manifest())
+    assert "## What this package can do" in card
+    assert "fine-tune on device" in card
+    assert "`rag`" in card
+
+
+def test_an_inference_only_package_says_so():
+    manifest = _manifest(variants=[{"id": "cpu-int4", "features": ["core", "inference"]}])
+    card = render_model_card(manifest)
+    assert "inference-only" in card
+
+
+# --- no `None` reaches a published page ---------------------------------------------------------
+#
+# The "Framework: None" bug shipped on a real model page: `lic.get(k, fallback)` returned None
+# because the key EXISTED with a null value, and a reader can only read that as "there is no licence".
+# The same shape was still live in three other places — the toolchain line, the device-memory line and
+# every variant-table cell — on every package the exporter has produced, since those fields are null
+# in all of them.
+
+
+def test_no_none_reaches_the_page_when_the_manifest_is_full_of_nulls():
+    manifest = _manifest(
+        optimumOnnxVersion=None,
+        transformersVersion=None,
+        onnxRuntimeTrainingVersion=None,
+        onnxRuntimeGenAIVersion=None,
+        androidRuntime={"minimumAndroidApi": None, "recommendedDeviceMemoryMb": None},
+        variants=[{"id": "cpu-int4", "features": ["core", "inference"]}],
+    )
+    card = render_model_card(manifest)
+    assert "None" not in card, f"a null rendered as the literal 'None':\n{card}"
+
+
+def test_a_known_toolchain_version_is_still_shown():
+    """The fix must not hide real data — only the nulls."""
+    card = render_model_card(_manifest(onnxRuntimeTrainingVersion="1.23.0+cpu"))
+    assert "ort-training 1.23.0+cpu" in card
+
+
+def test_a_recommended_memory_figure_is_shown_when_measured():
+    card = render_model_card(_manifest(androidRuntime={"recommendedDeviceMemoryMb": 3000}))
+    assert "3000" in card
diff --git a/tests/export/test_onnx_config_with_loss.py b/tests/export/test_onnx_config_with_loss.py
new file mode 100644
index 0000000..bf968a0
--- /dev/null
+++ b/tests/export/test_onnx_config_with_loss.py
@@ -0,0 +1,86 @@
+"""Training-graph export via the vendored OnnxConfigWithLoss (plan #7 Fallback resolution).
+
+Automates what the plan listed as a manual test: proves the vendored wrapper turns an inference
+OnnxConfig into a training graph (labels in, loss out) on optimum's surviving export(). Uses a tiny
+synthetic Llama config (no download). Needs the export profile (optimum + torch)."""
+
+from __future__ import annotations
+
+import importlib.util
+
+import pytest
+
+_HAS = importlib.util.find_spec("optimum") is not None and importlib.util.find_spec("torch") is not None
+pytestmark = pytest.mark.skipif(not _HAS, reason="needs export profile (optimum + torch)")
+
+
+def _tiny_llama_config():  # type: ignore[no-untyped-def]
+    from transformers import LlamaConfig
+
+    return LlamaConfig(
+        hidden_size=32,
+        num_hidden_layers=2,
+        num_attention_heads=4,
+        num_key_value_heads=4,
+        intermediate_size=64,
+        vocab_size=128,
+        max_position_embeddings=64,
+    )
+
+
+def test_vendored_wrapper_adds_labels_and_loss() -> None:
+    from optimum.exporters.onnx.model_configs import LlamaOnnxConfig
+
+    from mobiletransformers.export.onnx_config_with_loss import OnnxConfigWithLoss
+
+    base = LlamaOnnxConfig(
+        _tiny_llama_config(), task="text-generation", use_past=False, use_past_in_inputs=False
+    )
+    ocl = OnnxConfigWithLoss(base)
+    assert "labels" in ocl.inputs
+    assert "loss" in ocl.outputs
+    dummy = ocl.generate_dummy_inputs(framework="pt")
+    assert "labels" in dummy
+
+
+def test_training_graph_export_emits_loss(tmp_path) -> None:
+    import onnx
+    import torch
+    from optimum.exporters.onnx import export
+    from optimum.exporters.onnx.model_configs import LlamaOnnxConfig
+    from transformers import LlamaForCausalLM
+
+    from mobiletransformers.export.onnx_config_with_loss import OnnxConfigWithLoss
+
+    class _TrainerWrapper(torch.nn.Module):
+        def __init__(self, model: torch.nn.Module) -> None:
+            super().__init__()
+            self.backbone = model
+            self.config = model.config
+            self.training = True
+
+        def forward(self, input_ids, attention_mask, position_ids, labels):  # type: ignore[no-untyped-def]
+            return self.backbone(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                position_ids=position_ids,
+                labels=labels,
+            )
+
+    cfg = _tiny_llama_config()
+    model = LlamaForCausalLM(cfg)
+    base = LlamaOnnxConfig(cfg, task="text-generation", use_past=False, use_past_in_inputs=False)
+    ocl = OnnxConfigWithLoss(base)
+    wrapper = _TrainerWrapper(model)
+    wrapper.train()
+
+    out = tmp_path / "model.onnx"
+    inputs, outputs = export(wrapper, ocl, out, opset=20, do_constant_folding=False)
+
+    assert "labels" in inputs
+    assert "loss" in outputs
+    graph = onnx.load(str(out))
+    graph_inputs = {i.name for i in graph.graph.input}
+    graph_outputs = {o.name for o in graph.graph.output}
+    assert "labels" in graph_inputs
+    assert "loss" in graph_outputs
diff --git a/tests/export/test_orphaned_external_data.py b/tests/export/test_orphaned_external_data.py
new file mode 100644
index 0000000..4486422
--- /dev/null
+++ b/tests/export/test_orphaned_external_data.py
@@ -0,0 +1,108 @@
+"""The upstream external-data blob must not survive into the shipped package.
+
+Optimum writes every weight to one ``model.onnx_data`` beside ``model.onnx``. ``_split_external_data``
+then re-points **every** initializer at ``frozen_base.onnx.data`` or a per-tensor ``<name>.bin`` — so
+the upstream blob ends up referenced by nothing and was simply left in the package.
+
+Nothing caught it, and that is the interesting part: a package with a spare file still passes every
+gate there is. The graph is self-consistent, `validate` resolves every declared file, and the
+checksums match. Only the **download** notices, because `downloadPlan` ships the inference stage as
+the glob ``variants/<id>/inference/**``:
+
+    FunctionGemma   1,743 MB dead of 3,875 MB   (45%)  <- already published to the Hub
+    SmolLM2-135M      651 MB dead of 1,586 MB   (41%)
+
+So every user paid nearly double the download for every package. These tests pin the removal, and pin
+that a **referenced** blob is never touched — a package that legitimately keeps the upstream layout
+must degrade to a no-op, not to a corrupt graph.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import onnx
+import pytest
+from onnx import TensorProto, helper, numpy_helper
+
+from mobiletransformers.export.inference_package import _drop_orphaned_external_data
+
+
+def _model_with_external_weight(location: str) -> onnx.ModelProto:
+    """A one-initializer graph whose weight lives in ``location``."""
+    weight = numpy_helper.from_array(np.zeros((4, 4), dtype=np.float32), name="w")
+    weight.data_location = TensorProto.EXTERNAL
+    del weight.external_data[:]
+    for key, value in (("location", location), ("offset", "0"), ("length", "64")):
+        entry = weight.external_data.add()
+        entry.key, entry.value = key, value
+    weight.ClearField("raw_data")
+
+    node = helper.make_node("Identity", ["w"], ["y"])
+    graph = helper.make_graph(
+        [node],
+        "g",
+        [],
+        [helper.make_tensor_value_info("y", TensorProto.FLOAT, [4, 4])],
+        initializer=[weight],
+    )
+    return helper.make_model(graph)
+
+
+def test_an_unreferenced_upstream_blob_is_removed(tmp_path):
+    """The defect: 45% of every published package was this file."""
+    model = _model_with_external_weight("frozen_base.onnx.data")
+    path = tmp_path / "model.onnx"
+    onnx.save(model, str(path))
+    (tmp_path / "frozen_base.onnx.data").write_bytes(b"\0" * 64)
+    orphan = tmp_path / "model.onnx_data"
+    orphan.write_bytes(b"\0" * 4096)
+
+    assert _drop_orphaned_external_data(path, tmp_path) == 1
+    assert not orphan.exists()
+    # The blob the graph actually uses survives — the whole package depends on it.
+    assert (tmp_path / "frozen_base.onnx.data").exists()
+
+
+def test_a_referenced_blob_is_never_removed(tmp_path):
+    """Fail-safe: if a layout genuinely keeps the upstream blob, this must be a no-op."""
+    model = _model_with_external_weight("model.onnx_data")
+    path = tmp_path / "model.onnx"
+    onnx.save(model, str(path))
+    referenced = tmp_path / "model.onnx_data"
+    referenced.write_bytes(b"\0" * 64)
+
+    assert _drop_orphaned_external_data(path, tmp_path) == 0
+    assert referenced.exists(), "removing a REFERENCED blob would corrupt the package"
+
+
+def test_our_own_blobs_are_out_of_scope(tmp_path):
+    """Only `*.onnx_data` is considered. `frozen_base.onnx.data` and `*.bin` are ours, by name."""
+    model = _model_with_external_weight("frozen_base.onnx.data")
+    path = tmp_path / "model.onnx"
+    onnx.save(model, str(path))
+    (tmp_path / "frozen_base.onnx.data").write_bytes(b"\0" * 64)
+    # Unreferenced, but not named `.onnx_data` — deliberately left alone.
+    stray = tmp_path / "model.layers.0.self_attn.q_proj.MatMul.weight.bin"
+    stray.write_bytes(b"\0" * 16)
+
+    _drop_orphaned_external_data(path, tmp_path)
+    assert stray.exists()
+
+
+def test_nothing_to_do_is_not_an_error(tmp_path):
+    model = _model_with_external_weight("frozen_base.onnx.data")
+    path = tmp_path / "model.onnx"
+    onnx.save(model, str(path))
+    (tmp_path / "frozen_base.onnx.data").write_bytes(b"\0" * 64)
+    assert _drop_orphaned_external_data(path, tmp_path) == 0
+
+
+@pytest.mark.parametrize("count", [1, 3])
+def test_several_orphans_are_all_removed(tmp_path, count):
+    model = _model_with_external_weight("frozen_base.onnx.data")
+    path = tmp_path / "model.onnx"
+    onnx.save(model, str(path))
+    (tmp_path / "frozen_base.onnx.data").write_bytes(b"\0" * 64)
+    for i in range(count):
+        (tmp_path / f"decoder{i}.onnx_data").write_bytes(b"\0" * 128)
+    assert _drop_orphaned_external_data(path, tmp_path) == count
diff --git a/tests/export/test_pipeline.py b/tests/export/test_pipeline.py
new file mode 100644
index 0000000..46642dd
--- /dev/null
+++ b/tests/export/test_pipeline.py
@@ -0,0 +1,131 @@
+"""#15 one-command export pipeline: arg mapping, dry-run plan, assemble+manifest checkpoint, model card."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.exceptions import ConfigValidationError
+from mobiletransformers.export.model_card import render_model_card
+from mobiletransformers.export.pipeline import (
+    assemble_package,
+    export_package,
+    manifest_skeleton,
+    parse_peft,
+    plan_export,
+    quant_spec,
+)
+
+PKG = Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package"
+
+
+# --- arg mapping ------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "value,method,opt",
+    [
+        ("lora", PEFTMethod.LORA, None),
+        ("lora-xs", PEFTMethod.LORA_XS, None),
+        ("mars", PEFTMethod.MARS, 0),
+        ("mars-opt1", PEFTMethod.MARS, 1),
+        ("mars-opt4", PEFTMethod.MARS, 4),
+    ],
+)
+def test_parse_peft(value, method, opt):
+    assert parse_peft(value) == (method, opt)
+
+
+@pytest.mark.parametrize("bad", ["mars-opt9", "mars-optx", "banana"])
+def test_parse_peft_rejects_invalid(bad):
+    with pytest.raises(ConfigValidationError):
+        parse_peft(bad)
+
+
+def test_quant_spec_known_and_unknown():
+    assert quant_spec("qint8")["weight_type"] == "QInt8"
+    assert quant_spec("int4")["weight_type"] == "MatMul4Bits"
+    with pytest.raises(ConfigValidationError):
+        quant_spec("int2")
+
+
+# --- dry-run planning (no heavy deps; task injected) ------------------------
+
+
+def test_plan_and_dry_run(tmp_path):
+    plan = export_package(
+        model="org/tiny",
+        output=tmp_path / "out",
+        peft="mars-opt1",
+        quant="int4",
+        include_rag=True,
+        dry_run=True,
+        discover=lambda m: "text-generation-with-past",
+    )
+    assert plan.task == "text-generation-with-past"
+    assert plan.peft_method is PEFTMethod.MARS and plan.optimization_level == 1
+    assert plan.variant_id == "cpu-int4"
+    assert "rag" in plan.features
+    # nothing written on dry-run
+    assert not (tmp_path / "out").exists()
+    skel = manifest_skeleton(plan)
+    assert skel["defaultVariant"] == "cpu-int4" and skel["_dryRun"] is True
+
+
+def test_plan_export_auto_task_uses_injected_discover(tmp_path):
+    plan = plan_export(model="org/x", output=tmp_path, discover=lambda m: "feature-extraction")
+    assert plan.task == "feature-extraction"
+
+
+# --- assemble + manifest CHECKPOINT (validates against #13) -----------------
+
+
+def test_assemble_package_produces_valid_13_package(tmp_path):
+    # Reuse the fixture's cpu-int4 variant subtrees as synthetic stage outputs.
+    src = PKG / "variants" / "cpu-int4"
+    stage_dirs = {
+        "inference": src / "inference",
+        "train": src / "train",
+        "embedding": src / "embedding",
+        "tokenizer": PKG / "shared" / "tokenizer",
+    }
+    plan = plan_export(
+        model="org/tiny",
+        output=tmp_path / "pkg",
+        quant="int4",
+        include_rag=True,
+        discover=lambda m: "text-generation-with-past",
+    )
+    report = {
+        "mobiletransformersVersion": "0.2.0",
+        "architectures": ["LlamaForCausalLM"],
+        "supportedTasks": ["text-generation-with-past"],
+        "selectedTask": "text-generation-with-past",
+        "peftMethods": ["lora"],
+        "quantization": ["int4"],
+        "androidRuntime": {"minimumAndroidApi": 28, "recommendedDeviceMemoryMb": 3072, "requiredAbis": []},
+        "license": {"framework": "Apache-2.0", "baseModelWeights": "Apache-2.0", "noticeFile": None},
+    }
+    pkg = assemble_package(
+        plan, stage_dirs, base_model_id="org/tiny", report=report, exported_at="2026-07-14T00:00:00Z"
+    )
+    # The emitted tree validates against the #13 manifest validator — this is the export-E2E checkpoint.
+    manifest = MobileTransformersManifest.load(pkg.manifest_path)
+    manifest.validate(pkg.output_dir)
+    assert (pkg.output_dir / "variants/cpu-int4/inference/model.onnx").exists()
+    assert (pkg.output_dir / "shared/tokenizer/tokenizer.json").exists()
+
+
+# --- model card -------------------------------------------------------------
+
+
+def test_render_model_card_contains_key_sections():
+    manifest = json.loads((PKG / "mobiletransformers_manifest.json").read_text())
+    card = render_model_card(manifest)
+    assert manifest["baseModelId"] in card
+    assert "## Licenses" in card and "## Variants" in card
+    assert "cpu-int4" in card and "cpu-fp16" in card
diff --git a/tests/export/test_quantizer_compat.py b/tests/export/test_quantizer_compat.py
new file mode 100644
index 0000000..1045cf9
--- /dev/null
+++ b/tests/export/test_quantizer_compat.py
@@ -0,0 +1,107 @@
+"""The ORT quantizer-rename resolver that unblocked Migration S6.
+
+`inference/builder.py` (3,441 lines, the largest file in the repo and the last unmigrated one) was
+recorded as "unimportable under every declared profile". That was true, and the cause was **one import**:
+ORT generalised its 4-bit weight-only MatMul quantizer to N-bit and renamed both the module and the
+class, deleting the old names rather than aliasing them.
+
+These tests run in the core env: the resolver is exercised against stub modules, so no onnxruntime is
+needed to prove the resolution order and the failure message.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+
+import pytest
+
+from mobiletransformers.export.quantizer_compat import (
+    _CANDIDATES,
+    load_weight_only_matmul_quantizer,
+)
+
+NEW_MODULE, NEW_CLASS = "onnxruntime.quantization.matmul_nbits_quantizer", "MatMulNBitsQuantizer"
+OLD_MODULE, OLD_CLASS = "onnxruntime.quantization.matmul_4bits_quantizer", "MatMul4BitsQuantizer"
+
+
+@pytest.fixture
+def fake_ort(monkeypatch):
+    """Install a stub `onnxruntime.quantization` package; yields a function to add quantizer modules."""
+    for name in ("onnxruntime", "onnxruntime.quantization", NEW_MODULE, OLD_MODULE):
+        monkeypatch.delitem(sys.modules, name, raising=False)
+
+    root = types.ModuleType("onnxruntime")
+    root.__version__ = "9.9.9-stub"
+    root.__path__ = []
+    quant = types.ModuleType("onnxruntime.quantization")
+    quant.__path__ = []
+    monkeypatch.setitem(sys.modules, "onnxruntime", root)
+    monkeypatch.setitem(sys.modules, "onnxruntime.quantization", quant)
+
+    def add(module_path: str, attr: str | None):
+        module = types.ModuleType(module_path)
+        if attr is not None:
+            setattr(module, attr, type(attr, (), {}))
+        monkeypatch.setitem(sys.modules, module_path, module)
+        return module
+
+    return add
+
+
+def test_prefers_the_current_ort_spelling(fake_ort):
+    """When both exist, the N-bit name wins — it is the one a current ORT actually ships."""
+    fake_ort(NEW_MODULE, NEW_CLASS)
+    fake_ort(OLD_MODULE, OLD_CLASS)
+
+    assert load_weight_only_matmul_quantizer().__name__ == NEW_CLASS
+
+
+def test_falls_back_to_the_legacy_spelling(fake_ort):
+    """The repo pins two ORT lines; hard-coding either name re-breaks the other."""
+    fake_ort(OLD_MODULE, OLD_CLASS)
+
+    assert load_weight_only_matmul_quantizer().__name__ == OLD_CLASS
+
+
+def test_module_present_but_class_renamed_again_is_not_fatal(fake_ort):
+    """A future ORT could keep the module and rename the class; fall through rather than crash."""
+    fake_ort(NEW_MODULE, None)  # module exists, class absent
+    fake_ort(OLD_MODULE, OLD_CLASS)
+
+    assert load_weight_only_matmul_quantizer().__name__ == OLD_CLASS
+
+
+def test_failure_names_both_spellings_and_the_version(fake_ort):
+    """A bare ModuleNotFoundError reads like onnxruntime is missing. It is not — it is renamed."""
+    fake_ort(NEW_MODULE, None)
+
+    with pytest.raises(ImportError) as excinfo:
+        load_weight_only_matmul_quantizer()
+
+    message = str(excinfo.value)
+    assert "9.9.9-stub" in message, "must name the installed ORT version"
+    assert "MatMulNBitsQuantizer" in message and "MatMul4BitsQuantizer" in message
+    assert "quantizer_compat.py" in message, "must say where to add a new spelling"
+
+
+def test_missing_onnxruntime_says_so_plainly(monkeypatch):
+    for name in ("onnxruntime", "onnxruntime.quantization", NEW_MODULE, OLD_MODULE):
+        monkeypatch.delitem(sys.modules, name, raising=False)
+    real_import = __builtins__["__import__"] if isinstance(__builtins__, dict) else __builtins__.__import__
+
+    def blocked(name, *args, **kwargs):
+        if name.split(".")[0] == "onnxruntime":
+            raise ImportError("no onnxruntime")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr("builtins.__import__", blocked)
+
+    with pytest.raises(ImportError, match="onnxruntime is not installed"):
+        load_weight_only_matmul_quantizer()
+
+
+def test_candidate_order_is_newest_first():
+    """Ordering is the contract: a stale name must never shadow the current one."""
+    assert [m for m, _ in _CANDIDATES] == [NEW_MODULE, OLD_MODULE]
+    assert [c for _, c in _CANDIDATES] == [NEW_CLASS, OLD_CLASS]
diff --git a/tests/export/test_registry.py b/tests/export/test_registry.py
new file mode 100644
index 0000000..083842f
--- /dev/null
+++ b/tests/export/test_registry.py
@@ -0,0 +1,80 @@
+"""Unit tests for the export discovery + frontend registries (plan #7).
+
+Pure tests (task selection, frontend registry) run in any profile. Discovery tests need optimum
+(metadata-only lookups, no network) and skip when it is absent."""
+
+from __future__ import annotations
+
+import importlib.util
+
+import pytest
+
+from mobiletransformers.config.constants import ExportFrontend
+from mobiletransformers.exceptions import ExportError, UnsupportedModelError
+from mobiletransformers.export.registry import (
+    EXPORT_FRONTEND_REGISTRY,
+    choose_task,
+    is_supported,
+    resolve_frontend,
+    supported_onnx_tasks,
+)
+
+_HAS_OPTIMUM = importlib.util.find_spec("optimum") is not None
+requires_optimum = pytest.mark.skipif(not _HAS_OPTIMUM, reason="needs export profile (optimum)")
+
+
+# --- task selection (pure) ------------------------------------------------------------------------
+def test_choose_task_prefers_with_past() -> None:
+    supported = ["feature-extraction", "text-generation", "text-generation-with-past"]
+    assert choose_task(supported) == "text-generation-with-past"
+
+
+def test_choose_task_falls_back_to_text_generation() -> None:
+    assert choose_task(["feature-extraction", "text-generation"]) == "text-generation"
+
+
+def test_choose_task_feature_extraction_only() -> None:
+    assert choose_task(["feature-extraction"]) == "feature-extraction"
+
+
+def test_choose_task_override_wins_even_outside_auto_order() -> None:
+    assert choose_task(["text-generation-with-past"], override="feature-extraction") == "feature-extraction"
+
+
+def test_choose_task_none_supported_fails_closed() -> None:
+    with pytest.raises(UnsupportedModelError):
+        choose_task([])
+
+
+# --- frontend registry (pure, table lookup — not if/elif) -----------------------------------------
+def test_resolve_frontend_by_enum_and_wire_value() -> None:
+    assert resolve_frontend(ExportFrontend.OPTIMUM_ONNX).frontend is ExportFrontend.OPTIMUM_ONNX
+    assert resolve_frontend("optimum-onnx").frontend is ExportFrontend.OPTIMUM_ONNX
+    assert resolve_frontend("torch.onnx").frontend is ExportFrontend.TORCH_ONNX
+
+
+def test_resolve_frontend_unknown_fails_closed() -> None:
+    with pytest.raises(ExportError):
+        resolve_frontend("tensorrt")
+
+
+def test_frontend_registry_capabilities() -> None:
+    assert set(EXPORT_FRONTEND_REGISTRY) == {ExportFrontend.OPTIMUM_ONNX, ExportFrontend.TORCH_ONNX}
+    assert "inference" in EXPORT_FRONTEND_REGISTRY[ExportFrontend.OPTIMUM_ONNX].capabilities
+    assert "training" in EXPORT_FRONTEND_REGISTRY[ExportFrontend.TORCH_ONNX].capabilities
+
+
+# --- discovery (needs optimum, no network) --------------------------------------------------------
+@requires_optimum
+@pytest.mark.parametrize("model_type", ["llama", "phi3", "qwen2"])
+def test_discovery_supported_model_types(model_type: str) -> None:
+    tasks = supported_onnx_tasks(model_type)
+    assert tasks, f"{model_type} should have ONNX tasks"
+    assert "text-generation-with-past" in tasks
+    assert is_supported(model_type)
+
+
+@requires_optimum
+def test_discovery_unknown_model_type_is_empty_not_raising() -> None:
+    assert supported_onnx_tasks("totally-unknown-xyz") == ()
+    assert not is_supported("totally-unknown-xyz")
diff --git a/tests/export/test_registry_matches_optimum.py b/tests/export/test_registry_matches_optimum.py
new file mode 100644
index 0000000..5075d61
--- /dev/null
+++ b/tests/export/test_registry_matches_optimum.py
@@ -0,0 +1,182 @@
+"""Cross-check: every `ArchitectureSpec.onnx_config_class` is the one Optimum itself would pick.
+
+Env-gated on the `export` profile (needs optimum + transformers); no network, no model downloads.
+
+## Why this exists
+
+`ArchitectureSpec.onnx_config_class` is a **lazy dotted path**. It is resolved only when a training
+export actually runs, so a wrong binding is invisible to every other gate — it does not fail import,
+lint, typecheck or any unit test. The registry carried the note *"corrected but NOT exercised end to
+end"* for exactly this reason.
+
+It was wrong. `Gemma3ForCausalLM` bound `Gemma3OnnxConfig`, which is the **multimodal** config: its
+`__init__` does `super().__init__(config.text_config, ...)`, and a text-only Gemma-3 config
+(`google/gemma-3-270m`, `model_type: gemma3_text`) has no `text_config`. Every training export of a
+Gemma-3 would have died with `AttributeError`. Optimum maps `gemma3_text` to `Gemma3TextOnnxConfig`.
+
+The generalizing fix is this test rather than one corrected row: Optimum's `TasksManager` already
+knows the right answer for every model type it supports, so the registry is checked **against** it
+instead of being maintained in parallel and hoping the two agree.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("optimum.exporters.onnx", reason="export profile only")
+pytest.importorskip("transformers", reason="export profile only")
+
+from mobiletransformers.config.registry.architecture import ARCHITECTURE_REGISTRY  # noqa: E402
+
+
+def _optimum_config_for(model_type: str) -> type | None:
+    """The ONNX config class Optimum's TasksManager maps `model_type` to, or None if unsupported."""
+    import optimum.exporters.onnx.model_configs  # noqa: F401  # decorator registration
+    from optimum.exporters.tasks import TasksManager
+
+    entry = TasksManager._SUPPORTED_MODEL_TYPE.get(model_type, {}).get("onnx")
+    if not entry:
+        return None
+    # Values are `functools.partial(SomeOnnxConfig, task=..., use_past=...)`.
+    constructor = next(iter(entry.values()))
+    return getattr(constructor, "func", constructor)
+
+
+def _model_types_for_architecture(architecture: str) -> set[str]:
+    """Every `model_type` whose auto-mapping declares this architecture class name."""
+    from transformers.models.auto import modeling_auto
+
+    found: set[str] = set()
+    for attr in dir(modeling_auto):
+        if not attr.endswith("_MAPPING_NAMES"):
+            continue
+        mapping = getattr(modeling_auto, attr)
+        if not isinstance(mapping, dict):
+            continue
+        for model_type, names in mapping.items():
+            candidates = {names} if isinstance(names, str) else set(names)
+            if architecture in candidates:
+                found.add(model_type)
+    return found
+
+
+@pytest.mark.parametrize("architecture", sorted(ARCHITECTURE_REGISTRY))
+def test_registry_binding_matches_optimum_task_manager(architecture: str) -> None:
+    """A row's ONNX config must be the class Optimum resolves for that architecture's model type."""
+    spec = ARCHITECTURE_REGISTRY[architecture]
+    if spec.onnx_config_class is None:
+        pytest.skip(f"{architecture} is inference-only (no Optimum config by design)")
+
+    model_types = _model_types_for_architecture(architecture)
+    if not model_types:
+        pytest.skip(f"{architecture} is not in this transformers line's auto-mappings")
+
+    expected = {_optimum_config_for(mt) for mt in model_types}
+    expected.discard(None)
+    if not expected:
+        pytest.skip(f"Optimum has no ONNX config for {sorted(model_types)}")
+
+    declared = spec.onnx_config_class.rsplit(".", 1)[-1]
+    expected_names = {cls.__name__ for cls in expected}
+
+    assert declared in expected_names, (
+        f"{architecture} (model_type {sorted(model_types)}) is bound to {declared!r}, but Optimum "
+        f"resolves {sorted(expected_names)}. A lazy dotted path makes this invisible until an export "
+        "runs — fix the registry row, not this test."
+    )
+
+
+def _default_config_for(architecture: str):
+    """A default `PretrainedConfig` for this architecture's model type, built offline.
+
+    `AutoConfig.for_model` constructs from the class defaults — no checkpoint, no network. The
+    dimensions are irrelevant here: an `OnnxConfig`'s `inputs` are decided by the model *type*, not
+    by its sizes.
+    """
+    from transformers import AutoConfig
+
+    for model_type in sorted(_model_types_for_architecture(architecture)):
+        try:
+            return AutoConfig.for_model(model_type)
+        except (ValueError, KeyError):
+            continue
+    return None
+
+
+@pytest.mark.parametrize("architecture", sorted(ARCHITECTURE_REGISTRY))
+def test_trainer_wrapper_signature_matches_the_configs_input_set(architecture: str) -> None:
+    """A trainable row's wrapper must declare exactly its OnnxConfig's inputs, in order.
+
+    Optimum hands the dummy inputs to the traced module **positionally**, so the wrapper's parameter
+    list and `OnnxConfig.inputs` are one contract with two authors. When they disagree every argument
+    shifts by one and `labels` lands in some other tensor's slot.
+
+    Two architectures have already hit this, from opposite directions — `Gemma3ForCausalLM` (no
+    `position_ids`, decoder) and `DistilBertForSequenceClassification` (no `token_type_ids`, encoder)
+    — and both were found only when someone ran that specific export. The production cross-check
+    `_check_wrapper_matches_config_inputs` fails closed at export time; this runs it against **every**
+    row on the host, so the next architecture whose config omits an input is a red test rather than a
+    failed export.
+
+    It calls the production function rather than reimplementing the comparison: a test that derives
+    the same answer a second way would pass while the shipping check drifted.
+
+    Needs `peft` on top of the export profile's optimum, because `training_export` imports it at
+    module scope — so this runs under `ort-training-local` (`make test-train`) and skips elsewhere.
+    Probed by importing rather than by `find_spec`, for the reason recorded as gotcha 14.
+    """
+    pytest.importorskip("peft", reason="training_export imports peft at module scope")
+
+    from mobiletransformers.config.registry.architecture import import_from_path
+    from mobiletransformers.config.registry.task import get_task_spec
+    from mobiletransformers.export.onnx_config_with_loss import OnnxConfigWithLoss
+    from mobiletransformers.export.training_export import _check_wrapper_matches_config_inputs
+
+    spec = ARCHITECTURE_REGISTRY[architecture]
+    if spec.onnx_config_class is None:
+        pytest.skip(f"{architecture} is inference-only (no Optimum config by design)")
+
+    task_spec = get_task_spec(spec.task)
+    if not task_spec.trainable:
+        pytest.skip(f"{spec.task.value} is not trainable, so no wrapper is ever chosen")
+
+    config = _default_config_for(architecture)
+    if config is None:
+        pytest.skip(f"{architecture} is not in this transformers line's auto-mappings")
+
+    onnx_config = spec.load_onnx_config_class()(
+        config,
+        task=spec.task.value,
+        **task_spec.onnx_config_kwargs(training_mode=True),
+    )
+    wrapper = import_from_path(spec.trainer_wrapper_class or task_spec.trainer_wrapper_class)
+
+    # Raises UnsupportedModelError naming both lists when they disagree.
+    _check_wrapper_matches_config_inputs(wrapper, OnnxConfigWithLoss(onnx_config))
+
+
+def test_gemma3_binds_the_text_config_not_the_multimodal_one() -> None:
+    """The specific defect this file was written for, pinned by name.
+
+    `Gemma3OnnxConfig` reads `config.text_config`; a `Gemma3TextConfig` has no such attribute, so the
+    binding was not merely imprecise — it could not construct at all.
+    """
+    spec = ARCHITECTURE_REGISTRY["Gemma3ForCausalLM"]
+    assert spec.onnx_config_class.endswith("Gemma3TextOnnxConfig")
+
+    from transformers import Gemma3TextConfig
+
+    config = Gemma3TextConfig(
+        vocab_size=64,
+        hidden_size=32,
+        num_hidden_layers=2,
+        num_attention_heads=2,
+        num_key_value_heads=1,
+        intermediate_size=37,
+        head_dim=16,
+    )
+    onnx_config = spec.load_onnx_config_class()(config, task="text-generation", use_past=True)
+    outputs = list(onnx_config.outputs)
+    # The canonical contract `export/normalize.py` enforces on every package.
+    assert outputs[0] == "logits"
+    assert outputs[1:3] == ["present.0.key", "present.0.value"]
diff --git a/tests/export/test_support_matrix.py b/tests/export/test_support_matrix.py
new file mode 100644
index 0000000..82a0e1d
--- /dev/null
+++ b/tests/export/test_support_matrix.py
@@ -0,0 +1,58 @@
+"""Integration test for support-matrix merge (plan #7). Pure JSON — runs in any profile."""
+
+from __future__ import annotations
+
+import copy
+
+from mobiletransformers.export.support_matrix import (
+    SupportRow,
+    update_support_matrix,
+    write_matrix,
+)
+
+
+def _row(model_id: str, model_type: str, ok: bool) -> SupportRow:
+    return SupportRow(
+        model_id=model_id,
+        model_type=model_type,
+        optimum_exportable=ok,
+        mobile_package_exportable=ok,
+        supported_tasks=("text-generation-with-past",) if ok else (),
+        chosen_task="text-generation-with-past" if ok else None,
+        blocker=None if ok else "no ONNX exporter",
+        toolchain={"optimum": "2.1.0"} if ok else {},
+    )
+
+
+def test_merge_two_synthetic_results(tmp_path) -> None:
+    path = tmp_path / "model_support_matrix.json"
+    update_support_matrix(path, _row("org/good", "llama", True))
+    matrix = update_support_matrix(path, _row("org/bad", "myst", False))
+
+    good = matrix["models"]["org/good"]
+    bad = matrix["models"]["org/bad"]
+    assert good["optimum_exportable"] is True and good["mobile_package_exportable"] is True
+    assert bad["optimum_exportable"] is False and bad["mobile_package_exportable"] is False
+    # deferred statuses seeded None for later plans
+    assert good["android_inference_ready"] is None
+    assert matrix["schemaVersion"] == "1.0"
+
+
+def test_merge_is_idempotent(tmp_path) -> None:
+    path = tmp_path / "m.json"
+    row = _row("org/good", "llama", True)
+    first = copy.deepcopy(update_support_matrix(path, row))
+    second = update_support_matrix(path, row)
+    assert second == first
+
+
+def test_merge_preserves_later_plan_status(tmp_path) -> None:
+    path = tmp_path / "m.json"
+    row = _row("org/good", "llama", True)
+    matrix = update_support_matrix(path, row)
+    # A later plan flips a deferred status it owns.
+    matrix["models"]["org/good"]["android_inference_ready"] = True
+    write_matrix(matrix, path)
+    # Re-merging the #7 row must not clobber the later plan's value.
+    remerged = update_support_matrix(path, row)
+    assert remerged["models"]["org/good"]["android_inference_ready"] is True
diff --git a/tests/export/test_tokenizer_export.py b/tests/export/test_tokenizer_export.py
new file mode 100644
index 0000000..a0a1b39
--- /dev/null
+++ b/tests/export/test_tokenizer_export.py
@@ -0,0 +1,164 @@
+"""The on-device tokenizer config: what goes in it, and which object each field comes from.
+
+``mobiletransformers_tokenizer_config.json`` is the only file the Android Native tokenizer reads for
+``vocab_size``, and that number bounds the sampler's argmax scan over the logits row. A value larger
+than the embedding table lets the sampler return an id with no embedding row, which ORT then fails on
+in the next step's ``Gather``. So these are correctness tests, not formatting ones.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.export.tokenizer_export import build_device_tokenizer_config
+
+
+class FakeConfig:
+    """A stand-in for a transformers config: attributes only, nothing else is used."""
+
+    def __init__(self, **fields):
+        for key, value in fields.items():
+            setattr(self, key, value)
+
+
+class FakeTokenizer:
+    def __init__(self, vocab_size: int, added: dict[str, int] | None = None, **ids):
+        self._vocab = {f"tok{i}": i for i in range(vocab_size)}
+        self._added = added or {}
+        for key, value in ids.items():
+            setattr(self, key, value)
+
+    def get_vocab(self):
+        return self._vocab
+
+    def get_added_vocab(self):
+        return self._added
+
+
+def gemma3_text_config() -> FakeConfig:
+    """``google/functiongemma-270m-it`` as its config.json actually reads."""
+    return FakeConfig(
+        model_type="gemma3_text",
+        vocab_size=262144,
+        num_hidden_layers=18,
+        num_attention_heads=4,
+        num_key_value_heads=1,
+        max_position_embeddings=32768,
+        bos_token_id=2,
+        eos_token_id=[1, 50],
+        pad_token_id=0,
+    )
+
+
+def gemma3_generation_config() -> FakeConfig:
+    """Its generation_config.json: token ids and nothing else — no architecture fields at all."""
+    return FakeConfig(bos_token_id=2, eos_token_id=[1, 50, 106], pad_token_id=0)
+
+
+def test_vocab_size_comes_from_the_model_not_the_tokenizer():
+    """The regression that produced ``idx=262145 ... range [-262144,262143]`` on device.
+
+    FunctionGemma's tokenizer declares ``<image_soft_token>`` (262144) and ``<end_of_image>``
+    (262145) above a 262144-row embedding table. Sizing the sampler from the tokenizer let it read
+    two floats past the end of every logits row and return an id with no embedding.
+    """
+    added = {"<image_soft_token>": 262144, "<end_of_image>": 262145}
+    tokenizer = FakeTokenizer(vocab_size=262144, added=added)
+
+    payload = build_device_tokenizer_config(gemma3_text_config(), gemma3_generation_config(), tokenizer)
+
+    assert payload["model"]["vocab_size"] == 262144, (
+        "the emitted vocab size must be the number of embedding rows; anything the tokenizer can "
+        "address above that has no row and must never be sampled"
+    )
+
+
+def test_architecture_fields_come_from_the_model_config_not_the_defaults():
+    """A ``GenerationConfig`` has none of these, so reading it wrote 12/12/12/2048/'unknown'."""
+    payload = build_device_tokenizer_config(gemma3_text_config(), gemma3_generation_config(), None)
+
+    model = payload["model"]
+    assert model["num_hidden_layers"] == 18
+    assert model["num_attention_heads"] == 4
+    assert model["num_key_value_heads"] == 1
+    assert model["context_length"] == 32768
+    assert model["type"] == "gemma3_text"
+
+
+def test_a_null_bos_in_the_generation_config_falls_through_to_the_model():
+    """``getattr(cfg, 'bos_token_id', 2)`` returns None for a declared-null field, not 2."""
+    generation = FakeConfig(bos_token_id=None, eos_token_id=[1, 50, 106], pad_token_id=None)
+
+    payload = build_device_tokenizer_config(gemma3_text_config(), generation, None)
+
+    assert payload["model"]["bos_token_id"] == 2
+    assert payload["model"]["pad_token_id"] == 0
+
+
+def test_the_generation_config_wins_for_eos():
+    """It commonly stops on more tokens than the model config lists — ``106`` is ``<end_of_turn>``."""
+    payload = build_device_tokenizer_config(gemma3_text_config(), gemma3_generation_config(), None)
+
+    assert payload["model"]["eos_token_id"] == [1, 50, 106]
+
+
+def test_a_nested_text_config_is_used_for_the_decoder_shape():
+    """Multimodal configs describe the composite at the top level and the decoder underneath."""
+    composite = FakeConfig(
+        model_type="gemma3",
+        text_config=FakeConfig(
+            model_type="gemma3_text",
+            vocab_size=262144,
+            num_hidden_layers=18,
+            num_attention_heads=4,
+            max_position_embeddings=32768,
+            eos_token_id=[1, 50],
+        ),
+    )
+
+    payload = build_device_tokenizer_config(composite, None, None)
+
+    assert payload["model"]["vocab_size"] == 262144
+    assert payload["model"]["num_hidden_layers"] == 18
+
+
+def test_a_model_config_without_a_vocab_size_is_an_export_failure():
+    """Failing the export beats emitting a guess that only fails once it is on a phone."""
+    with pytest.raises(ValueError, match="vocab_size"):
+        build_device_tokenizer_config(FakeConfig(model_type="mystery"), None, FakeTokenizer(vocab_size=1000))
+
+
+def test_pad_falls_back_to_the_first_eos_when_nothing_declares_one():
+    payload = build_device_tokenizer_config(
+        FakeConfig(model_type="llama", vocab_size=32000, eos_token_id=[2, 32001]),
+        None,
+        None,
+    )
+
+    assert payload["model"]["pad_token_id"] == 2
+
+
+def test_smollm2_still_emits_what_it_did_before():
+    """The control: the model this was silently wrong for, but which happened to work.
+
+    Its tokenizer and its config agree on 49152, so the old tokenizer-derived path produced the right
+    number by luck. The architecture fields it used to get wrong are now right, and the one field the
+    device actually depends on is unchanged — this must not move.
+    """
+    config = FakeConfig(
+        model_type="llama",
+        vocab_size=49152,
+        num_hidden_layers=30,
+        num_attention_heads=9,
+        num_key_value_heads=3,
+        max_position_embeddings=8192,
+        bos_token_id=1,
+        eos_token_id=2,
+        pad_token_id=2,
+    )
+
+    payload = build_device_tokenizer_config(config, None, FakeTokenizer(vocab_size=49152))
+
+    assert payload["model"]["vocab_size"] == 49152
+    assert payload["model"]["num_hidden_layers"] == 30
+    assert payload["model"]["type"] == "llama"
diff --git a/tests/federated/__init__.py b/tests/federated/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/federated/_helpers.py b/tests/federated/_helpers.py
new file mode 100644
index 0000000..7eab783
--- /dev/null
+++ b/tests/federated/_helpers.py
@@ -0,0 +1,73 @@
+"""Build a tiny two-layer HandoffMap + matching arrays for #35 federated tests (pure numpy).
+
+**Rank-r shaped as of #35's vocabulary decision (2026-08-09).** Federation exchanges the adapter
+FACTORS (`lora_A`/`lora_B`), not the merged inference initializers, so the fixture describes two
+adapted layers with their factor dtypes/shapes rather than two full-size merged weights.
+
+Each layer is deliberately given a different `(rank, in, out)` so a codec that silently transposed or
+reordered anything would produce a shape error rather than a plausible-looking record.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from mobiletransformers.artifacts.handoff_map import HandoffEntry, HandoffMap
+
+_NAME_A = "model.layers.0.attn.q_proj.MatMul.weight"
+_NAME_B = "model.layers.1.attn.v_proj.MatMul.weight"
+
+#: Layer 0: rank 2, in 3, out 4.  Layer 1: rank 2, in 5, out 6.
+_A0_SHAPE, _B0_SHAPE = (2, 3), (4, 2)
+_A1_SHAPE, _B1_SHAPE = (2, 5), (6, 2)
+
+
+def _entry(
+    name: str,
+    layer: int,
+    merged_shape: tuple[int, ...],
+    a_shape: tuple[int, int],
+    b_shape: tuple[int, int],
+) -> HandoffEntry:
+    return HandoffEntry(
+        training_base_layer_name=(
+            f"backbone.model.layers.{layer}.self_attn.{'q_proj' if layer == 0 else 'v_proj'}.base_layer"
+        ),
+        dtype="float32",
+        shape=merged_shape,
+        checkpoint_names={
+            "adapter_A": f"l{layer}.lora_A.lora",
+            "adapter_B": f"l{layer}.lora_B.lora",
+            "weight": f"l{layer}.weight",
+        },
+        # Schema 1.1: the map DESCRIBES the factors, it does not merely name them.
+        adapter_dtypes={"adapter_A": "float32", "adapter_B": "float32"},
+        adapter_shapes={"adapter_A": a_shape, "adapter_B": b_shape},
+        merger_output_names={"weight": "merged_weight"},
+        merged_tensor_names={"weight": name},
+        inference_initializer_names={"weight": name},
+        external_data_location={"weight": f"{name}.bin"},
+    )
+
+
+def make_handoff() -> HandoffMap:
+    """A deterministic 2-layer / 4-factor handoff map (all float32, all shapes distinct)."""
+    return HandoffMap(
+        entries=[
+            _entry(_NAME_A, 0, (4, 3), _A0_SHAPE, _B0_SHAPE),
+            _entry(_NAME_B, 1, (6, 5), _A1_SHAPE, _B1_SHAPE),
+        ]
+    )
+
+
+def make_arrays(scale: float = 1.0) -> list[np.ndarray]:
+    """Arrays in codec order for :func:`make_handoff`.
+
+    Order: entries sorted by canonical weight name (`layers.0` < `layers.1`), and within an entry the
+    canonical `HandoffEntry.ADAPTER_ROLE_ORDER` (`adapter_A` before `adapter_B`).
+    """
+    arrays = []
+    for shape in (_A0_SHAPE, _B0_SHAPE, _A1_SHAPE, _B1_SHAPE):
+        size = int(np.prod(shape))
+        arrays.append(np.arange(size, dtype=np.float32).reshape(shape) * scale)
+    return arrays
diff --git a/tests/federated/fixtures/federated_record.golden.bin b/tests/federated/fixtures/federated_record.golden.bin
new file mode 100644
index 0000000..304fb55
Binary files /dev/null and b/tests/federated/fixtures/federated_record.golden.bin differ
diff --git a/tests/federated/gen_serialization_golden.py b/tests/federated/gen_serialization_golden.py
new file mode 100644
index 0000000..ac2155c
--- /dev/null
+++ b/tests/federated/gen_serialization_golden.py
@@ -0,0 +1,30 @@
+"""Regenerate the federated-record byte golden (run from the repo root under the core/dev env).
+
+python -m tests.federated.gen_serialization_golden
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def main() -> None:
+    rec = FederatedAdapterRecord.from_handoff(
+        make_handoff(),
+        make_arrays(),
+        base_model_id="org/base",
+        peft_method="lora",
+        round=0,
+        package_revision="rev-1",
+    )
+    out = Path(__file__).parent / "fixtures" / "federated_record.golden.bin"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_bytes(rec.serialize())
+    print(f"wrote {out} ({out.stat().st_size} bytes)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/federated/test_aggregate_round.py b/tests/federated/test_aggregate_round.py
new file mode 100644
index 0000000..2683d4f
--- /dev/null
+++ b/tests/federated/test_aggregate_round.py
@@ -0,0 +1,83 @@
+"""#35: one server round — aggregate, wrap in the codec-ordered record, persist.
+
+``build_server_app`` used to discard all five of its arguments and return a bare ``ServerApp()``: no
+strategy, no round loop, no handler. ``federated_average`` was wired to nothing and
+``save_global_adapter`` had no caller, so ``run_simulation`` reported success for an ``--output``
+directory that was guaranteed to be empty. :func:`aggregate_round` is the whole server side of a round
+minus the Flower messaging, which is why it can be tested here without ``flwr``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from mobiletransformers.federated.flower_sim import ClientUpdate, aggregate_round
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def _round(tmp_path, updates, round_index=1):
+    return aggregate_round(
+        make_handoff(),
+        updates,
+        base_model_id="org/base",
+        peft_method="lora",
+        round_index=round_index,
+        output_dir=tmp_path,
+    )
+
+
+def test_round_writes_a_readable_global_adapter(tmp_path):
+    updates = [ClientUpdate(make_arrays(scale=1.0), 2), ClientUpdate(make_arrays(scale=3.0), 2)]
+
+    aggregated, path = _round(tmp_path, updates)
+
+    assert path.is_file(), "the round must persist an artifact — --output was never written before"
+    assert path.name == "global_adapter_round1.mtfed"
+
+    restored = FederatedAdapterRecord.deserialize(path.read_bytes())
+    assert restored.round == 1
+    assert restored.base_model_id == "org/base"
+    assert len(restored.arrays) == len(aggregated)
+    for got, expected in zip(restored.to_ndarrays(), aggregated, strict=True):
+        assert np.allclose(got, expected)
+
+
+def test_round_result_is_the_weighted_mean(tmp_path):
+    a, b = make_arrays(scale=1.0), make_arrays(scale=3.0)
+    aggregated, _ = _round(tmp_path, [ClientUpdate(a, 1), ClientUpdate(b, 3)])
+    for got, base in zip(aggregated, a, strict=True):
+        assert np.allclose(got, base * 2.5)  # (1*a + 3*3a)/4
+
+
+def test_round_records_participation_metrics(tmp_path):
+    updates = [ClientUpdate(make_arrays(), 5), None, ClientUpdate(make_arrays(), 7)]
+    _, path = _round(tmp_path, updates)
+    metrics = FederatedAdapterRecord.deserialize(path.read_bytes()).metrics
+    assert metrics["clients"] == 2
+    assert metrics["dropped"] == 1
+    assert metrics["numExamples"] == 12
+
+
+def test_rounds_produce_distinct_artifacts(tmp_path):
+    _, first = _round(tmp_path, [ClientUpdate(make_arrays(), 1)], round_index=1)
+    _, second = _round(tmp_path, [ClientUpdate(make_arrays(), 1)], round_index=2)
+    assert first != second
+    assert sorted(p.name for p in tmp_path.glob("*.mtfed")) == [
+        "global_adapter_round1.mtfed",
+        "global_adapter_round2.mtfed",
+    ]
+
+
+def test_round_fails_closed_when_every_client_dropped(tmp_path):
+    with pytest.raises(HandoffError, match="no surviving client updates"):
+        _round(tmp_path, [None, None])
+    assert not list(tmp_path.glob("*.mtfed")), "a failed round must not leave an artifact behind"
+
+
+def test_round_fails_closed_on_tensor_count_mismatch(tmp_path):
+    short = make_arrays()[:-1]
+    with pytest.raises(HandoffError):
+        _round(tmp_path, [ClientUpdate(make_arrays(), 1), ClientUpdate(short, 1)])
diff --git a/tests/federated/test_codec_roundtrip.py b/tests/federated/test_codec_roundtrip.py
new file mode 100644
index 0000000..01c9172
--- /dev/null
+++ b/tests/federated/test_codec_roundtrip.py
@@ -0,0 +1,43 @@
+"""#35: the federated record round-trips byte-identically with codec-derived tensor order."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord, codec_tensor_specs
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def test_tensor_order_is_codec_derived():
+    handoff = make_handoff()
+    specs = codec_tensor_specs(handoff)
+    # Order is (entries sorted by canonical weight name) x (HandoffEntry.ADAPTER_ROLE_ORDER).
+    # Rank-r factors as of #35, so two per adapted layer rather than one merged weight.
+    assert [s.name for s in specs] == [
+        "l0.lora_A.lora.weight",
+        "l0.lora_B.lora.weight",
+        "l1.lora_A.lora.weight",
+        "l1.lora_B.lora.weight",
+    ]
+    assert [s.role for s in specs] == ["adapter_A", "adapter_B", "adapter_A", "adapter_B"]
+    assert {s.aggregation_role for s in specs} == {"adapter_only"}
+
+
+def test_record_roundtrip_byte_identical():
+    handoff = make_handoff()
+    arrays = make_arrays()
+    rec = FederatedAdapterRecord.from_handoff(
+        handoff, arrays, base_model_id="org/base", peft_method="lora", round=1
+    )
+
+    blob = rec.serialize()
+    back = FederatedAdapterRecord.deserialize(blob)
+
+    assert back.base_model_id == "org/base"
+    assert back.peft_method == "lora"
+    assert back.round == 1
+    assert [t.name for t in back.tensors] == [t.name for t in rec.tensors]
+    for orig, restored in zip(arrays, back.to_ndarrays(), strict=True):
+        assert np.array_equal(orig, restored)
+    # re-serializing the deserialized record reproduces the exact bytes.
+    assert back.serialize() == blob
diff --git a/tests/federated/test_comm_size.py b/tests/federated/test_comm_size.py
new file mode 100644
index 0000000..4340ad8
--- /dev/null
+++ b/tests/federated/test_comm_size.py
@@ -0,0 +1,58 @@
+"""#35: per-round communication size is measured, bounded, and rank-r rather than merged-weight sized.
+
+The size question is the whole reason the vocabulary decision existed, so it gets a test that states
+the trade-off rather than a magic byte count.
+"""
+
+from __future__ import annotations
+
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def test_comm_size_bounded_and_accounts_for_payload():
+    handoff = make_handoff()
+    arrays = make_arrays()
+    rec = FederatedAdapterRecord.from_handoff(handoff, arrays, base_model_id="org/base", peft_method="lora")
+
+    # Payload = the four float32 ADAPTER FACTORS: (2,3) + (4,2) + (2,5) + (6,2) = 36 floats.
+    raw_payload = sum(a.nbytes for a in arrays)
+    assert raw_payload == 36 * 4
+
+    size = rec.comm_size_bytes()
+    # size = 4 (header length) + JSON header + raw payload; must exceed the payload and stay small.
+    assert size > raw_payload + 4
+    assert size < raw_payload + 4096  # header is tiny for a 4-tensor LoRA record
+
+
+def test_rank_r_exchange_is_far_smaller_than_merged_at_real_dimensions():
+    """Why #35 chose rank-r factors over merged weights, pinned as arithmetic.
+
+    The toy fixture above cannot show this — at `r=2` with `d` of 3..6 the factors are no smaller than
+    the weight, which is exactly right and exactly why the fixture is a poor place to assert it. At
+    real dimensions the ratio is `d_in * d_out / (r * (d_in + d_out))`.
+
+    Numbers are SmolLM2-135M's adapted layers, the model this project actually ships: `q_proj` is
+    576x576 and `v_proj` is 576x192, r=8, 30 layers, two adapted modules per layer.
+    """
+    rank = 8
+    layers = 30
+    adapted = [(576, 576), (576, 192)]  # q_proj, v_proj
+
+    merged_floats = layers * sum(d_in * d_out for d_in, d_out in adapted)
+    factor_floats = layers * sum(rank * (d_in + d_out) for d_in, d_out in adapted)
+
+    # 60 merged tensors vs 120 rank-r factors — more tensors, far fewer numbers.
+    assert merged_floats == 30 * (576 * 576 + 576 * 192)
+
+    # Cross-check against a number the pipeline records independently: the shipped SmolLM2 package's
+    # `trainable_parameter_count`. If these two ever disagree, one of them is describing a different
+    # adapter set than the other — which is precisely the confusion #35 was stuck in.
+    assert factor_floats == 460_800
+
+    ratio = merged_floats / factor_floats
+    assert ratio > 25, f"expected a large saving at r={rank}, got {ratio:.1f}x"  # measured 28.8x
+
+    # And the saving grows as rank shrinks relative to the dimensions.
+    smaller_rank_floats = layers * sum(4 * (d_in + d_out) for d_in, d_out in adapted)
+    assert merged_floats / smaller_rank_floats > ratio
diff --git a/tests/federated/test_dropout.py b/tests/federated/test_dropout.py
new file mode 100644
index 0000000..d97f920
--- /dev/null
+++ b/tests/federated/test_dropout.py
@@ -0,0 +1,31 @@
+"""#35: a dropped client (missing reply) does not stall aggregation — it completes over the survivors."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.flower_sim import ClientUpdate, federated_average
+from tests.federated._helpers import make_arrays
+
+
+def test_dropped_client_skipped():
+    a = make_arrays(scale=1.0)
+    c = make_arrays(scale=5.0)
+    # middle client dropped (None); aggregation runs over clients 1 and 3.
+    agg = federated_average([ClientUpdate(a, 1), None, ClientUpdate(c, 1)])
+    for i in range(len(a)):
+        assert np.allclose(agg[i], (a[i] + c[i]) / 2)
+
+
+def test_all_clients_dropped_fails_closed():
+    with pytest.raises(HandoffError, match="no surviving client"):
+        federated_average([None, None])
+
+
+def test_tensor_count_mismatch_fails_closed():
+    a = make_arrays()
+    bad = [a[0]]  # one tensor instead of two
+    with pytest.raises(HandoffError, match="tensor-count mismatch"):
+        federated_average([ClientUpdate(a, 1), ClientUpdate(bad, 1)])
diff --git a/tests/federated/test_fedavg_aggregation.py b/tests/federated/test_fedavg_aggregation.py
new file mode 100644
index 0000000..b5113b2
--- /dev/null
+++ b/tests/federated/test_fedavg_aggregation.py
@@ -0,0 +1,48 @@
+"""#35: FedAvg aggregation equals the (weighted) mean; the global artifact is written."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from mobiletransformers.federated.flower_sim import (
+    ClientUpdate,
+    federated_average,
+    save_global_adapter,
+)
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def test_weighted_average_matches_manual_mean():
+    a = make_arrays(scale=1.0)  # client 1 tensors
+    b = make_arrays(scale=3.0)  # client 2 tensors
+    updates = [ClientUpdate(a, num_examples=1), ClientUpdate(b, num_examples=3)]
+
+    agg = federated_average(updates)
+
+    # weighted mean: (1*a + 3*b) / 4 = (a + 3*(3a)) / 4 = (a + 9a)/4 = 2.5*a  (since b == 3a)
+    for i, expected in enumerate(a):
+        assert np.allclose(agg[i], expected * 2.5)
+
+
+def test_equal_weight_average():
+    a = make_arrays(scale=2.0)
+    b = make_arrays(scale=4.0)
+    agg = federated_average([ClientUpdate(a, 1), ClientUpdate(b, 1)])
+    for i in range(len(a)):
+        assert np.allclose(agg[i], (a[i] + b[i]) / 2)
+
+
+def test_global_artifact_written(tmp_path):
+    handoff = make_handoff()
+    agg = federated_average([ClientUpdate(make_arrays(1.0), 1), ClientUpdate(make_arrays(3.0), 3)])
+    rec = FederatedAdapterRecord.from_handoff(
+        handoff, agg, base_model_id="org/base", peft_method="lora", round=2
+    )
+    path = save_global_adapter(rec, tmp_path)
+    assert path.name == "global_adapter_round2.mtfed"
+    assert path.exists()
+    # the saved artifact deserializes back to the aggregated tensors.
+    back = FederatedAdapterRecord.deserialize(path.read_bytes())
+    for orig, restored in zip(agg, back.to_ndarrays(), strict=True):
+        assert np.array_equal(orig, restored)
diff --git a/tests/federated/test_format_version.py b/tests/federated/test_format_version.py
new file mode 100644
index 0000000..1b91ff8
--- /dev/null
+++ b/tests/federated/test_format_version.py
@@ -0,0 +1,28 @@
+"""#35: adapterFormatVersion must equal the handoff schemaVersion; mismatch fails closed (F1/F8)."""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def test_matching_format_version_passes():
+    handoff = make_handoff()
+    rec = FederatedAdapterRecord.from_handoff(
+        handoff, make_arrays(), base_model_id="org/base", peft_method="lora"
+    )
+    assert rec.adapter_format_version == handoff.schema_version
+    rec.check_format(handoff)  # no raise
+
+
+def test_mismatched_format_version_fails_closed():
+    handoff = make_handoff()
+    rec = FederatedAdapterRecord.from_handoff(
+        handoff, make_arrays(), base_model_id="org/base", peft_method="lora"
+    )
+    rec.adapter_format_version = "2.0"  # simulate a record built against an incompatible codec
+    with pytest.raises(HandoffError, match="adapterFormatVersion"):
+        rec.check_format(handoff)
diff --git a/tests/federated/test_gateway.py b/tests/federated/test_gateway.py
new file mode 100644
index 0000000..b4ad262
--- /dev/null
+++ b/tests/federated/test_gateway.py
@@ -0,0 +1,136 @@
+"""#36 server half: aggregation, dropout, and refusing to publish an aggregate nobody agreed on."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.adapter_record import (
+    FederatedAdapterRecord,
+    codec_tensor_specs,
+)
+from mobiletransformers.federated.gateway import FederatedGateway
+
+from ._helpers import make_handoff
+
+
+def _record(handoff, scale: float, round_number: int = 0) -> bytes:
+    """A client record whose every tensor is a constant `scale`, so averages are checkable by hand."""
+    specs = codec_tensor_specs(handoff)
+    arrays = [np.full(tuple(s.shape), scale, dtype=np.float32) for s in specs]
+    return FederatedAdapterRecord.from_handoff(
+        handoff, arrays, base_model_id="org/base", peft_method="lora", round=round_number
+    ).serialize()
+
+
+def _gateway(handoff, **kw) -> FederatedGateway:
+    return FederatedGateway(handoff, base_model_id="org/base", **kw)
+
+
+def test_fedavg_is_weighted_by_num_examples() -> None:
+    handoff = make_handoff()
+    gw = _gateway(handoff)
+
+    # 1.0 with weight 1, 3.0 with weight 3 -> (1*1 + 3*3)/4 = 2.5
+    result = gw.aggregate([("a", _record(handoff, 1.0), 1), ("b", _record(handoff, 3.0), 3)])
+
+    decoded = FederatedAdapterRecord.deserialize(result.blob)
+    for array in decoded.arrays:
+        assert np.allclose(array, 2.5), "aggregate is not the example-weighted mean"
+    assert result.accepted == 2
+    assert result.total_examples == 4
+
+
+def test_a_dropped_client_does_not_end_the_round() -> None:
+    # Devices go offline mid-round; that is normal operation, not an error.
+    handoff = make_handoff()
+    gw = _gateway(handoff, min_clients=2)
+
+    result = gw.aggregate(
+        [("a", _record(handoff, 2.0), 1), ("b", _record(handoff, 2.0), 1), ("gone", b"", 1)]
+    )
+
+    assert result.accepted == 2
+    assert [client for client, _ in result.rejected] == ["gone"]
+
+
+def test_a_round_below_min_clients_refuses_to_publish() -> None:
+    # Publishing an aggregate two devices decided is worse than publishing nothing.
+    handoff = make_handoff()
+    gw = _gateway(handoff, min_clients=3)
+
+    with pytest.raises(HandoffError, match="min_clients"):
+        gw.aggregate([("a", _record(handoff, 1.0), 1), ("b", _record(handoff, 1.0), 1)])
+
+
+def test_a_client_running_a_different_package_is_rejected_not_coerced() -> None:
+    # Averaging in a record whose tensors do not match the package would silently corrupt the global
+    # adapter — the shapes here differ, which is exactly what "a different package" looks like.
+    handoff = make_handoff()
+    specs = codec_tensor_specs(handoff)
+    wrong = FederatedAdapterRecord.from_handoff(
+        handoff,
+        [np.full(tuple(s.shape), 1.0, dtype=np.float32) for s in specs],
+        base_model_id="org/base",
+        peft_method="lora",
+    )
+    # Corrupt one declared shape so the decoded array disagrees with the package.
+    wrong.arrays[0] = np.full((7, 7), 1.0, dtype=np.float32)
+    wrong.tensors[0].shape = (7, 7)
+
+    gw = _gateway(handoff, min_clients=1)
+    result = gw.aggregate([("ok", _record(handoff, 1.0), 1), ("bad", wrong.serialize(), 1)])
+
+    assert result.accepted == 1
+    assert result.rejected and result.rejected[0][0] == "bad"
+
+
+def test_tensors_are_matched_by_name_not_by_position() -> None:
+    # The #35 defect: pairing by iteration order would write one layer's lora_A over another's.
+    # A record serialized in a DIFFERENT order must still aggregate correctly.
+    handoff = make_handoff()
+    specs = codec_tensor_specs(handoff)
+    arrays = [np.full(tuple(s.shape), float(i + 1), dtype=np.float32) for i, s in enumerate(specs)]
+    record = FederatedAdapterRecord.from_handoff(
+        handoff, arrays, base_model_id="org/base", peft_method="lora"
+    )
+    # Reverse tensors AND arrays together: same content, different wire order.
+    record.tensors = list(reversed(record.tensors))
+    record.arrays = list(reversed(record.arrays))
+
+    gw = _gateway(handoff, min_clients=1)
+    result = gw.aggregate([("shuffled", record.serialize(), 1)])
+
+    decoded = FederatedAdapterRecord.deserialize(result.blob)
+    # Each tensor keeps ITS OWN value; a positional match would have permuted them.
+    for i, array in enumerate(decoded.arrays):
+        assert np.allclose(array, float(i + 1)), f"tensor {i} picked up another tensor's values"
+
+
+def test_a_client_with_no_examples_is_rejected() -> None:
+    handoff = make_handoff()
+    gw = _gateway(handoff, min_clients=1)
+
+    result = gw.aggregate([("ok", _record(handoff, 1.0), 2), ("empty", _record(handoff, 9.0), 0)])
+
+    assert result.accepted == 1
+    assert result.rejected[0][0] == "empty"
+
+
+def test_the_global_record_round_trips_through_the_same_codec() -> None:
+    # The bytes the server hands back must be bytes a client can read.
+    handoff = make_handoff()
+    gw = _gateway(handoff, min_clients=1)
+
+    result = gw.aggregate([("a", _record(handoff, 1.5), 1)], round_number=3)
+
+    decoded = FederatedAdapterRecord.deserialize(result.blob)
+    decoded.check_format(handoff)
+    assert decoded.round == 3
+    assert [t.name for t in decoded.tensors] == [s.name for s in codec_tensor_specs(handoff)]
+
+
+def test_min_clients_below_one_is_rejected_at_construction() -> None:
+    with pytest.raises(HandoffError, match="min_clients"):
+        _gateway(make_handoff(), min_clients=0)
diff --git a/tests/federated/test_serialization_golden.py b/tests/federated/test_serialization_golden.py
new file mode 100644
index 0000000..61525dd
--- /dev/null
+++ b/tests/federated/test_serialization_golden.py
@@ -0,0 +1,45 @@
+"""#35: freeze the pinned byte serialization as a golden (the #36 cross-language JNI contract).
+
+If this test fails after an intentional format change, regenerate the golden with:
+    python -m tests.federated.gen_serialization_golden
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mobiletransformers.federated.adapter_record import FederatedAdapterRecord
+from tests.federated._helpers import make_arrays, make_handoff
+
+_GOLDEN = Path(__file__).parent / "fixtures" / "federated_record.golden.bin"
+
+
+def _deterministic_record() -> FederatedAdapterRecord:
+    return FederatedAdapterRecord.from_handoff(
+        make_handoff(),
+        make_arrays(),
+        base_model_id="org/base",
+        peft_method="lora",
+        round=0,
+        package_revision="rev-1",
+    )
+
+
+def test_serialization_matches_golden():
+    blob = _deterministic_record().serialize()
+    assert _GOLDEN.exists(), f"missing golden {_GOLDEN}; run gen_serialization_golden.py"
+    assert blob == _GOLDEN.read_bytes()
+
+
+def test_golden_deserializes_back():
+    back = FederatedAdapterRecord.deserialize(_GOLDEN.read_bytes())
+    assert back.base_model_id == "org/base"
+    assert back.mobiletransformers_package_revision == "rev-1"
+    # Rank-r factors as of #35, in codec order: entries by canonical weight name, then adapter role.
+    assert [t.name for t in back.tensors] == [
+        "l0.lora_A.lora.weight",
+        "l0.lora_B.lora.weight",
+        "l1.lora_A.lora.weight",
+        "l1.lora_B.lora.weight",
+    ]
+    assert [t.role for t in back.tensors] == ["adapter_A", "adapter_B", "adapter_A", "adapter_B"]
diff --git a/tests/federated/test_vocabulary.py b/tests/federated/test_vocabulary.py
new file mode 100644
index 0000000..f1e2a25
--- /dev/null
+++ b/tests/federated/test_vocabulary.py
@@ -0,0 +1,86 @@
+"""#35 role/aggregation vocabulary — decided 2026-08-08, enforced on read.
+
+The record is a **wire format**: a peer builds it and this side consumes it. An enum value that is
+declared but unimplemented is therefore not harmless documentation — a peer may legitimately emit it,
+and before this change `from_bytes` accepted it and carried on, so a tensor marked `server_only` would
+have been aggregated as a weighted average. Unknown values now fail closed.
+
+**Updated 2026-08-09 (#35 rank-r decision).** The exchanged vocabulary is now the ADAPTER FACTOR
+roles (`shared_A`/`intermediate`/`adapter_A`/`adapter_B`). The merged-weight roles stay in
+`SUPPORTED_ROLES` for READ compatibility — a peer may still hold a record written under the previous
+vocabulary, and rejecting it as "unknown role" would be worse than accepting and reporting it — but
+nothing produces them any more. The golden was regenerated for this change.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+
+import numpy as np
+import pytest
+
+from mobiletransformers.exceptions import HandoffError
+from mobiletransformers.federated.adapter_record import (
+    SUPPORTED_AGGREGATIONS,
+    SUPPORTED_ROLES,
+    FederatedAdapterRecord,
+)
+from tests.federated._helpers import make_arrays, make_handoff
+
+
+def _record() -> FederatedAdapterRecord:
+    return FederatedAdapterRecord.from_handoff(
+        make_handoff(), make_arrays(), base_model_id="tiny/model", peft_method="lora"
+    )
+
+
+def _rewrite_header(blob: bytes, mutate) -> bytes:
+    """Patch the JSON header in place, keeping the payload and the length prefix consistent."""
+    (header_len,) = struct.unpack("<I", blob[:4])
+    header = json.loads(blob[4 : 4 + header_len])
+    payload = blob[4 + header_len :]
+    mutate(header)
+    new_header = json.dumps(header).encode("utf-8")
+    return struct.pack("<I", len(new_header)) + new_header + payload
+
+
+def test_v1_vocabulary_is_the_codec_vocabulary():
+    # What v1 PRODUCES: the adapter factors (#35 rank-r decision).
+    assert {"shared_A", "intermediate", "adapter_A", "adapter_B"} <= SUPPORTED_ROLES
+    # What it still ACCEPTS on read: the previous merged-weight roles.
+    assert {"weight", "weight_quantized", "scale", "zero_point"} <= SUPPORTED_ROLES
+    # The tier doc's original set was never implemented by anything, and still is not.
+    assert not SUPPORTED_ROLES & {"adapter", "trainable_weight", "head"}
+
+
+def test_aggregation_is_single_valued_in_v1():
+    assert SUPPORTED_AGGREGATIONS == {"weighted_average"}
+
+
+def test_round_trip_still_works():
+    record = _record()
+    restored = FederatedAdapterRecord.deserialize(record.serialize())
+
+    assert [t.role for t in restored.tensors] == [t.role for t in record.tensors]
+    assert all(t.aggregation in SUPPORTED_AGGREGATIONS for t in restored.tensors)
+    for got, want in zip(restored.arrays, record.arrays, strict=True):
+        np.testing.assert_array_equal(got, want)
+
+
+@pytest.mark.parametrize("bad", ["average", "server_only", "median", ""])
+def test_unknown_aggregation_is_rejected(bad):
+    """`average`/`server_only` were declared-but-unreachable; a peer emitting one must not be misread."""
+    blob = _rewrite_header(_record().serialize(), lambda h: h["tensors"][0].update(aggregation=bad))
+
+    with pytest.raises(HandoffError, match="unsupported aggregation"):
+        FederatedAdapterRecord.deserialize(blob)
+
+
+@pytest.mark.parametrize("bad", ["adapter", "trainable_weight", "head", "bias"])
+def test_unknown_role_is_rejected(bad):
+    """Including the tier doc's old vocabulary: it is not silently accepted as an alias."""
+    blob = _rewrite_header(_record().serialize(), lambda h: h["tensors"][0].update(role=bad))
+
+    with pytest.raises(HandoffError, match="unknown role"):
+        FederatedAdapterRecord.deserialize(blob)
diff --git a/tests/fixtures/__init__.py b/tests/fixtures/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/fixtures/agent/README.md b/tests/fixtures/agent/README.md
new file mode 100644
index 0000000..815ea25
--- /dev/null
+++ b/tests/fixtures/agent/README.md
@@ -0,0 +1,16 @@
+# `mobile_actions_sample.jsonl`
+
+Five records excerpted from **[`google/mobile-actions`](https://huggingface.co/datasets/google/mobile-actions)**,
+© Google, licensed **CC-BY-4.0**. Unmodified except for key ordering.
+
+Chosen to cover the shapes the importer has to get right, so
+`tests/unit/test_mobile_actions_import.py` runs offline:
+
+| records | why |
+| --- | --- |
+| 3 | `metadata: "train"`, one `tool_call` — the ordinary path |
+| 1 | `metadata: "train"`, **several** `tool_calls` — the `multi_call` policy |
+| 1 | `metadata: "eval"` — split filtering |
+
+Between them they declare all 7 tools, including `send_email` and `create_contact` whose `required`
+is a strict subset of `properties` — the case that `ActionSpec.required_parameters` exists for.
diff --git a/tests/fixtures/agent/expected_action_schema.json b/tests/fixtures/agent/expected_action_schema.json
new file mode 100644
index 0000000..c5cd89c
--- /dev/null
+++ b/tests/fixtures/agent/expected_action_schema.json
@@ -0,0 +1,85 @@
+[
+  {
+    "actionName": "create_calendar_event",
+    "allowedIntent": "android.intent.action.INSERT",
+    "parameters": {
+      "datetime": "string",
+      "title": "string"
+    },
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [
+      "datetime",
+      "title"
+    ],
+    "validationRules": {
+      "datetime": "/\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}/"
+    }
+  },
+  {
+    "actionName": "create_contact",
+    "allowedIntent": "android.intent.action.INSERT",
+    "parameters": {
+      "email": "string",
+      "first_name": "string",
+      "last_name": "string",
+      "phone_number": "string"
+    },
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [
+      "first_name",
+      "last_name"
+    ],
+    "validationRules": {}
+  },
+  {
+    "actionName": "open_wifi_settings",
+    "allowedIntent": "android.settings.WIFI_SETTINGS",
+    "parameters": {},
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [],
+    "validationRules": {}
+  },
+  {
+    "actionName": "send_email",
+    "allowedIntent": "android.intent.action.SENDTO",
+    "parameters": {
+      "body": "string",
+      "subject": "string",
+      "to": "string"
+    },
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [
+      "subject",
+      "to"
+    ],
+    "validationRules": {}
+  },
+  {
+    "actionName": "show_map",
+    "allowedIntent": "android.intent.action.VIEW",
+    "parameters": {
+      "query": "string"
+    },
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [
+      "query"
+    ],
+    "validationRules": {}
+  },
+  {
+    "actionName": "turn_off_flashlight",
+    "allowedIntent": "",
+    "parameters": {},
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [],
+    "validationRules": {}
+  },
+  {
+    "actionName": "turn_on_flashlight",
+    "allowedIntent": "",
+    "parameters": {},
+    "privacyClass": "imported-corpus",
+    "requiredParameters": [],
+    "validationRules": {}
+  }
+]
diff --git a/tests/fixtures/agent/expected_rows.jsonl b/tests/fixtures/agent/expected_rows.jsonl
new file mode 100644
index 0000000..28eaa95
--- /dev/null
+++ b/tests/fixtures/agent/expected_rows.jsonl
@@ -0,0 +1,4 @@
+{"prompt": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2025-06-04T15:29:23\nDay of week is Wednesday\nYou are a model that can do function calling with the following functions\n\nPlease set a reminder for a \"Team Sync Meeting\" this Friday, June 6th, 2025, at 2 PM.", "completion": "{\"actionName\": \"create_calendar_event\", \"parameters\": {\"datetime\": \"2025-06-06T14:00:00\", \"title\": \"Team Sync Meeting\"}}"}
+{"prompt": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-08-18T20:15:44\nDay of week is Sunday\nYou are a model that can do function calling with the following functions\n\nPlease schedule a meeting with Ms. Chen about the project proposal for Tuesday, August 20th, at 2:00 PM.", "completion": "{\"actionName\": \"create_calendar_event\", \"parameters\": {\"datetime\": \"2024-08-20T14:00:00\", \"title\": \"Meeting with Ms. Chen about the project proposal\"}}"}
+{"prompt": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-05-29T01:40:38\nDay of week is Wednesday\nYou are a model that can do function calling with the following functions\n\nPlease schedule a new calendar event for me titled \"Project Alpha Review\" on Thursday, June 6th, 2024, at 10:30 AM.", "completion": "{\"actionName\": \"create_calendar_event\", \"parameters\": {\"datetime\": \"2024-06-06T10:30:00\", \"title\": \"Project Alpha Review\"}}"}
+{"prompt": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-09-15T17:35:19\nDay of week is Sunday\nYou are a model that can do function calling with the following functions\n\nCan you please save a new contact for me? The name is Lena Petrova, the phone number is +359 888 123 456, and the email is lena.petrova.design@webmail.com.", "completion": "{\"actionName\": \"create_contact\", \"parameters\": {\"email\": \"lena.petrova.design@webmail.com\", \"first_name\": \"Lena\", \"last_name\": \"Petrova\", \"phone_number\": \"+359 888 123 456\"}}"}
diff --git a/tests/fixtures/agent/mobile_actions_sample.jsonl b/tests/fixtures/agent/mobile_actions_sample.jsonl
new file mode 100644
index 0000000..ebf8527
--- /dev/null
+++ b/tests/fixtures/agent/mobile_actions_sample.jsonl
@@ -0,0 +1,5 @@
+{"messages": [{"content": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2025-06-04T15:29:23\nDay of week is Wednesday\nYou are a model that can do function calling with the following functions\n", "role": "developer"}, {"content": "Please set a reminder for a \"Team Sync Meeting\" this Friday, June 6th, 2025, at 2 PM.", "role": "user"}, {"role": "assistant", "tool_calls": [{"function": {"arguments": {"datetime": "2025-06-06T14:00:00", "title": "Team Sync Meeting"}, "name": "create_calendar_event"}}]}], "metadata": "train", "tools": [{"function": {"description": "Turns the flashlight off.", "name": "turn_off_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Opens the Wi-Fi settings.", "name": "open_wifi_settings", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Creates a new calendar event.", "name": "create_calendar_event", "parameters": {"properties": {"datetime": {"description": "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS.", "type": "STRING"}, "title": {"description": "The title of the event.", "type": "STRING"}}, "required": ["title", "datetime"], "type": "OBJECT"}}}, {"function": {"description": "Shows a location on the map.", "name": "show_map", "parameters": {"properties": {"query": {"description": "The location to search for. May be the name of a place, a business, or an address.", "type": "STRING"}}, "required": ["query"], "type": "OBJECT"}}}, {"function": {"description": "Sends an email.", "name": "send_email", "parameters": {"properties": {"body": {"description": "The body of the email.", "type": "STRING"}, "subject": {"description": "The subject of the email.", "type": "STRING"}, "to": {"description": "The email address of the recipient.", "type": "STRING"}}, "required": ["to", "subject"], "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight on.", "name": "turn_on_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Creates a contact in the phone's contact list.", "name": "create_contact", "parameters": {"properties": {"email": {"description": "The email address of the contact.", "type": "STRING"}, "first_name": {"description": "The first name of the contact.", "type": "STRING"}, "last_name": {"description": "The last name of the contact.", "type": "STRING"}, "phone_number": {"description": "The phone number of the contact.", "type": "STRING"}}, "required": ["first_name", "last_name"], "type": "OBJECT"}}}]}
+{"messages": [{"content": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-08-18T20:15:44\nDay of week is Sunday\nYou are a model that can do function calling with the following functions\n", "role": "developer"}, {"content": "Please schedule a meeting with Ms. Chen about the project proposal for Tuesday, August 20th, at 2:00 PM.", "role": "user"}, {"role": "assistant", "tool_calls": [{"function": {"arguments": {"datetime": "2024-08-20T14:00:00", "title": "Meeting with Ms. Chen about the project proposal"}, "name": "create_calendar_event"}}]}], "metadata": "train", "tools": [{"function": {"description": "Sends an email.", "name": "send_email", "parameters": {"properties": {"body": {"description": "The body of the email.", "type": "STRING"}, "subject": {"description": "The subject of the email.", "type": "STRING"}, "to": {"description": "The email address of the recipient.", "type": "STRING"}}, "required": ["to", "subject"], "type": "OBJECT"}}}, {"function": {"description": "Shows a location on the map.", "name": "show_map", "parameters": {"properties": {"query": {"description": "The location to search for. May be the name of a place, a business, or an address.", "type": "STRING"}}, "required": ["query"], "type": "OBJECT"}}}, {"function": {"description": "Creates a new calendar event.", "name": "create_calendar_event", "parameters": {"properties": {"datetime": {"description": "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS.", "type": "STRING"}, "title": {"description": "The title of the event.", "type": "STRING"}}, "required": ["title", "datetime"], "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight off.", "name": "turn_off_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Creates a contact in the phone's contact list.", "name": "create_contact", "parameters": {"properties": {"email": {"description": "The email address of the contact.", "type": "STRING"}, "first_name": {"description": "The first name of the contact.", "type": "STRING"}, "last_name": {"description": "The last name of the contact.", "type": "STRING"}, "phone_number": {"description": "The phone number of the contact.", "type": "STRING"}}, "required": ["first_name", "last_name"], "type": "OBJECT"}}}, {"function": {"description": "Opens the Wi-Fi settings.", "name": "open_wifi_settings", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight on.", "name": "turn_on_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}]}
+{"messages": [{"content": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-05-29T01:40:38\nDay of week is Wednesday\nYou are a model that can do function calling with the following functions\n", "role": "developer"}, {"content": "Please schedule a new calendar event for me titled \"Project Alpha Review\" on Thursday, June 6th, 2024, at 10:30 AM.", "role": "user"}, {"role": "assistant", "tool_calls": [{"function": {"arguments": {"datetime": "2024-06-06T10:30:00", "title": "Project Alpha Review"}, "name": "create_calendar_event"}}]}], "metadata": "train", "tools": [{"function": {"description": "Sends an email.", "name": "send_email", "parameters": {"properties": {"body": {"description": "The body of the email.", "type": "STRING"}, "subject": {"description": "The subject of the email.", "type": "STRING"}, "to": {"description": "The email address of the recipient.", "type": "STRING"}}, "required": ["to", "subject"], "type": "OBJECT"}}}, {"function": {"description": "Creates a contact in the phone's contact list.", "name": "create_contact", "parameters": {"properties": {"email": {"description": "The email address of the contact.", "type": "STRING"}, "first_name": {"description": "The first name of the contact.", "type": "STRING"}, "last_name": {"description": "The last name of the contact.", "type": "STRING"}, "phone_number": {"description": "The phone number of the contact.", "type": "STRING"}}, "required": ["first_name", "last_name"], "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight off.", "name": "turn_off_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Creates a new calendar event.", "name": "create_calendar_event", "parameters": {"properties": {"datetime": {"description": "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS.", "type": "STRING"}, "title": {"description": "The title of the event.", "type": "STRING"}}, "required": ["title", "datetime"], "type": "OBJECT"}}}, {"function": {"description": "Opens the Wi-Fi settings.", "name": "open_wifi_settings", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight on.", "name": "turn_on_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Shows a location on the map.", "name": "show_map", "parameters": {"properties": {"query": {"description": "The location to search for. May be the name of a place, a business, or an address.", "type": "STRING"}}, "required": ["query"], "type": "OBJECT"}}}]}
+{"messages": [{"content": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2025-01-22T22:16:29\nDay of week is Wednesday\nYou are a model that can do function calling with the following functions\n", "role": "developer"}, {"content": "Turn off the flashlight and send an email to sofia.lindstrom@innotrail.net with the subject 'Quick Status Update' and the body 'Meeting finished early, heading back to the office now.'", "role": "user"}, {"role": "assistant", "tool_calls": [{"function": {"arguments": {}, "name": "turn_off_flashlight"}}, {"function": {"arguments": {"body": "Meeting finished early, heading back to the office now.", "subject": "Quick Status Update", "to": "sofia.lindstrom@innotrail.net"}, "name": "send_email"}}]}], "metadata": "train", "tools": [{"function": {"description": "Turns the flashlight on.", "name": "turn_on_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Opens the Wi-Fi settings.", "name": "open_wifi_settings", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight off.", "name": "turn_off_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Sends an email.", "name": "send_email", "parameters": {"properties": {"body": {"description": "The body of the email.", "type": "STRING"}, "subject": {"description": "The subject of the email.", "type": "STRING"}, "to": {"description": "The email address of the recipient.", "type": "STRING"}}, "required": ["to", "subject"], "type": "OBJECT"}}}, {"function": {"description": "Shows a location on the map.", "name": "show_map", "parameters": {"properties": {"query": {"description": "The location to search for. May be the name of a place, a business, or an address.", "type": "STRING"}}, "required": ["query"], "type": "OBJECT"}}}, {"function": {"description": "Creates a new calendar event.", "name": "create_calendar_event", "parameters": {"properties": {"datetime": {"description": "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS.", "type": "STRING"}, "title": {"description": "The title of the event.", "type": "STRING"}}, "required": ["title", "datetime"], "type": "OBJECT"}}}, {"function": {"description": "Creates a contact in the phone's contact list.", "name": "create_contact", "parameters": {"properties": {"email": {"description": "The email address of the contact.", "type": "STRING"}, "first_name": {"description": "The first name of the contact.", "type": "STRING"}, "last_name": {"description": "The last name of the contact.", "type": "STRING"}, "phone_number": {"description": "The phone number of the contact.", "type": "STRING"}}, "required": ["first_name", "last_name"], "type": "OBJECT"}}}]}
+{"messages": [{"content": "Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2024-09-15T17:35:19\nDay of week is Sunday\nYou are a model that can do function calling with the following functions\n", "role": "developer"}, {"content": "Can you please save a new contact for me? The name is Lena Petrova, the phone number is +359 888 123 456, and the email is lena.petrova.design@webmail.com.", "role": "user"}, {"role": "assistant", "tool_calls": [{"function": {"arguments": {"email": "lena.petrova.design@webmail.com", "first_name": "Lena", "last_name": "Petrova", "phone_number": "+359 888 123 456"}, "name": "create_contact"}}]}], "metadata": "eval", "tools": [{"function": {"description": "Opens the Wi-Fi settings.", "name": "open_wifi_settings", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Creates a contact in the phone's contact list.", "name": "create_contact", "parameters": {"properties": {"email": {"description": "The email address of the contact.", "type": "STRING"}, "first_name": {"description": "The first name of the contact.", "type": "STRING"}, "last_name": {"description": "The last name of the contact.", "type": "STRING"}, "phone_number": {"description": "The phone number of the contact.", "type": "STRING"}}, "required": ["first_name", "last_name"], "type": "OBJECT"}}}, {"function": {"description": "Shows a location on the map.", "name": "show_map", "parameters": {"properties": {"query": {"description": "The location to search for. May be the name of a place, a business, or an address.", "type": "STRING"}}, "required": ["query"], "type": "OBJECT"}}}, {"function": {"description": "Creates a new calendar event.", "name": "create_calendar_event", "parameters": {"properties": {"datetime": {"description": "The date and time of the event in the format YYYY-MM-DDTHH:MM:SS.", "type": "STRING"}, "title": {"description": "The title of the event.", "type": "STRING"}}, "required": ["title", "datetime"], "type": "OBJECT"}}}, {"function": {"description": "Sends an email.", "name": "send_email", "parameters": {"properties": {"body": {"description": "The body of the email.", "type": "STRING"}, "subject": {"description": "The subject of the email.", "type": "STRING"}, "to": {"description": "The email address of the recipient.", "type": "STRING"}}, "required": ["to", "subject"], "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight off.", "name": "turn_off_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}, {"function": {"description": "Turns the flashlight on.", "name": "turn_on_flashlight", "parameters": {"properties": {}, "type": "OBJECT"}}}]}
diff --git a/tests/fixtures/check_compat_cases.json b/tests/fixtures/check_compat_cases.json
new file mode 100644
index 0000000..96aef1c
--- /dev/null
+++ b/tests/fixtures/check_compat_cases.json
@@ -0,0 +1,15 @@
+{
+  "description": "Shared table-driven cases for check_compat(). Mirrored by Python/Kotlin/C++ readers so schema-version gating is byte-identical across languages. Owned by 00_code_plans/07 (#8).",
+  "cases": [
+    {"doc": "1.0", "minReader": "1.0", "reader": "1.0", "expect": "accept", "why": "exact match"},
+    {"doc": "1.1", "minReader": "1.0", "reader": "1.0", "expect": "accept", "why": "higher doc minor is additive, ignored"},
+    {"doc": "1.0", "minReader": "1.0", "reader": "1.5", "expect": "accept", "why": "newer reader minor reads older doc"},
+    {"doc": "0.9", "minReader": "0.9", "reader": "1.0", "expect": "accept", "why": "older doc major accepted"},
+    {"doc": "1.5", "minReader": "1.5", "reader": "1.5", "expect": "accept", "why": "reader meets minReader exactly"},
+    {"doc": "2.0", "minReader": "1.0", "reader": "1.0", "expect": "fail", "why": "doc major beyond reader"},
+    {"doc": "1.0", "minReader": "2.0", "reader": "1.0", "expect": "fail", "why": "reader below minReader major"},
+    {"doc": "1.0", "minReader": "1.5", "reader": "1.2", "expect": "fail", "why": "reader below minReader minor"},
+    {"doc": "1", "minReader": "1.0", "reader": "1.0", "expect": "fail", "why": "malformed doc version"},
+    {"doc": "1.x", "minReader": "1.0", "reader": "1.0", "expect": "fail", "why": "non-integer doc version"}
+  ]
+}
diff --git a/tests/fixtures/gen_compat_matrix_doc.py b/tests/fixtures/gen_compat_matrix_doc.py
new file mode 100644
index 0000000..9c95fcf
--- /dev/null
+++ b/tests/fixtures/gen_compat_matrix_doc.py
@@ -0,0 +1,71 @@
+"""Generate docs/COMPATIBILITY_MATRIX.md from a representative offline SupportMatrix (#31, F6).
+
+The committed doc is *rendered* (never hand-edited). Live rows come from
+`mobiletransformers support-matrix --md ...` under the export profile; this generator produces a
+deterministic, network-free sample so the page + its drift test are reproducible in the core env.
+
+Run: `python tests/fixtures/gen_compat_matrix_doc.py` (core env; no torch/optimum needed).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mobiletransformers.support.matrix import evaluate_statuses
+from mobiletransformers.support.models import CandidateEntry, SupportMatrix
+from mobiletransformers.support.render import render_matrix_markdown
+
+#: Fixed stamp/toolchain so the rendered doc is byte-deterministic across runs.
+_GENERATED_AT = "2026-07-14T00:00:00Z"
+_TOOLCHAIN = {"optimumOnnxVersion": "0.1.0", "transformersVersion": "4.46.2"}
+
+
+def build_sample_matrix() -> SupportMatrix:
+    """A representative, network-free matrix: two causal-LM rows (exportable, no device probe yet) and
+    one encoder row whose MARS target modules aren't verified (train-artifacts blocked)."""
+    rows = [
+        CandidateEntry(
+            model_id="HuggingFaceTB/SmolLM2-135M",
+            model_type="llama",
+            architectures=("LlamaForCausalLM",),
+            selected_task="text-generation-with-past",
+            supported_tasks=("text-generation", "text-generation-with-past", "feature-extraction"),
+            mars_target_modules_known=True,
+        ),
+        CandidateEntry(
+            model_id="Qwen/Qwen2-0.5B",
+            model_type="qwen2",
+            architectures=("Qwen2ForCausalLM",),
+            selected_task="text-generation-with-past",
+            supported_tasks=("text-generation", "text-generation-with-past"),
+            mars_target_modules_known=True,
+        ),
+        CandidateEntry(
+            model_id="sentence-transformers/all-MiniLM-L6-v2",
+            model_type="bert",
+            architectures=("BertModel",),
+            selected_task="feature-extraction",
+            supported_tasks=("feature-extraction",),
+            mars_target_modules_known=False,
+        ),
+    ]
+    for entry in rows:
+        entry.optimum_onnx_version = _TOOLCHAIN["optimumOnnxVersion"]
+        entry.transformers_version = _TOOLCHAIN["transformersVersion"]
+        evaluate_statuses(entry, probe=None)  # no device probe -> android/rag honestly false
+    return SupportMatrix(models=rows, generated_at=_GENERATED_AT, toolchain=dict(_TOOLCHAIN))
+
+
+def _docs_path() -> Path:
+    return Path(__file__).resolve().parents[2] / "docs" / "COMPATIBILITY_MATRIX.md"
+
+
+def main() -> None:
+    doc = _docs_path()
+    doc.parent.mkdir(parents=True, exist_ok=True)
+    doc.write_text(render_matrix_markdown(build_sample_matrix()), encoding="utf-8")
+    print(f"wrote {doc}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/fixtures/gen_legacy_symbol_golden.py b/tests/fixtures/gen_legacy_symbol_golden.py
new file mode 100644
index 0000000..56cddbb
--- /dev/null
+++ b/tests/fixtures/gen_legacy_symbol_golden.py
@@ -0,0 +1,62 @@
+"""ARCHIVAL — regenerated `tests/fixtures/legacy_symbol_golden.json` while the legacy roots existed.
+
+**This script can no longer run.** `LEGACY_ROOTS` names the seven repo-root packages S9 deleted, so
+`collect()` walks paths that are not there and would rewrite the golden to `{}` — silently destroying
+the evidence that the migration was symbol-preserving. It is kept as the record of HOW the golden was
+produced, not as a tool to re-run.
+
+The goldens it produced are still enforced, by `tests/unit/test_symbol_golden.py`, against the modules'
+CURRENT homes. The pure AST helpers those tests need moved to `tests/fixtures/symbol_tools.py`
+(2026-08-14) so the live code no longer lives inside a dead generator.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from tests.fixtures.symbol_tools import decorated_definitions, public_symbols
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+LEGACY_ROOTS = ("trainer", "artifact", "inference", "tools", "peft_models", "evaluation", "database")
+GOLDEN = REPO_ROOT / "tests" / "fixtures" / "legacy_symbol_golden.json"
+
+
+def collect() -> dict[str, list[str]]:
+    modules: dict[str, list[str]] = {}
+    for root in LEGACY_ROOTS:
+        for path in sorted((REPO_ROOT / root).rglob("*.py")):
+            rel = path.relative_to(REPO_ROOT)
+            dotted = str(rel.with_suffix("")).replace("/", ".").removesuffix(".__init__")
+            modules[dotted] = public_symbols(path)
+    return modules
+
+
+def collect_decorators() -> dict[str, dict[str, list[str]]]:
+    out: dict[str, dict[str, list[str]]] = {}
+    for root in LEGACY_ROOTS:
+        for path in sorted((REPO_ROOT / root).rglob("*.py")):
+            rel = path.relative_to(REPO_ROOT)
+            dotted = str(rel.with_suffix("")).replace("/", ".").removesuffix(".__init__")
+            found = decorated_definitions(path)
+            if found:
+                out[dotted] = found
+    return out
+
+
+DECORATOR_GOLDEN = REPO_ROOT / "tests" / "fixtures" / "legacy_decorator_golden.json"
+
+if __name__ == "__main__":  # pragma: no cover - see the module docstring; do NOT run this
+    raise SystemExit(
+        "refusing to run: the seven legacy roots this generator walks were deleted in S9, so "
+        "regenerating would overwrite the goldens with an empty document. See the docstring."
+    )
+    payload = collect()
+    GOLDEN.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    total = sum(len(v) for v in payload.values())
+    print(f"wrote {GOLDEN.relative_to(REPO_ROOT)}: {len(payload)} modules, {total} public symbols")
+
+    decorators = collect_decorators()
+    DECORATOR_GOLDEN.write_text(json.dumps(decorators, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    n = sum(len(v) for v in decorators.values())
+    print(f"wrote {DECORATOR_GOLDEN.relative_to(REPO_ROOT)}: {n} decorated definitions")
diff --git a/tests/fixtures/gen_merger_golden.py b/tests/fixtures/gen_merger_golden.py
new file mode 100644
index 0000000..be60d09
--- /dev/null
+++ b/tests/fixtures/gen_merger_golden.py
@@ -0,0 +1,70 @@
+"""Generate golden merger ONNX fixtures from the LEGACY ``artifact/merger.py`` ``*_2`` factories.
+
+These goldens pin ``build_merger_model`` (``config/registry/merger.py``, #9) to the exact graphs the
+legacy ``create_lora_merger_model_2`` / ``create_mars_merger_model_2`` emitted, for the full
+family × quant_in × quant_out cross-product. Committing them lets the equivalence test
+(``tests/unit/test_merger_builder.py``) run in the core env (onnx only) without importing the legacy
+module — which #9 deletes the factories from anyway.
+
+The legacy factory *bodies* use only onnx/numpy; the module's top-level ``import onnxruntime`` is
+unused by them, so we stub it to load the module in the core env.
+
+Regenerate with: ``python tests/fixtures/gen_merger_golden.py`` (core env, onnx only).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+GOLDEN_DIR = Path(__file__).parent / "merger_golden"
+LEGACY_MERGER = REPO_ROOT / "artifact" / "merger.py"
+
+#: (family, quant_in, quant_out) — matches the build_merger_model dispatch axes.
+CASES = [
+    ("lora", False, False),
+    ("lora", False, True),
+    ("lora", True, False),
+    ("lora", True, True),
+    ("mars", False, False),
+    ("mars", False, True),
+    ("mars", True, False),
+    ("mars", True, True),
+]
+
+
+def golden_name(family: str, quant_in: bool, quant_out: bool) -> str:
+    return f"{family}_{'qin' if quant_in else 'fpin'}_{'qout' if quant_out else 'fpout'}.onnx"
+
+
+def _load_legacy_merger() -> types.ModuleType:
+    """Load ``artifact/merger.py`` standalone, stubbing the unused onnxruntime import."""
+    sys.modules.setdefault("onnxruntime", types.ModuleType("onnxruntime"))
+    spec = importlib.util.spec_from_file_location("_legacy_merger", LEGACY_MERGER)
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def main() -> None:
+    GOLDEN_DIR.mkdir(exist_ok=True)
+    legacy = _load_legacy_merger()
+    for family, quant_in, quant_out in CASES:
+        out = GOLDEN_DIR / golden_name(family, quant_in, quant_out)
+        if family == "lora":
+            legacy.create_lora_merger_model_2(
+                str(out), quantized_inputs=quant_in, quantized_outputs=quant_out
+            )
+        else:
+            legacy.create_mars_merger_model_2(
+                str(out), quantized_inputs=quant_in, quantized_outputs=quant_out
+            )
+    print(f"wrote {len(CASES)} goldens to {GOLDEN_DIR}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/fixtures/legacy_decorator_golden.json b/tests/fixtures/legacy_decorator_golden.json
new file mode 100644
index 0000000..d9cd5e6
--- /dev/null
+++ b/tests/fixtures/legacy_decorator_golden.json
@@ -0,0 +1,48 @@
+{
+  "database.vector_entity": {
+    "VectorEntity1024": [
+      "Entity"
+    ],
+    "VectorEntity128": [
+      "Entity"
+    ],
+    "VectorEntity1536": [
+      "Entity"
+    ],
+    "VectorEntity256": [
+      "Entity"
+    ],
+    "VectorEntity384": [
+      "Entity"
+    ],
+    "VectorEntity512": [
+      "Entity"
+    ],
+    "VectorEntity64": [
+      "Entity"
+    ],
+    "VectorEntity768": [
+      "Entity"
+    ]
+  },
+  "inference.export_inference_package": {
+    "ExportedPackage": [
+      "dataclass"
+    ]
+  },
+  "peft_models.ablation.config": {
+    "AblationConfig": [
+      "dataclass"
+    ]
+  },
+  "peft_models.mars.config": {
+    "MarsConfig": [
+      "dataclass"
+    ]
+  },
+  "trainer.utils": {
+    "DataCollatorForSupervisedDataset": [
+      "dataclass"
+    ]
+  }
+}
diff --git a/tests/fixtures/legacy_symbol_golden.json b/tests/fixtures/legacy_symbol_golden.json
new file mode 100644
index 0000000..fa83e11
--- /dev/null
+++ b/tests/fixtures/legacy_symbol_golden.json
@@ -0,0 +1,383 @@
+{
+  "artifact": [],
+  "artifact.merger": [
+    "emit_merger_models"
+  ],
+  "artifact.onnx_builder": [
+    "CausalLMCE",
+    "convert_pipeline",
+    "force_dequantize_external_and_save",
+    "gen_artifacts",
+    "gen_genai",
+    "get_all_metadata_from_onnx",
+    "get_layers_with_grad",
+    "load_config_from_file",
+    "onnx_checktrain",
+    "onnx_export_dummy_model",
+    "onnx_infer",
+    "onnx_segment_weights",
+    "onnx_transfer_trained_weights",
+    "parse_arguments",
+    "parse_extra_options"
+  ],
+  "artifact.tflite_builder": [
+    "convert_gemma_hf",
+    "convert_llm_tflite",
+    "convert_tflite",
+    "gemma_decode",
+    "get_signatures_tflite",
+    "hf_token",
+    "kaggle_key",
+    "kaggle_username",
+    "pad_array",
+    "run_inference_keras_tflite",
+    "run_training_keras_lora",
+    "run_training_keras_tflite"
+  ],
+  "database.builder": [
+    "MobileTransformersObjectBoxProcessor",
+    "logger",
+    "main",
+    "process_documents_with_custom_entities",
+    "validate_and_prepare_schema"
+  ],
+  "database.json2entity": [
+    "create_filtered_json_model",
+    "extract_uids_for_kotlin",
+    "extract_uids_from_objectbox_json"
+  ],
+  "database.query": [
+    "ObjectBoxQueryEngine",
+    "VectorSearchResult",
+    "format_results",
+    "logger",
+    "main",
+    "save_results_json"
+  ],
+  "database.vector_entity": [
+    "VectorEntity1024",
+    "VectorEntity128",
+    "VectorEntity1536",
+    "VectorEntity256",
+    "VectorEntity384",
+    "VectorEntity512",
+    "VectorEntity64",
+    "VectorEntity768"
+  ],
+  "evaluation.benchmark.arc_eval": [
+    "MODEL_PATH",
+    "benchmark",
+    "custom_llm",
+    "results"
+  ],
+  "evaluation.benchmark.boolq_eval": [
+    "MODEL_PATH",
+    "benchmark",
+    "custom_llm",
+    "results"
+  ],
+  "evaluation.benchmark.hellaswag_eval": [
+    "MODEL_PATH",
+    "benchmark",
+    "custom_llm",
+    "results"
+  ],
+  "evaluation.benchmark.logiqa_eval": [
+    "MODEL_PATH",
+    "benchmark",
+    "custom_llm",
+    "results"
+  ],
+  "evaluation.benchmark.winogrande_eval": [
+    "MODEL_PATH",
+    "benchmark",
+    "custom_llm",
+    "results"
+  ],
+  "evaluation.eval_adapter_models": [
+    "CustomPeftModel",
+    "add_peft_type"
+  ],
+  "evaluation.eval_adapter_onnx_model": [
+    "CustomPeftONNXModel"
+  ],
+  "evaluation.mobile.base_mobile_eval": [
+    "MINI_PERSONAL_QA_EXAMPLES",
+    "MINI_RECOMMENDATION_EXAMPLES",
+    "evaluate_base_mini_personalqa",
+    "evaluate_base_mini_recommendation"
+  ],
+  "evaluation.mobile.mobile_eval": [
+    "evaluate_finetuned",
+    "evaluate_onnx_mini_personalqa",
+    "evaluate_onnx_mini_recommendation"
+  ],
+  "evaluation.mobile.recommendation_eval": [
+    "AzureOpenAIModel",
+    "RecommendationEvaluator",
+    "main"
+  ],
+  "evaluation.mobile_evaluator": [
+    "MobileEvaluator"
+  ],
+  "evaluation.openehr.openehr_eval": [
+    "CHUNK_DATABASE_DIR",
+    "DOCUMENT_DATABASE_DIR",
+    "EMBEDDING_MODEL_ID",
+    "GEMINI_API_KEY",
+    "MAX_RESPONSE_LENGTH",
+    "MEDICAL_ASSISTANT_TEMPLATE",
+    "SLM_TO_TEST",
+    "TEST_DATA_TYPE",
+    "all_responses",
+    "all_test_cases",
+    "chunk_db",
+    "clinical_quality_metric",
+    "doc_chunk_llm",
+    "doc_chunk_slm",
+    "document_db",
+    "evaluation_results",
+    "export_data",
+    "faithfulness_metric",
+    "format_medical_prompt",
+    "llm_evaluator",
+    "llm_generator",
+    "llm_test_data",
+    "output_filename",
+    "slm_generator",
+    "slm_llm_chunk",
+    "slm_llm_doc"
+  ],
+  "evaluation.openehr.openehr_eval_plots": [
+    "create_scatter_plot",
+    "load_evaluation_data",
+    "main",
+    "model_json_pairs",
+    "plot_evaluation_results"
+  ],
+  "evaluation.test.test_eval_onnx": [
+    "MERGED_WEIGHTS_DIR",
+    "SLM_MODEL_DIR",
+    "SLM_MODEL_ID",
+    "SLM_MODEL_NAME",
+    "benchmark",
+    "results",
+    "slm_generator"
+  ],
+  "evaluation.test.test_gen": [
+    "MERGED_WEIGHTS_DIR",
+    "SLM_MODEL_DIR",
+    "SLM_MODEL_ID",
+    "SLM_MODEL_NAME",
+    "g",
+    "q",
+    "slm_generator",
+    "test_arc"
+  ],
+  "evaluation.test.test_gen_viz": [
+    "ADAPTER_NAME",
+    "ADAPTER_PATH",
+    "BASE_MODEL",
+    "generator",
+    "q",
+    "results",
+    "test_arc"
+  ],
+  "inference": [],
+  "inference.builder": [
+    "ChatGLMModel",
+    "Gemma2Model",
+    "GemmaModel",
+    "INFERENCE_CONFIG",
+    "LlamaModel",
+    "MistralModel",
+    "Model",
+    "NemotronModel",
+    "Phi3Mini128KModel",
+    "Phi3Mini4KModel",
+    "Phi3MoE128KModel",
+    "Phi3Small128KModel",
+    "Phi3Small8KModel",
+    "Phi3VModel",
+    "PhiModel",
+    "QwenModel",
+    "TRAIN_CONFIG",
+    "check_extra_options",
+    "create_model",
+    "get_args",
+    "load_config_from_file",
+    "parse_extra_options",
+    "parse_hf_token"
+  ],
+  "inference.export_inference_package": [
+    "EXTERNAL_INITIALIZERS_FOLDER_KEY",
+    "ExportedPackage",
+    "FROZEN_BASE_BLOB",
+    "GENAI_CONFIG_FILENAME",
+    "HANDOFF_MAP_FILENAME",
+    "MODEL_FILENAME",
+    "export_inference_package",
+    "logger"
+  ],
+  "inference.generator": [
+    "generate_tokens_onnx"
+  ],
+  "inference.generator_genai": [
+    "test_genai_model",
+    "test_genai_model_with_inputs"
+  ],
+  "inference.validator": [
+    "MobileTransformerGenerator",
+    "load_config_from_file",
+    "parse_arguments",
+    "parse_extra_options",
+    "validate_generation"
+  ],
+  "peft_models": [],
+  "peft_models.ablation.config": [
+    "AblationConfig",
+    "AblationVariant"
+  ],
+  "peft_models.ablation.layer": [
+    "AblationLayer",
+    "Linear",
+    "ManualQuantizedLinear"
+  ],
+  "peft_models.ablation.model": [
+    "AblationModel"
+  ],
+  "peft_models.ablation.utils": [
+    "TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING"
+  ],
+  "peft_models.lora_xs": [],
+  "peft_models.lora_xs.initialization_utils": [
+    "find_and_initialize",
+    "get_replacement_module",
+    "init_module_weights",
+    "kaiming_uniform_init",
+    "kaiming_uniform_init_lower_half",
+    "replace_module_weights",
+    "update_decoder_weights"
+  ],
+  "peft_models.lora_xs.latent_utils": [
+    "forward_latent",
+    "get_delta_weight",
+    "transpose"
+  ],
+  "peft_models.lora_xs.merger": [
+    "load_and_merge_lora_model",
+    "main"
+  ],
+  "peft_models.lora_xs.svd_utils": [
+    "get_linear_rec_svd",
+    "run_svd"
+  ],
+  "peft_models.mars.config": [
+    "MarsConfig"
+  ],
+  "peft_models.mars.layer": [
+    "Linear",
+    "MarsLayer",
+    "QuantizedBaseLayer",
+    "SharedAttentionAdapter",
+    "SharedMLPAdapter"
+  ],
+  "peft_models.mars.model": [
+    "MarsModel"
+  ],
+  "peft_models.mars.study": [
+    "factorize",
+    "find_best_shape",
+    "reshape_to_higher_order",
+    "sequential_svd",
+    "tensor_train_contract",
+    "tensor_train_decomposition",
+    "tt_tensor_elements"
+  ],
+  "peft_models.mars.utils": [
+    "TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING"
+  ],
+  "tools": [],
+  "tools.parser_config": [],
+  "tools.tokenizer_export": [
+    "export_tokenizer_config",
+    "export_tokenizer_config_advanced"
+  ],
+  "tools.utils": [
+    "MemoryLoggerCallback",
+    "create_chat_input",
+    "delete_directory",
+    "load_and_save_dataset",
+    "move_files_excluding",
+    "move_onnx_model",
+    "preload_dataset",
+    "render_template",
+    "save_as_jsonl",
+    "trim_dataset"
+  ],
+  "trainer": [],
+  "trainer.builder": [
+    "OnnxInferenceWrapper",
+    "OnnxTrainerWrapper",
+    "add_peft_type",
+    "apply_metadata",
+    "check_extra_options",
+    "compare_weights",
+    "count_trainable_parameters",
+    "ensure_training_mode_input",
+    "get_layers_with_grad",
+    "inspect_weights",
+    "load_config_from_file",
+    "onnx_dynamic_quantization",
+    "optimum_hf_export",
+    "parse_argument_list",
+    "parse_arguments",
+    "parse_extra_options",
+    "preprocess_model",
+    "trim_initializers"
+  ],
+  "trainer.embedding_builder": [
+    "add_cls_pooling",
+    "add_concatenation",
+    "add_max_pooling",
+    "add_mean_pooling",
+    "add_mean_sqrt_len_pooling",
+    "add_pooling_operations",
+    "add_pooling_to_onnx_model",
+    "load_pooling_config_from_hub",
+    "print_pooling_summary"
+  ],
+  "trainer.merge_validator": [
+    "PEFTMergeValidator",
+    "create_peft_merge_validator",
+    "load_config_from_file",
+    "parse_arguments",
+    "parse_extra_options"
+  ],
+  "trainer.utils": [
+    "DataCollatorForSupervisedDataset",
+    "create_lora_mapping",
+    "create_mars_adapter_mapping",
+    "process_sample_alpaca",
+    "process_sample_arc_deepeval",
+    "process_sample_boolq_deepeval",
+    "process_sample_dolly",
+    "process_sample_hellaswag",
+    "process_sample_hellaswag_deepeval",
+    "process_sample_logiqa_deepeval",
+    "process_sample_minipersonalqa",
+    "process_sample_minirecommendation",
+    "process_sample_winogrande_deepeval",
+    "taskname_to_deepeval_preprocess_function"
+  ],
+  "trainer.validator": [
+    "CosineLRScheduler",
+    "ORTDataCurator",
+    "ORTTrainer",
+    "ORTTrainingArguments",
+    "check_duplicate_initializers",
+    "load_config_from_file",
+    "parse_arguments",
+    "parse_extra_options"
+  ]
+}
diff --git a/tests/fixtures/make_tiny_package.py b/tests/fixtures/make_tiny_package.py
new file mode 100644
index 0000000..fa331d2
--- /dev/null
+++ b/tests/fixtures/make_tiny_package.py
@@ -0,0 +1,158 @@
+"""Generate the shared tiny MobileTransformers Hub package fixture (#14) at ``tests/fixtures/tiny_package``.
+
+A minimal but *structurally complete* two-variant package: ``cpu-int4`` (native+genai, all features) and
+``cpu-fp16`` (native-only, no rag/genai). Placeholder ONNX/blob files are tiny; the real bits are the
+directory shape, a valid tiny ``weight_handoff_map.json`` per variant (so #13's resolvability check
+passes), and a consistent generated ``mobiletransformers_manifest.json`` + per-variant ``checksums.json``.
+
+Shared by #14 (`build_manifest` round-trip), #13 (validator), and #21 (pull smoke). Regenerate with:
+``python tests/fixtures/make_tiny_package.py`` (core env, onnx not required — pure files).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mobiletransformers.artifacts.handoff_map import HandoffEntry, HandoffMap
+from mobiletransformers.hub.package_format import (
+    build_manifest,
+    write_manifest,
+    write_variant_checksums,
+)
+
+FIXTURE_DIR = Path(__file__).parent / "tiny_package"
+TRAINABLE = "model.layers.0.attn.q_proj.MatMul.weight"
+
+_REPORT = {
+    "mobiletransformersVersion": "0.2.0",
+    "architectures": ["LlamaForCausalLM"],
+    "supportedTasks": ["text-generation", "text-generation-with-past"],
+    "selectedTask": "text-generation-with-past",
+    "trustRemoteCode": False,
+    "optimumOnnxVersion": "0.1.0",
+    "transformersVersion": "4.46.2",
+    "onnxRuntimeTrainingVersion": "1.23.0",
+    "onnxRuntimeGenAIVersion": "0.14.0",
+    "peftMethods": ["lora"],
+    "quantization": ["int4", "fp16"],
+    "androidRuntime": {
+        "minimumAndroidApi": 28,
+        "recommendedDeviceMemoryMb": 3072,
+        "requiredAbis": ["arm64-v8a"],
+    },
+    "license": {
+        "framework": "Apache-2.0",
+        "baseModelWeights": "Apache-2.0",
+        "noticeFile": "licenses/BASE_MODEL_LICENSE",
+    },
+}
+
+_VARIANTS = [
+    {
+        "id": "cpu-int4",
+        "executionProvider": "cpu",
+        "quantization": "int4",
+        "supportedEngines": ["native", "genai"],
+        "abi": ["arm64-v8a"],
+        "features": ["core", "inference", "train", "rag", "genai"],
+        "minimumAndroidApi": 28,
+        "recommendedDeviceMemoryMb": 3072,
+    },
+    {
+        "id": "cpu-fp16",
+        "executionProvider": "cpu",
+        "quantization": "fp16",
+        "supportedEngines": ["native"],
+        "abi": None,
+        "features": ["core", "inference", "train"],
+        "minimumAndroidApi": 28,
+        "recommendedDeviceMemoryMb": 6144,
+    },
+]
+
+
+def _w(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+
+
+def _tiny_handoff() -> str:
+    entry = HandoffEntry(
+        training_base_layer_name="backbone.model.layers.0.self_attn.q_proj.base_layer",
+        dtype="float32",
+        shape=(4, 3),
+        checkpoint_names={"weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"},
+        merger_output_names={"weight": "merged_weight"},
+        merged_tensor_names={"weight": TRAINABLE},
+        inference_initializer_names={"weight": TRAINABLE},
+        external_data_location={"weight": f"{TRAINABLE}.bin"},
+    )
+    return HandoffMap(entries=[entry]).to_json()
+
+
+def _write_variant_tree(root: Path, variant: dict, *, with_genai: bool, with_rag: bool) -> None:
+    vid = variant["id"]
+    inf = root / "variants" / vid / "inference"
+    _w(inf / "model.onnx", "ONNX_PLACEHOLDER\n")
+    _w(inf / "frozen_base.onnx.data", "FROZEN_BASE_PLACEHOLDER\n")
+    _w(inf / f"{TRAINABLE}.bin", "TRAINABLE_TENSOR_BYTES\n")
+    _w(inf / f"{TRAINABLE}.bin.sha256", "0" * 64 + "\n")
+    _w(inf / "weight_handoff_map.json", _tiny_handoff())
+    _w(inf / "generation_config.json", json.dumps({"type": "native"}, indent=2) + "\n")
+    if with_genai:
+        _w(inf / "genai_config.json", json.dumps({"model": {"type": "llama"}}, indent=2) + "\n")
+
+    train = root / "variants" / vid / "train"
+    _w(train / "training_config.json", json.dumps({"peftMethod": "lora", "rank": 8}, indent=2) + "\n")
+    _w(train / "weight_handoff_map.json", _tiny_handoff())
+
+    if with_rag:
+        emb = root / "variants" / vid / "embedding"
+        _w(emb / "embedding_model.onnx", "EMBED_ONNX_PLACEHOLDER\n")
+        _w(emb / "rag_config.json", json.dumps({"embeddingDimension": 384}, indent=2) + "\n")
+
+
+def main() -> None:
+    root = FIXTURE_DIR
+    # shared/
+    _w(root / "shared" / "tokenizer" / "tokenizer.json", json.dumps({"version": "1.0"}) + "\n")
+    _w(root / "shared" / "chat_template.jinja", "{{ messages }}\n")
+    _w(root / "shared" / "config.json", json.dumps({"model_type": "llama"}, indent=2) + "\n")
+    _w(root / "shared" / "generation_config.json", json.dumps({"eos_token_id": 2}, indent=2) + "\n")
+    # optimum/
+    _w(root / "optimum" / "export_report.json", json.dumps({"selectedTask": _REPORT["selectedTask"]}) + "\n")
+    _w(root / "optimum" / "supported_tasks.json", json.dumps(_REPORT["supportedTasks"]) + "\n")
+    _w(root / "optimum" / "optimum_config.json", json.dumps({"opset": 20}) + "\n")
+    # licenses/ + README
+    _w(root / "licenses" / "BASE_MODEL_LICENSE", "Apache-2.0\n")
+    _w(root / "licenses" / "FRAMEWORK_LICENSE", "Apache-2.0\n")
+    _w(root / "README.md", "# Tiny MobileTransformers package fixture\n")
+    # variants/
+    _write_variant_tree(root, _VARIANTS[0], with_genai=True, with_rag=True)
+    _write_variant_tree(root, _VARIANTS[1], with_genai=False, with_rag=False)
+
+    manifest = build_manifest(
+        root,
+        _VARIANTS,
+        base_model_id="MobileTransformers/Tiny-0.1B",
+        report=_REPORT,
+        default_variant="cpu-int4",
+        exported_at="2026-07-14T00:00:00Z",
+    )
+    write_variant_checksums(root, manifest)
+    # Recompute so the manifest's sha256/fileSizes include the just-written checksums.json files.
+    manifest = build_manifest(
+        root,
+        _VARIANTS,
+        base_model_id="MobileTransformers/Tiny-0.1B",
+        report=_REPORT,
+        default_variant="cpu-int4",
+        exported_at="2026-07-14T00:00:00Z",
+    )
+    write_manifest(root, manifest)
+    print(f"wrote tiny package fixture to {root} ({len(manifest['sha256'])} files hashed)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/fixtures/make_tiny_trainable.py b/tests/fixtures/make_tiny_trainable.py
new file mode 100644
index 0000000..b9bac19
--- /dev/null
+++ b/tests/fixtures/make_tiny_trainable.py
@@ -0,0 +1,76 @@
+"""Generate the tiny trainable ONNX fixture + training_config.json for the ORT-training smoke.
+
+The fixture mirrors the shape `artifact/onnx_builder.py::gen_artifacts` expects: an ONNX graph with
+at least one trainable initializer and a scalar output that IS the loss (generate_artifacts is called
+with ``loss=None``), plus a ``training_config.json`` carrying the exact fields the builder reads
+(``requires_grad``, ``peft_mapping``, ``rank``, ``alpha``, ``peft_target``,
+``trainable_parameter_count``).
+
+Regenerate with: ``python tests/fixtures/make_tiny_trainable.py``. Uses only onnx (a core dep), so it
+runs in any environment — no onnxruntime-training needed to BUILD the fixture (only to consume it).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import onnx
+from onnx import TensorProto, helper, numpy_helper
+
+FIXTURE_DIR = Path(__file__).parent
+MODEL_PATH = FIXTURE_DIR / "tiny_trainable.onnx"
+CONFIG_PATH = FIXTURE_DIR / "training_config.json"
+
+# Trainable-parameter name substrings (gen_artifacts matches initializer names against these).
+REQUIRES_GRAD_SUBSTRINGS = ["weight"]
+
+
+def build_model() -> onnx.ModelProto:
+    # x: [batch, 4] float32 (dynamic batch); loss: scalar float32.
+    x = helper.make_tensor_value_info("input", TensorProto.FLOAT, ["batch", 4])
+    loss = helper.make_tensor_value_info("loss", TensorProto.FLOAT, [])
+
+    rng = np.random.default_rng(0)
+    weight = numpy_helper.from_array(rng.standard_normal((4, 1)).astype(np.float32), name="linear.weight")
+    bias = numpy_helper.from_array(np.zeros((1,), dtype=np.float32), name="linear.bias")  # frozen
+
+    matmul = helper.make_node("MatMul", ["input", "linear.weight"], ["mm"])
+    add = helper.make_node("Add", ["mm", "linear.bias"], ["logits"])
+    # ReduceMean over all axes, keepdims=0 -> scalar loss (opset-17 style: axes as attribute).
+    reduce_mean = helper.make_node("ReduceMean", ["logits"], ["loss"], keepdims=0)
+
+    graph = helper.make_graph(
+        [matmul, add, reduce_mean],
+        "tiny_trainable",
+        [x],
+        [loss],
+        initializer=[weight, bias],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)])
+    model.ir_version = 10  # onnxruntime-training 1.23 rejects newer IR versions
+    onnx.checker.check_model(model, full_check=True)
+    return model
+
+
+def build_config() -> dict:
+    return {
+        "requires_grad": REQUIRES_GRAD_SUBSTRINGS,
+        "peft_mapping": {"linear.weight": "linear.weight"},
+        "rank": 8,
+        "alpha": 16,
+        "peft_target": ["linear"],
+        "trainable_parameter_count": 4,
+    }
+
+
+def main() -> None:
+    onnx.save(build_model(), MODEL_PATH)
+    CONFIG_PATH.write_text(json.dumps(build_config(), indent=2) + "\n", encoding="utf-8")
+    size_kb = MODEL_PATH.stat().st_size / 1024
+    print(f"wrote {MODEL_PATH} ({size_kb:.1f} KiB) and {CONFIG_PATH}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/fixtures/merger_golden/lora_fpin_fpout.onnx b/tests/fixtures/merger_golden/lora_fpin_fpout.onnx
new file mode 100644
index 0000000..2346df6
Binary files /dev/null and b/tests/fixtures/merger_golden/lora_fpin_fpout.onnx differ
diff --git a/tests/fixtures/merger_golden/lora_fpin_qout.onnx b/tests/fixtures/merger_golden/lora_fpin_qout.onnx
new file mode 100644
index 0000000..20c00ae
Binary files /dev/null and b/tests/fixtures/merger_golden/lora_fpin_qout.onnx differ
diff --git a/tests/fixtures/merger_golden/lora_qin_fpout.onnx b/tests/fixtures/merger_golden/lora_qin_fpout.onnx
new file mode 100644
index 0000000..618dce5
Binary files /dev/null and b/tests/fixtures/merger_golden/lora_qin_fpout.onnx differ
diff --git a/tests/fixtures/merger_golden/lora_qin_qout.onnx b/tests/fixtures/merger_golden/lora_qin_qout.onnx
new file mode 100644
index 0000000..20fcd67
Binary files /dev/null and b/tests/fixtures/merger_golden/lora_qin_qout.onnx differ
diff --git a/tests/fixtures/merger_golden/mars_fpin_fpout.onnx b/tests/fixtures/merger_golden/mars_fpin_fpout.onnx
new file mode 100644
index 0000000..3295396
Binary files /dev/null and b/tests/fixtures/merger_golden/mars_fpin_fpout.onnx differ
diff --git a/tests/fixtures/merger_golden/mars_fpin_qout.onnx b/tests/fixtures/merger_golden/mars_fpin_qout.onnx
new file mode 100644
index 0000000..0dbdb3e
Binary files /dev/null and b/tests/fixtures/merger_golden/mars_fpin_qout.onnx differ
diff --git a/tests/fixtures/merger_golden/mars_qin_fpout.onnx b/tests/fixtures/merger_golden/mars_qin_fpout.onnx
new file mode 100644
index 0000000..a652ff2
Binary files /dev/null and b/tests/fixtures/merger_golden/mars_qin_fpout.onnx differ
diff --git a/tests/fixtures/merger_golden/mars_qin_qout.onnx b/tests/fixtures/merger_golden/mars_qin_qout.onnx
new file mode 100644
index 0000000..079c393
Binary files /dev/null and b/tests/fixtures/merger_golden/mars_qin_qout.onnx differ
diff --git a/tests/fixtures/sanitize_repo_id_cases.json b/tests/fixtures/sanitize_repo_id_cases.json
new file mode 100644
index 0000000..1ca2e27
--- /dev/null
+++ b/tests/fixtures/sanitize_repo_id_cases.json
@@ -0,0 +1,15 @@
+{
+  "_comment": "Cross-language parity oracle for sanitize_repo_id (#14). Python and Kotlin must agree byte-for-byte. Rules: '/'->'__'; other non [A-Za-z0-9._-] -> single '_'; no trim/case-fold/length-cap.",
+  "cases": [
+    { "input": "mobiletransformers/Qwen2-0.5B", "expected": "mobiletransformers__Qwen2-0.5B" },
+    { "input": "org/sub/model", "expected": "org__sub__model" },
+    { "input": "TinyLlama/TinyLlama-1.1B-Chat-v1.0", "expected": "TinyLlama__TinyLlama-1.1B-Chat-v1.0" },
+    { "input": "with space", "expected": "with_space" },
+    { "input": "model@v1", "expected": "model_v1" },
+    { "input": "with:colon", "expected": "with_colon" },
+    { "input": "..leadingdots", "expected": "..leadingdots" },
+    { "input": "UPPER/Lower", "expected": "UPPER__Lower" },
+    { "input": "café/model", "expected": "caf___model" },
+    { "input": "a/b\\c", "expected": "a__b_c" }
+  ]
+}
diff --git a/tests/fixtures/symbol_tools.py b/tests/fixtures/symbol_tools.py
new file mode 100644
index 0000000..6da36a6
--- /dev/null
+++ b/tests/fixtures/symbol_tools.py
@@ -0,0 +1,84 @@
+"""Pure AST helpers for the symbol/decorator goldens.
+
+Lifted out of `gen_legacy_symbol_golden.py` on 2026-08-14. That generator can no longer run — the seven
+legacy roots it walks were deleted in S9 — but these two functions are still imported by
+`tests/unit/test_symbol_golden.py` and `tests/unit/test_import_weight.py`, which compare the frozen
+goldens against the modules' CURRENT homes. Keeping live helpers inside a dead generator was the kind
+of "load-bearing by accident" arrangement this repo has been paying for elsewhere.
+
+Nothing here touches the legacy roots; both functions take a path and parse it.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+def decorated_definitions(path: Path) -> dict[str, list[str]]:
+    """Top-level defs/classes -> their decorator names.
+
+    A move that drops a DECORATOR changes behaviour while preserving every symbol name, so the symbol
+    golden alone cannot see it. This is not hypothetical: slicing ``trainer/utils.py`` by line during
+    S4 started the slice at `class DataCollatorForSupervisedDataset` and silently left `@dataclass`
+    behind, removing the generated ``__init__``.
+    """
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    out: dict[str, list[str]] = {}
+    for node in tree.body:
+        if not isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            continue
+        names = []
+        for dec in node.decorator_list:
+            target = dec.func if isinstance(dec, ast.Call) else dec
+            if isinstance(target, ast.Name):
+                names.append(target.id)
+            elif isinstance(target, ast.Attribute):
+                names.append(target.attr)
+        if names:
+            out[node.name] = sorted(names)
+    return out
+
+
+def public_symbols(path: Path) -> list[str]:
+    """The module's public surface.
+
+    ``__all__`` when the module declares one — that is Python's own answer, and it is what makes a
+    deprecation shim comparable to the module it replaces: the shim *imports* the names rather than
+    defining them, so a defs-only walk would report every symbol as dropped.
+
+    Otherwise: top-level defs/classes/assigned names **and module-level import bindings**, excluding
+    ``_``-prefixed ones. Imports count because they genuinely are attributes of the module — a
+    de-duplication that replaces a private copy of a helper with ``from ...utils.yaml import
+    load_config_from_file`` keeps the name importable from exactly where it was, and a defs-only walk
+    would report that as a lost public symbol (it did, for five modules, on 2026-08-14).
+    """
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+
+    for node in tree.body:
+        if isinstance(node, ast.Assign) and any(
+            isinstance(t, ast.Name) and t.id == "__all__" for t in node.targets
+        ):
+            if isinstance(node.value, ast.List | ast.Tuple):
+                declared = [
+                    e.value
+                    for e in node.value.elts
+                    if isinstance(e, ast.Constant) and isinstance(e.value, str)
+                ]
+                return sorted(set(declared))
+
+    names: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            names.add(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    names.add(target.id)
+        elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            names.add(node.target.id)
+        elif isinstance(node, ast.Import | ast.ImportFrom):
+            for alias in node.names:
+                if alias.name != "*":
+                    names.add(alias.asname or alias.name.split(".", 1)[0])
+    return sorted(n for n in names if not n.startswith("_"))
diff --git a/tests/fixtures/test_tiny_trainable.py b/tests/fixtures/test_tiny_trainable.py
new file mode 100644
index 0000000..05c2ed1
--- /dev/null
+++ b/tests/fixtures/test_tiny_trainable.py
@@ -0,0 +1,42 @@
+"""Fixture well-formedness (onnx-only; runs in the core env — no onnxruntime-training needed)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import onnx
+
+FIXTURE_DIR = Path(__file__).parent
+MODEL_PATH = FIXTURE_DIR / "tiny_trainable.onnx"
+CONFIG_PATH = FIXTURE_DIR / "training_config.json"
+
+
+def test_model_is_valid_and_tiny():
+    assert MODEL_PATH.exists()
+    assert MODEL_PATH.stat().st_size < 1_000_000  # sub-MB so CI stays fast
+    onnx.checker.check_model(str(MODEL_PATH), full_check=True)
+
+
+def test_has_trainable_initializer():
+    model = onnx.load(str(MODEL_PATH))
+    config = json.loads(CONFIG_PATH.read_text())
+    names = [init.name for init in model.graph.initializer]
+    # At least one initializer matches a requires_grad substring (the trainable split gen_artifacts does).
+    trainable = [n for n in names if any(sub in n for sub in config["requires_grad"])]
+    assert trainable, f"no trainable initializer among {names}"
+
+
+def test_config_has_gen_artifacts_fields():
+    config = json.loads(CONFIG_PATH.read_text())
+    # Exact fields artifact/onnx_builder.py::gen_artifacts reads.
+    for field in (
+        "requires_grad",
+        "peft_mapping",
+        "rank",
+        "alpha",
+        "peft_target",
+        "trainable_parameter_count",
+    ):
+        assert field in config, f"training_config.json missing {field}"
+    assert isinstance(config["requires_grad"], list) and config["requires_grad"]
diff --git a/tests/fixtures/tiny_package/README.md b/tests/fixtures/tiny_package/README.md
new file mode 100644
index 0000000..56e52a0
--- /dev/null
+++ b/tests/fixtures/tiny_package/README.md
@@ -0,0 +1 @@
+# Tiny MobileTransformers package fixture
diff --git a/tests/fixtures/tiny_package/licenses/BASE_MODEL_LICENSE b/tests/fixtures/tiny_package/licenses/BASE_MODEL_LICENSE
new file mode 100644
index 0000000..622901a
--- /dev/null
+++ b/tests/fixtures/tiny_package/licenses/BASE_MODEL_LICENSE
@@ -0,0 +1 @@
+Apache-2.0
diff --git a/tests/fixtures/tiny_package/licenses/FRAMEWORK_LICENSE b/tests/fixtures/tiny_package/licenses/FRAMEWORK_LICENSE
new file mode 100644
index 0000000..622901a
--- /dev/null
+++ b/tests/fixtures/tiny_package/licenses/FRAMEWORK_LICENSE
@@ -0,0 +1 @@
+Apache-2.0
diff --git a/tests/fixtures/tiny_package/mobiletransformers_manifest.json b/tests/fixtures/tiny_package/mobiletransformers_manifest.json
new file mode 100644
index 0000000..06ca9b6
--- /dev/null
+++ b/tests/fixtures/tiny_package/mobiletransformers_manifest.json
@@ -0,0 +1,211 @@
+{
+  "androidRuntime": {
+    "minimumAndroidApi": 28,
+    "recommendedDeviceMemoryMb": 3072,
+    "requiredAbis": [
+      "arm64-v8a"
+    ]
+  },
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "artifactFormatVersion": 1,
+  "baseModelId": "MobileTransformers/Tiny-0.1B",
+  "defaultVariant": "cpu-int4",
+  "downloadPlan": {
+    "cpu-fp16": {
+      "checksums": [
+        "variants/cpu-fp16/checksums.json"
+      ],
+      "core": [
+        "mobiletransformers_manifest.json",
+        "shared/tokenizer/**",
+        "shared/chat_template.jinja",
+        "shared/config.json",
+        "shared/generation_config.json"
+      ],
+      "genai": [],
+      "inference": [
+        "variants/cpu-fp16/inference/**"
+      ],
+      "rag": [],
+      "train": [
+        "variants/cpu-fp16/train/**"
+      ]
+    },
+    "cpu-int4": {
+      "checksums": [
+        "variants/cpu-int4/checksums.json"
+      ],
+      "core": [
+        "mobiletransformers_manifest.json",
+        "shared/tokenizer/**",
+        "shared/chat_template.jinja",
+        "shared/config.json",
+        "shared/generation_config.json"
+      ],
+      "genai": [
+        "variants/cpu-int4/inference/genai_config.json"
+      ],
+      "inference": [
+        "variants/cpu-int4/inference/**"
+      ],
+      "rag": [
+        "variants/cpu-int4/embedding/**"
+      ],
+      "train": [
+        "variants/cpu-int4/train/**"
+      ]
+    }
+  },
+  "exportedAt": "2026-07-14T00:00:00Z",
+  "fileSizes": {
+    "README.md": 42,
+    "licenses/BASE_MODEL_LICENSE": 11,
+    "licenses/FRAMEWORK_LICENSE": 11,
+    "optimum/export_report.json": 46,
+    "optimum/optimum_config.json": 14,
+    "optimum/supported_tasks.json": 49,
+    "shared/chat_template.jinja": 15,
+    "shared/config.json": 28,
+    "shared/generation_config.json": 24,
+    "shared/tokenizer/tokenizer.json": 19,
+    "variants/cpu-fp16/checksums.json": 1025,
+    "variants/cpu-fp16/inference/frozen_base.onnx.data": 24,
+    "variants/cpu-fp16/inference/generation_config.json": 23,
+    "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": 23,
+    "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": 65,
+    "variants/cpu-fp16/inference/model.onnx": 17,
+    "variants/cpu-fp16/inference/weight_handoff_map.json": 1038,
+    "variants/cpu-fp16/train/training_config.json": 40,
+    "variants/cpu-fp16/train/weight_handoff_map.json": 1038,
+    "variants/cpu-int4/checksums.json": 1383,
+    "variants/cpu-int4/embedding/embedding_model.onnx": 23,
+    "variants/cpu-int4/embedding/rag_config.json": 32,
+    "variants/cpu-int4/inference/frozen_base.onnx.data": 24,
+    "variants/cpu-int4/inference/genai_config.json": 41,
+    "variants/cpu-int4/inference/generation_config.json": 23,
+    "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": 23,
+    "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": 65,
+    "variants/cpu-int4/inference/model.onnx": 17,
+    "variants/cpu-int4/inference/weight_handoff_map.json": 1038,
+    "variants/cpu-int4/train/training_config.json": 40,
+    "variants/cpu-int4/train/weight_handoff_map.json": 1038
+  },
+  "license": {
+    "baseModelWeights": "Apache-2.0",
+    "framework": "Apache-2.0",
+    "noticeFile": "licenses/BASE_MODEL_LICENSE"
+  },
+  "minReaderVersion": "1.0",
+  "mobiletransformersVersion": "0.2.0",
+  "onnxRuntimeGenAIVersion": "0.14.0",
+  "onnxRuntimeTrainingVersion": "1.23.0",
+  "optimumOnnxVersion": "0.1.0",
+  "peftMethods": [
+    "lora"
+  ],
+  "quantization": [
+    "int4",
+    "fp16"
+  ],
+  "requiredFiles": [
+    "mobiletransformers_manifest.json",
+    "shared/tokenizer/tokenizer.json",
+    "variants/cpu-int4/inference/model.onnx"
+  ],
+  "schemaVersion": "1.0",
+  "selectedTask": "text-generation-with-past",
+  "sha256": {
+    "README.md": "51aba426dcfe1a3e908b8742381ba6cd976f7082ab60c31dc2f0e9c97055ae65",
+    "licenses/BASE_MODEL_LICENSE": "31d33b6815f84ee57fd784c7a88333a776bd3df1532d650bfdad7305d9efbf35",
+    "licenses/FRAMEWORK_LICENSE": "31d33b6815f84ee57fd784c7a88333a776bd3df1532d650bfdad7305d9efbf35",
+    "optimum/export_report.json": "1ba45986e4bf74432bb87710d3918c9cb95a53a476e9d673656b81ecdcb9ed9c",
+    "optimum/optimum_config.json": "0fd5383b862cc607421383946b9e9a93c428bf0560fc0e9573a63d455a761a07",
+    "optimum/supported_tasks.json": "53890b58122830323c1e4f6663601cb9923d62b068e97dcc896020912ba26caa",
+    "shared/chat_template.jinja": "7f3de14b4a359865a98f84be7a9314754b7e14e8e23524e2553e4effaa9d18e1",
+    "shared/config.json": "779942ebb16708036af3626823520ad296c3b78c42d5a1dababbdfc2dc496a09",
+    "shared/generation_config.json": "e06158a364deea17a6e26014b87b9048179dd5990f6371889cee4ad7e042de1a",
+    "shared/tokenizer/tokenizer.json": "e0e77b70ca77d0be8f321590c0deb449d364cc3c4edaeaa6eef40636d56a298e",
+    "variants/cpu-fp16/checksums.json": "ddfb6aab04f028f8ccd8d0bf4952cda5c3bf02c76acfcab1bf20adf008d38dad",
+    "variants/cpu-fp16/inference/frozen_base.onnx.data": "3b9d3e0ca40fedc16823b2a0d15ebb760aa9b1c2f68ce2fe229688cf36a4b42d",
+    "variants/cpu-fp16/inference/generation_config.json": "1d985e40e0f3c082e41afef928f2c2d2362acae574b1b0e5550de0d51edef52f",
+    "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": "b39a7c6175b60a789569dd83dafebc0ef35cd78d53f955bdcd05fd8142895da3",
+    "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": "827d096d92f3deeaa0e8070d79f45beb176768e57a958a1cd325f5f4b754b048",
+    "variants/cpu-fp16/inference/model.onnx": "f41027621d842764ef7f3b12331cec51ede487a823c41b445cc84d1414030147",
+    "variants/cpu-fp16/inference/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452",
+    "variants/cpu-fp16/train/training_config.json": "b19bcfdda05b80cca28138805de0fd2480fa673684cf6d13baa7b13aea1c04c0",
+    "variants/cpu-fp16/train/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452",
+    "variants/cpu-int4/checksums.json": "3a519b0e51c30b28d70b6e86d3d7f9e2ee8b7324f9033991a1ecbc046304b613",
+    "variants/cpu-int4/embedding/embedding_model.onnx": "60a7c170d9e49b7edb8c14a08385667f330d5e762cd42179297028719ec4d941",
+    "variants/cpu-int4/embedding/rag_config.json": "aebdb4b9641d0da9344a75bb753bd4b8c31ce66183f2b6780d9b43a39377fa20",
+    "variants/cpu-int4/inference/frozen_base.onnx.data": "3b9d3e0ca40fedc16823b2a0d15ebb760aa9b1c2f68ce2fe229688cf36a4b42d",
+    "variants/cpu-int4/inference/genai_config.json": "86dfd3eb783dd928ccefe7deb60ba8b0c6fe3c1399584f1934b15543ec6c3496",
+    "variants/cpu-int4/inference/generation_config.json": "1d985e40e0f3c082e41afef928f2c2d2362acae574b1b0e5550de0d51edef52f",
+    "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": "b39a7c6175b60a789569dd83dafebc0ef35cd78d53f955bdcd05fd8142895da3",
+    "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": "827d096d92f3deeaa0e8070d79f45beb176768e57a958a1cd325f5f4b754b048",
+    "variants/cpu-int4/inference/model.onnx": "f41027621d842764ef7f3b12331cec51ede487a823c41b445cc84d1414030147",
+    "variants/cpu-int4/inference/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452",
+    "variants/cpu-int4/train/training_config.json": "b19bcfdda05b80cca28138805de0fd2480fa673684cf6d13baa7b13aea1c04c0",
+    "variants/cpu-int4/train/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452"
+  },
+  "supportedTasks": [
+    "text-generation",
+    "text-generation-with-past"
+  ],
+  "transformersVersion": "4.46.2",
+  "trustRemoteCode": false,
+  "variants": [
+    {
+      "abi": [
+        "arm64-v8a"
+      ],
+      "executionProvider": "cpu",
+      "features": [
+        "core",
+        "inference",
+        "train",
+        "rag",
+        "genai"
+      ],
+      "id": "cpu-int4",
+      "minimumAndroidApi": 28,
+      "paths": {
+        "embedding": "variants/cpu-int4/embedding",
+        "inference": "variants/cpu-int4/inference",
+        "tokenizer": "shared/tokenizer",
+        "train": "variants/cpu-int4/train"
+      },
+      "quantization": "int4",
+      "recommendedDeviceMemoryMb": 3072,
+      "supportedEngines": [
+        "native",
+        "genai"
+      ],
+      "weightHandoff": "variants/cpu-int4/inference/weight_handoff_map.json"
+    },
+    {
+      "abi": null,
+      "executionProvider": "cpu",
+      "features": [
+        "core",
+        "inference",
+        "train"
+      ],
+      "id": "cpu-fp16",
+      "minimumAndroidApi": 28,
+      "paths": {
+        "inference": "variants/cpu-fp16/inference",
+        "tokenizer": "shared/tokenizer",
+        "train": "variants/cpu-fp16/train"
+      },
+      "quantization": "fp16",
+      "recommendedDeviceMemoryMb": 6144,
+      "supportedEngines": [
+        "native"
+      ],
+      "weightHandoff": "variants/cpu-fp16/inference/weight_handoff_map.json"
+    }
+  ],
+  "weightHandoff": "variants/cpu-int4/inference/weight_handoff_map.json"
+}
diff --git a/tests/fixtures/tiny_package/optimum/export_report.json b/tests/fixtures/tiny_package/optimum/export_report.json
new file mode 100644
index 0000000..84901ed
--- /dev/null
+++ b/tests/fixtures/tiny_package/optimum/export_report.json
@@ -0,0 +1 @@
+{"selectedTask": "text-generation-with-past"}
diff --git a/tests/fixtures/tiny_package/optimum/optimum_config.json b/tests/fixtures/tiny_package/optimum/optimum_config.json
new file mode 100644
index 0000000..febabd2
--- /dev/null
+++ b/tests/fixtures/tiny_package/optimum/optimum_config.json
@@ -0,0 +1 @@
+{"opset": 20}
diff --git a/tests/fixtures/tiny_package/optimum/supported_tasks.json b/tests/fixtures/tiny_package/optimum/supported_tasks.json
new file mode 100644
index 0000000..99a5d63
--- /dev/null
+++ b/tests/fixtures/tiny_package/optimum/supported_tasks.json
@@ -0,0 +1 @@
+["text-generation", "text-generation-with-past"]
diff --git a/tests/fixtures/tiny_package/shared/chat_template.jinja b/tests/fixtures/tiny_package/shared/chat_template.jinja
new file mode 100644
index 0000000..a4d882e
--- /dev/null
+++ b/tests/fixtures/tiny_package/shared/chat_template.jinja
@@ -0,0 +1 @@
+{{ messages }}
diff --git a/tests/fixtures/tiny_package/shared/config.json b/tests/fixtures/tiny_package/shared/config.json
new file mode 100644
index 0000000..7768d91
--- /dev/null
+++ b/tests/fixtures/tiny_package/shared/config.json
@@ -0,0 +1,3 @@
+{
+  "model_type": "llama"
+}
diff --git a/tests/fixtures/tiny_package/shared/generation_config.json b/tests/fixtures/tiny_package/shared/generation_config.json
new file mode 100644
index 0000000..57f09e3
--- /dev/null
+++ b/tests/fixtures/tiny_package/shared/generation_config.json
@@ -0,0 +1,3 @@
+{
+  "eos_token_id": 2
+}
diff --git a/tests/fixtures/tiny_package/shared/tokenizer/tokenizer.json b/tests/fixtures/tiny_package/shared/tokenizer/tokenizer.json
new file mode 100644
index 0000000..92bdb0a
--- /dev/null
+++ b/tests/fixtures/tiny_package/shared/tokenizer/tokenizer.json
@@ -0,0 +1 @@
+{"version": "1.0"}
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/checksums.json b/tests/fixtures/tiny_package/variants/cpu-fp16/checksums.json
new file mode 100644
index 0000000..4c63d28
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/checksums.json
@@ -0,0 +1,10 @@
+{
+  "variants/cpu-fp16/inference/frozen_base.onnx.data": "3b9d3e0ca40fedc16823b2a0d15ebb760aa9b1c2f68ce2fe229688cf36a4b42d",
+  "variants/cpu-fp16/inference/generation_config.json": "1d985e40e0f3c082e41afef928f2c2d2362acae574b1b0e5550de0d51edef52f",
+  "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": "b39a7c6175b60a789569dd83dafebc0ef35cd78d53f955bdcd05fd8142895da3",
+  "variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": "827d096d92f3deeaa0e8070d79f45beb176768e57a958a1cd325f5f4b754b048",
+  "variants/cpu-fp16/inference/model.onnx": "f41027621d842764ef7f3b12331cec51ede487a823c41b445cc84d1414030147",
+  "variants/cpu-fp16/inference/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452",
+  "variants/cpu-fp16/train/training_config.json": "b19bcfdda05b80cca28138805de0fd2480fa673684cf6d13baa7b13aea1c04c0",
+  "variants/cpu-fp16/train/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/frozen_base.onnx.data b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/frozen_base.onnx.data
new file mode 100644
index 0000000..228610c
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/frozen_base.onnx.data
@@ -0,0 +1 @@
+FROZEN_BASE_PLACEHOLDER
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/generation_config.json b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/generation_config.json
new file mode 100644
index 0000000..c07ecaf
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/generation_config.json
@@ -0,0 +1,3 @@
+{
+  "type": "native"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin
new file mode 100644
index 0000000..608dd8d
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin
@@ -0,0 +1 @@
+TRAINABLE_TENSOR_BYTES
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256 b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256
new file mode 100644
index 0000000..cd09bbf
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000000000000000000
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.onnx b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.onnx
new file mode 100644
index 0000000..35e409e
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/model.onnx
@@ -0,0 +1 @@
+ONNX_PLACEHOLDER
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/inference/weight_handoff_map.json b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/weight_handoff_map.json
new file mode 100644
index 0000000..6df8f75
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/inference/weight_handoff_map.json
@@ -0,0 +1,40 @@
+{
+  "engines": [
+    "native",
+    "genai"
+  ],
+  "entries": [
+    {
+      "checkpointNames": {
+        "weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        4,
+        3
+      ],
+      "trainingBaseLayerName": "backbone.model.layers.0.self_attn.q_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    }
+  ],
+  "externalDataLayout": "one_file_per_tensor",
+  "frozenBaseBlob": "frozen_base.onnx.data",
+  "handoffMode": "external_initializer",
+  "mergerModels": {},
+  "minReaderVersion": "1.0",
+  "schemaVersion": "1.0"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/train/training_config.json b/tests/fixtures/tiny_package/variants/cpu-fp16/train/training_config.json
new file mode 100644
index 0000000..9575483
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/train/training_config.json
@@ -0,0 +1,4 @@
+{
+  "peftMethod": "lora",
+  "rank": 8
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-fp16/train/weight_handoff_map.json b/tests/fixtures/tiny_package/variants/cpu-fp16/train/weight_handoff_map.json
new file mode 100644
index 0000000..6df8f75
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-fp16/train/weight_handoff_map.json
@@ -0,0 +1,40 @@
+{
+  "engines": [
+    "native",
+    "genai"
+  ],
+  "entries": [
+    {
+      "checkpointNames": {
+        "weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        4,
+        3
+      ],
+      "trainingBaseLayerName": "backbone.model.layers.0.self_attn.q_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    }
+  ],
+  "externalDataLayout": "one_file_per_tensor",
+  "frozenBaseBlob": "frozen_base.onnx.data",
+  "handoffMode": "external_initializer",
+  "mergerModels": {},
+  "minReaderVersion": "1.0",
+  "schemaVersion": "1.0"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/checksums.json b/tests/fixtures/tiny_package/variants/cpu-int4/checksums.json
new file mode 100644
index 0000000..b4e6d04
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/checksums.json
@@ -0,0 +1,13 @@
+{
+  "variants/cpu-int4/embedding/embedding_model.onnx": "60a7c170d9e49b7edb8c14a08385667f330d5e762cd42179297028719ec4d941",
+  "variants/cpu-int4/embedding/rag_config.json": "aebdb4b9641d0da9344a75bb753bd4b8c31ce66183f2b6780d9b43a39377fa20",
+  "variants/cpu-int4/inference/frozen_base.onnx.data": "3b9d3e0ca40fedc16823b2a0d15ebb760aa9b1c2f68ce2fe229688cf36a4b42d",
+  "variants/cpu-int4/inference/genai_config.json": "86dfd3eb783dd928ccefe7deb60ba8b0c6fe3c1399584f1934b15543ec6c3496",
+  "variants/cpu-int4/inference/generation_config.json": "1d985e40e0f3c082e41afef928f2c2d2362acae574b1b0e5550de0d51edef52f",
+  "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin": "b39a7c6175b60a789569dd83dafebc0ef35cd78d53f955bdcd05fd8142895da3",
+  "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256": "827d096d92f3deeaa0e8070d79f45beb176768e57a958a1cd325f5f4b754b048",
+  "variants/cpu-int4/inference/model.onnx": "f41027621d842764ef7f3b12331cec51ede487a823c41b445cc84d1414030147",
+  "variants/cpu-int4/inference/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452",
+  "variants/cpu-int4/train/training_config.json": "b19bcfdda05b80cca28138805de0fd2480fa673684cf6d13baa7b13aea1c04c0",
+  "variants/cpu-int4/train/weight_handoff_map.json": "f8208cd160431f9942a4c4d9487a59ebc91dad9b3a0e739519e72964bbc1f452"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/embedding/embedding_model.onnx b/tests/fixtures/tiny_package/variants/cpu-int4/embedding/embedding_model.onnx
new file mode 100644
index 0000000..a9fc0ff
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/embedding/embedding_model.onnx
@@ -0,0 +1 @@
+EMBED_ONNX_PLACEHOLDER
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/embedding/rag_config.json b/tests/fixtures/tiny_package/variants/cpu-int4/embedding/rag_config.json
new file mode 100644
index 0000000..a3eefd3
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/embedding/rag_config.json
@@ -0,0 +1,3 @@
+{
+  "embeddingDimension": 384
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/frozen_base.onnx.data b/tests/fixtures/tiny_package/variants/cpu-int4/inference/frozen_base.onnx.data
new file mode 100644
index 0000000..228610c
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/frozen_base.onnx.data
@@ -0,0 +1 @@
+FROZEN_BASE_PLACEHOLDER
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/genai_config.json b/tests/fixtures/tiny_package/variants/cpu-int4/inference/genai_config.json
new file mode 100644
index 0000000..0a2588b
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/genai_config.json
@@ -0,0 +1,5 @@
+{
+  "model": {
+    "type": "llama"
+  }
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/generation_config.json b/tests/fixtures/tiny_package/variants/cpu-int4/inference/generation_config.json
new file mode 100644
index 0000000..c07ecaf
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/generation_config.json
@@ -0,0 +1,3 @@
+{
+  "type": "native"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin
new file mode 100644
index 0000000..608dd8d
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin
@@ -0,0 +1 @@
+TRAINABLE_TENSOR_BYTES
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256 b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256
new file mode 100644
index 0000000..cd09bbf
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin.sha256
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000000000000000000
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.onnx b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.onnx
new file mode 100644
index 0000000..35e409e
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/model.onnx
@@ -0,0 +1 @@
+ONNX_PLACEHOLDER
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/inference/weight_handoff_map.json b/tests/fixtures/tiny_package/variants/cpu-int4/inference/weight_handoff_map.json
new file mode 100644
index 0000000..6df8f75
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/inference/weight_handoff_map.json
@@ -0,0 +1,40 @@
+{
+  "engines": [
+    "native",
+    "genai"
+  ],
+  "entries": [
+    {
+      "checkpointNames": {
+        "weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        4,
+        3
+      ],
+      "trainingBaseLayerName": "backbone.model.layers.0.self_attn.q_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    }
+  ],
+  "externalDataLayout": "one_file_per_tensor",
+  "frozenBaseBlob": "frozen_base.onnx.data",
+  "handoffMode": "external_initializer",
+  "mergerModels": {},
+  "minReaderVersion": "1.0",
+  "schemaVersion": "1.0"
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/train/training_config.json b/tests/fixtures/tiny_package/variants/cpu-int4/train/training_config.json
new file mode 100644
index 0000000..9575483
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/train/training_config.json
@@ -0,0 +1,4 @@
+{
+  "peftMethod": "lora",
+  "rank": 8
+}
diff --git a/tests/fixtures/tiny_package/variants/cpu-int4/train/weight_handoff_map.json b/tests/fixtures/tiny_package/variants/cpu-int4/train/weight_handoff_map.json
new file mode 100644
index 0000000..6df8f75
--- /dev/null
+++ b/tests/fixtures/tiny_package/variants/cpu-int4/train/weight_handoff_map.json
@@ -0,0 +1,40 @@
+{
+  "engines": [
+    "native",
+    "genai"
+  ],
+  "entries": [
+    {
+      "checkpointNames": {
+        "weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"
+      },
+      "dtype": "float32",
+      "externalDataLocation": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight.bin"
+      },
+      "genaiInputNames": {},
+      "inferenceInitializerNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergedTensorNames": {
+        "weight": "model.layers.0.attn.q_proj.MatMul.weight"
+      },
+      "mergerOutputNames": {
+        "weight": "merged_weight"
+      },
+      "sha256": {},
+      "shape": [
+        4,
+        3
+      ],
+      "trainingBaseLayerName": "backbone.model.layers.0.self_attn.q_proj.base_layer",
+      "transposePolicy": "no_transpose"
+    }
+  ],
+  "externalDataLayout": "one_file_per_tensor",
+  "frozenBaseBlob": "frozen_base.onnx.data",
+  "handoffMode": "external_initializer",
+  "mergerModels": {},
+  "minReaderVersion": "1.0",
+  "schemaVersion": "1.0"
+}
diff --git a/tests/fixtures/tiny_trainable.onnx b/tests/fixtures/tiny_trainable.onnx
new file mode 100644
index 0000000..db5ae40
Binary files /dev/null and b/tests/fixtures/tiny_trainable.onnx differ
diff --git a/tests/fixtures/training_config.json b/tests/fixtures/training_config.json
new file mode 100644
index 0000000..edafb51
--- /dev/null
+++ b/tests/fixtures/training_config.json
@@ -0,0 +1,14 @@
+{
+  "requires_grad": [
+    "weight"
+  ],
+  "peft_mapping": {
+    "linear.weight": "linear.weight"
+  },
+  "rank": 8,
+  "alpha": 16,
+  "peft_target": [
+    "linear"
+  ],
+  "trainable_parameter_count": 4
+}
diff --git a/tests/hub/__init__.py b/tests/hub/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/hub/test_package_format.py b/tests/hub/test_package_format.py
new file mode 100644
index 0000000..1a5e3ae
--- /dev/null
+++ b/tests/hub/test_package_format.py
@@ -0,0 +1,148 @@
+"""#14 Hub package format: sanitize_repo_id parity, build_manifest round-trip, dual-engine sanity.
+
+onnx-free (core env). Uses the committed tiny package fixture (tests/fixtures/tiny_package).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.versioning import SchemaVersionError, check_compat
+from mobiletransformers.hub.package_format import (
+    MANIFEST_FILENAME,
+    build_manifest,
+    sanitize_repo_id,
+)
+
+FIXTURES = Path(__file__).resolve().parents[1] / "fixtures"
+PKG = FIXTURES / "tiny_package"
+
+
+def _load_manifest() -> dict:
+    return json.loads((PKG / MANIFEST_FILENAME).read_text())
+
+
+# --- sanitize_repo_id parity ------------------------------------------------
+
+
+def _sanitize_cases() -> list[tuple[str, str]]:
+    data = json.loads((FIXTURES / "sanitize_repo_id_cases.json").read_text())
+    return [(c["input"], c["expected"]) for c in data["cases"]]
+
+
+@pytest.mark.parametrize("raw,expected", _sanitize_cases())
+def test_sanitize_repo_id_matches_parity_oracle(raw, expected):
+    assert sanitize_repo_id(raw) == expected
+
+
+# --- build_manifest round-trip ---------------------------------------------
+
+
+def test_manifest_integrity_keys_exist_on_disk():
+    m = _load_manifest()
+    for rel in m["sha256"]:
+        assert (PKG / rel).is_file(), f"sha256 references missing file {rel}"
+    for rel in m["fileSizes"]:
+        assert (PKG / rel).stat().st_size == m["fileSizes"][rel]
+
+
+def test_required_files_present():
+    m = _load_manifest()
+    for rel in m["requiredFiles"]:
+        assert (PKG / rel).exists(), f"requiredFile missing: {rel}"
+
+
+def test_download_plan_patterns_resolve():
+    m = _load_manifest()
+    for variant_id, groups in m["downloadPlan"].items():
+        for group, patterns in groups.items():
+            for pat in patterns:
+                if pat.endswith("/**"):
+                    matches = list(PKG.glob(pat.replace("/**", "/**/*")))
+                    assert matches, f"{variant_id}/{group} glob {pat} matched nothing"
+                else:
+                    assert (PKG / pat).exists(), f"{variant_id}/{group} path {pat} missing"
+
+
+def test_build_manifest_is_deterministic():
+    # Rebuilding over the same tree reproduces identical integrity maps.
+    m = _load_manifest()
+    variants = [
+        {k: v for k, v in var.items() if k not in ("weightHandoff", "paths")} for var in m["variants"]
+    ]
+    report = {
+        "mobiletransformersVersion": m["mobiletransformersVersion"],
+        "architectures": m["architectures"],
+        "supportedTasks": m["supportedTasks"],
+        "selectedTask": m["selectedTask"],
+        "peftMethods": m["peftMethods"],
+        "quantization": m["quantization"],
+    }
+    rebuilt = build_manifest(
+        PKG,
+        variants,
+        base_model_id=m["baseModelId"],
+        report=report,
+        default_variant=m["defaultVariant"],
+        exported_at=m["exportedAt"],
+    )
+    assert rebuilt["sha256"] == m["sha256"]
+    assert rebuilt["fileSizes"] == m["fileSizes"]
+    assert rebuilt["downloadPlan"] == m["downloadPlan"]
+
+
+def test_parameter_counts_reach_the_manifest():
+    """The training stage reports both counts; `build_manifest` used to drop them on the floor.
+
+    Every shipped package (decoder and encoder alike) read `null` for these while
+    `train/trainable_parameters.json` carried the real number — so a package could not be audited
+    from its manifest alone.
+    """
+    m = _load_manifest()
+    variants = [
+        {k: v for k, v in var.items() if k not in ("weightHandoff", "paths")} for var in m["variants"]
+    ]
+    report = {"trainableParameterCount": 442_368, "trainingParameterCount": 135_000_000}
+    rebuilt = build_manifest(
+        PKG, variants, base_model_id=m["baseModelId"], report=report, default_variant=m["defaultVariant"]
+    )
+    assert rebuilt["trainableParameterCount"] == 442_368
+    assert rebuilt["trainingParameterCount"] == 135_000_000
+
+    # Inference-only packages legitimately have neither: the key is present and null, not absent.
+    inference_only = build_manifest(
+        PKG, variants, base_model_id=m["baseModelId"], report={}, default_variant=m["defaultVariant"]
+    )
+    assert inference_only["trainableParameterCount"] is None
+    assert inference_only["trainingParameterCount"] is None
+
+
+# --- dual-engine sanity -----------------------------------------------------
+
+
+def test_genai_variant_has_both_configs_native_only_omits():
+    m = _load_manifest()
+    by_id = {v["id"]: v for v in m["variants"]}
+    # cpu-int4 supports genai -> genai_config.json present, downloadPlan.genai non-empty.
+    assert "genai" in by_id["cpu-int4"]["supportedEngines"]
+    assert (PKG / "variants/cpu-int4/inference/genai_config.json").exists()
+    assert m["downloadPlan"]["cpu-int4"]["genai"]
+    # cpu-fp16 is native-only -> no genai_config.json, downloadPlan.genai empty.
+    assert "genai" not in by_id["cpu-fp16"]["supportedEngines"]
+    assert not (PKG / "variants/cpu-fp16/inference/genai_config.json").exists()
+    assert m["downloadPlan"]["cpu-fp16"]["genai"] == []
+
+
+# --- schema versioning (F1) -------------------------------------------------
+
+
+def test_manifest_carries_schema_versions_and_reader_gate():
+    m = _load_manifest()
+    assert m["schemaVersion"] and m["minReaderVersion"]
+    # A reader at 1.0 accepts a 1.0 doc; a future major fails closed.
+    check_compat(m["schemaVersion"], m["minReaderVersion"], "1.0")
+    with pytest.raises(SchemaVersionError):
+        check_compat("2.0", "2.0", "1.0")
diff --git a/tests/hub/test_pull.py b/tests/hub/test_pull.py
new file mode 100644
index 0000000..3aab2bf
--- /dev/null
+++ b/tests/hub/test_pull.py
@@ -0,0 +1,89 @@
+"""#21 pull + install smokes — offline (injected downloader over the tiny_package fixture)."""
+
+from __future__ import annotations
+
+import fnmatch
+import shutil
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.exceptions import HubError
+from mobiletransformers.hub.pull import install_package, pull_package
+
+FIXTURE = Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package"
+
+
+def _fake_downloader(remote: Path):
+    """A snapshot_download stand-in: copy files under `remote` matching allow_patterns into local_dir."""
+
+    def _dl(*, repo_id, revision, token, local_dir, allow_patterns, **_):
+        dst = Path(local_dir)
+        rels = [p.relative_to(remote).as_posix() for p in remote.rglob("*") if p.is_file()]
+        for rel in rels:
+            if _matches(rel, allow_patterns):
+                out = dst / rel
+                out.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(remote / rel, out)
+        return str(dst)
+
+    return _dl
+
+
+def _matches(rel: str, patterns) -> bool:
+    for pat in patterns:
+        if pat.endswith("/**"):
+            if rel.startswith(pat[:-2]) or rel.startswith(pat[:-3] + "/"):
+                return True
+        elif rel == pat or fnmatch.fnmatch(rel, pat):
+            return True
+    return False
+
+
+def test_pull_inference_only_downloads_expected_and_verifies(tmp_path):
+    staging = pull_package(
+        "org/tiny-model",
+        features=("inference",),
+        dest=tmp_path / "stg",
+        downloader=_fake_downloader(FIXTURE),
+    )
+    # core + inference + checksums present; train/ and embedding/ absent (not requested).
+    assert (staging / "mobiletransformers_manifest.json").is_file()
+    assert (staging / "shared/tokenizer/tokenizer.json").is_file()
+    assert (staging / "variants/cpu-int4/inference/model.onnx").is_file()
+    assert not (staging / "variants/cpu-int4/train").exists()
+    assert not (staging / "variants/cpu-int4/embedding").exists()
+
+
+def test_pull_detects_sha256_mismatch(tmp_path):
+    remote = tmp_path / "remote"
+    shutil.copytree(FIXTURE, remote)
+    # Corrupt one inference file's bytes (its manifest sha256 no longer matches).
+    (remote / "variants/cpu-int4/inference/model.onnx").write_text("CORRUPTED")
+    with pytest.raises(HubError, match="sha256 mismatch.*model.onnx"):
+        pull_package(
+            "org/tiny-model",
+            features=("inference",),
+            dest=tmp_path / "stg",
+            downloader=_fake_downloader(remote),
+        )
+
+
+def test_install_materializes_cache_layout(tmp_path):
+    staging = pull_package(
+        "org/tiny-model",
+        features=("inference", "train", "rag"),
+        dest=tmp_path / "stg",
+        downloader=_fake_downloader(FIXTURE),
+    )
+    cache_root = tmp_path / "cache"
+    target = install_package(staging, cache_root, "org/Tiny-Model", variant="cpu-int4")
+    assert target.name == "org__Tiny-Model"
+    # LLMRepository-shaped layout; tokenizer flattened out of shared/.
+    assert (target / "inference/model.onnx").is_file()
+    assert (target / "train/training_config.json").is_file()
+    assert (target / "embedding/rag_config.json").is_file()
+    assert (target / "tokenizer/tokenizer.json").is_file()
+    assert (target / "mobiletransformers_manifest.json").is_file()
+    # atomic: no leftover staging.
+    assert not (cache_root / ".partial" / "org__Tiny-Model").exists()
diff --git a/tests/hub/test_variant_select.py b/tests/hub/test_variant_select.py
new file mode 100644
index 0000000..645b817
--- /dev/null
+++ b/tests/hub/test_variant_select.py
@@ -0,0 +1,51 @@
+"""#21 constraint-based variant selection (onnx-free; uses the tiny_package fixture)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.exceptions import NoCompatibleVariant
+from mobiletransformers.hub.variant_select import Constraints, default_desktop_constraints, select_variant
+
+MANIFEST = (
+    Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package" / "mobiletransformers_manifest.json"
+)
+
+
+def _m() -> MobileTransformersManifest:
+    return MobileTransformersManifest.load(MANIFEST)
+
+
+def test_default_desktop_prefers_int4():
+    assert select_variant(_m(), default_desktop_constraints()) == "cpu-int4"
+
+
+def test_preferred_quantization_soft_preference():
+    c = Constraints(abi=("arm64-v8a", "x86_64"), preferred_quantization="fp16")
+    assert select_variant(_m(), c) == "cpu-fp16"
+
+
+def test_memory_ceiling_excludes_fp16():
+    # 4096 MB fits cpu-int4 (3072) but not cpu-fp16 (6144), even if fp16 preferred.
+    c = Constraints(abi=("arm64-v8a", "x86_64"), preferred_quantization="fp16", device_memory_mb=4096)
+    assert select_variant(_m(), c) == "cpu-int4"
+
+
+def test_genai_engine_requires_int4():
+    c = Constraints(abi=("arm64-v8a",), engine="genai", requested_features=("core", "inference", "genai"))
+    assert select_variant(_m(), c) == "cpu-int4"
+
+
+def test_storage_budget_fails_closed():
+    c = Constraints(abi=("arm64-v8a", "x86_64"), available_storage_bytes=10)  # ~10 bytes: impossible
+    with pytest.raises(NoCompatibleVariant, match="budget"):
+        select_variant(_m(), c)
+
+
+def test_no_matching_abi_raises():
+    c = Constraints(abi=("riscv64",))  # cpu-int4 is arm64-only; cpu-fp16 abi=null (any) -> fp16 chosen
+    # cpu-fp16 has abi=null so it matches any ABI; assert it is selected rather than raising.
+    assert select_variant(_m(), c) == "cpu-fp16"
diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/integration/test_encoder_training_gate.py b/tests/integration/test_encoder_training_gate.py
new file mode 100644
index 0000000..ccc5848
--- /dev/null
+++ b/tests/integration/test_encoder_training_gate.py
@@ -0,0 +1,171 @@
+"""#33 encoder training gate: export -> generate_artifacts -> real train step -> a metric.
+
+This is the plan's Definition-of-done for encoder support minus the Android smoke (device-gated). It
+downloads a small real encoder, so it is env-gated on the ``ort-training-local`` profile AND on
+network access, exactly like the other integration smokes.
+
+Run:  uv run --python 3.12 --group ort-training-local --no-default-groups \\
+          pytest tests/integration/test_encoder_training_gate.py -q
+
+## What this pins, and why each part earned a test
+
+Three defects had to be fixed to get here, none of which a decoder run could have surfaced:
+
+1. **PEFT was wrapped as ``CAUSAL_LM``** at both LoRA call sites regardless of task, mis-configuring
+   any encoder. Now from ``TaskSpec.peft_task_type``.
+2. **Activation quantization on the gradient path.** ORT rewrites ``Gemm`` -> ``MatMul`` *before*
+   quantizing and matches ``nodes_to_exclude`` against the rewritten name, so excluding BERT's
+   pooler/classifier ``Gemm`` silently missed and they came back as ``MatMulInteger`` fed by
+   ``DynamicQuantizeLinear`` — which has no gradient. Quantized *weights* are fine (they dequantize to
+   float and are frozen); quantized *activations* are not.
+3. **``LayerNormalization`` exported with one output.** ORT's gradient reads its optional saved
+   mean/inv-std. RMSNorm decoders export ``SimplifiedLayerNormalization`` with 2 outputs already.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+pytest.importorskip("torch", reason="ort-training-local profile only")
+pytest.importorskip("onnxruntime.training.artifacts", reason="ort-training-local profile only")
+pytest.importorskip("optimum.exporters.onnx", reason="optimum required for the export leg")
+pytest.importorskip("transformers", reason="transformers required for the export leg")
+
+#: Small real encoder (22.7M params) that the project already ships as the RAG embedder, so this adds
+#: no new download to a machine that has run an export.
+ENCODER_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+#: A tiny, deliberately separable sentiment set: the point is to prove gradients reach the encoder and
+#: move a real metric, not to measure generalisation.
+POSITIVE = [
+    "this film was wonderful",
+    "an absolute delight to watch",
+    "brilliant and moving",
+    "a masterpiece of storytelling",
+]
+NEGATIVE = [
+    "this film was terrible",
+    "a complete waste of time",
+    "boring and painfully dull",
+    "an awful, incoherent mess",
+]
+
+
+@pytest.fixture(scope="module")
+def encoder_artifacts(tmp_path_factory):
+    """Export the encoder training graph and generate ORT training artifacts once."""
+    from mobiletransformers.artifacts.builder import gen_artifacts
+    from mobiletransformers.export.training_export import optimum_hf_export
+
+    root = tmp_path_factory.mktemp("encoder_gate")
+    export_dir, artifact_dir = root / "export", root / "artifacts"
+    export_dir.mkdir()
+    artifact_dir.mkdir()
+
+    optimum_hf_export(
+        model_id=ENCODER_MODEL,
+        model_output=str(export_dir),
+        training_mode=True,
+        train_method="lora",
+        lora_rank=8,
+        lora_alpha=8,
+        quantize=True,
+        # No lora_target: the architecture registry's row for BertForSequenceClassification decides.
+        task_type="text-classification",
+    )
+    config = gen_artifacts(
+        train_dir=str(export_dir),
+        artifact_dir=str(artifact_dir),
+        model_name="quant_model.onnx",
+        training_config={},
+    )
+    return export_dir, artifact_dir, config
+
+
+def test_exported_graph_takes_per_sequence_labels_and_emits_a_loss(encoder_artifacts):
+    """`labels[batch]` — one per sequence — is the contract that defines this objective."""
+    import onnx
+
+    export_dir, _, _ = encoder_artifacts
+    model = onnx.load(str(export_dir / "model.onnx"), load_external_data=False)
+
+    shapes = {
+        i.name: [d.dim_param or d.dim_value for d in i.type.tensor_type.shape.dim] for i in model.graph.input
+    }
+    assert shapes["labels"] == ["batch_size"], "classification supervises one label per sequence"
+    assert shapes["input_ids"] == ["batch_size", "sequence_length"]
+    # token_type_ids, not position_ids — the encoder wrapper's signature is the exported input set.
+    assert "token_type_ids" in shapes and "position_ids" not in shapes
+    assert [o.name for o in model.graph.output] == ["loss", "logits"]
+
+
+def test_no_activation_quantization_survives_on_the_gradient_path(encoder_artifacts):
+    """Quantized weights are fine; quantized activations have no gradient at all.
+
+    `DequantizeLinear` on a frozen weight is what the project wants. `DynamicQuantizeLinear` means an
+    *activation* was quantized, and ORT registers no gradient builder for it.
+    """
+    import onnx
+
+    export_dir, _, _ = encoder_artifacts
+    model = onnx.load(str(export_dir / "quant_model.onnx"), load_external_data=False)
+    op_types = [n.op_type for n in model.graph.node]
+
+    assert op_types.count("DynamicQuantizeLinear") == 0
+    assert op_types.count("MatMulInteger") == 0
+    assert op_types.count("DequantizeLinear") > 0, "weights should still be quantized"
+
+
+def test_training_artifacts_are_generated(encoder_artifacts):
+    _, artifact_dir, config = encoder_artifacts
+
+    for name in ("training_model.onnx", "eval_model.onnx", "optimizer_model.onnx", "checkpoint"):
+        assert (artifact_dir / name).exists(), f"{name} missing"
+    assert config["trainable_parameter_count"] > 0
+    assert config["source_parameter_count"] > config["trainable_parameter_count"]
+
+
+def test_the_encoder_actually_learns(encoder_artifacts):
+    """The gate itself: gradients reach the encoder and move a real metric.
+
+    Asserts on **accuracy**, not only loss — a falling loss shows the optimizer runs, while accuracy
+    going to 1.0 on a separable set shows the update is in the right direction.
+    """
+    from onnxruntime.training.api import CheckpointState, Module, Optimizer
+    from transformers import AutoTokenizer
+
+    _, artifact_dir, _ = encoder_artifacts
+
+    state = CheckpointState.load_checkpoint(str(artifact_dir / "checkpoint"))
+    module = Module(str(artifact_dir / "training_model.onnx"), state, str(artifact_dir / "eval_model.onnx"))
+    optimizer = Optimizer(str(artifact_dir / "optimizer_model.onnx"), module)
+
+    tokenizer = AutoTokenizer.from_pretrained(ENCODER_MODEL)
+    encoded = tokenizer(
+        POSITIVE + NEGATIVE,
+        return_tensors="np",
+        padding="max_length",
+        truncation=True,
+        max_length=32,
+    )
+    input_ids = encoded["input_ids"].astype(np.int64)
+    attention_mask = encoded["attention_mask"].astype(np.int64)
+    token_type_ids = encoded.get("token_type_ids", np.zeros_like(input_ids)).astype(np.int64)
+    labels = np.array([1] * len(POSITIVE) + [0] * len(NEGATIVE), dtype=np.int64)
+
+    def accuracy() -> float:
+        module.eval()
+        logits = module(input_ids, attention_mask, token_type_ids, labels)[1]
+        return float((logits.argmax(-1) == labels).mean())
+
+    module.train()
+    losses = []
+    for _ in range(30):
+        losses.append(float(module(input_ids, attention_mask, token_type_ids, labels)[0]))
+        optimizer.step()
+        module.lazy_reset_grad()
+
+    assert all(np.isfinite(losses)), "loss went non-finite; gradients are not well-formed"
+    assert losses[-1] < losses[0] * 0.95, f"loss did not fall materially: {losses[0]} -> {losses[-1]}"
+    assert accuracy() == 1.0, "the encoder did not learn a deliberately separable 8-example set"
diff --git a/tests/integration/test_mars_encoder_transfer.py b/tests/integration/test_mars_encoder_transfer.py
new file mode 100644
index 0000000..3ae6b49
--- /dev/null
+++ b/tests/integration/test_mars_encoder_transfer.py
@@ -0,0 +1,305 @@
+"""#33 self-check 3: MARS transfer onto encoder attention layers — **verified, not assumed**.
+
+Run:  uv run --python 3.12 --group ort-training-local --no-default-groups \\
+          pytest tests/integration/test_mars_encoder_transfer.py -q
+
+Needs torch + transformers + peft; **no network and no HF token** — every model here is built from a
+tiny locally-constructed config, so this is fast and deterministic.
+
+## Why the assertions look the way they do
+
+A silent no-op and a successful transfer are indistinguishable from the outside, which is exactly the
+failure this file exists to catch. Before the fix, `peft/mars/model.py` hardcoded the Llama naming in
+five places:
+
+* the attention module was found by `isinstance(m, type(model.model.layers[0].self_attn))` —
+  `BertForSequenceClassification` has no `.model.layers` at all;
+* the shared outputs were read from `kwargs["hidden_states"]` — `BertAttention` passes them
+  positionally;
+* the projections were looked up as `q_proj`/`k_proj`/`v_proj` — BERT names them
+  `query`/`key`/`value`, nested one level deeper under `attention.self`;
+* `projection_type` came from `"q_proj" in target_name`, which matched nothing on an encoder, leaving
+  `is_standalone=True` — i.e. MARS **silently degraded to unshared adapters**;
+* `_replace_module` grouped `qkv`/`mlp` by the same decoder literals, so the shared adapter was never
+  wired to the wrapped module even when one existed.
+
+So asserting "the call returned" proves nothing. These tests assert **counts** (how many modules
+actually carry a shared adapter) and, across the seam, that perturbing the *shared* parameters
+changes the model's logits — which cannot happen unless the shared adapter is genuinely on the
+compute graph.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+torch = pytest.importorskip("torch", reason="needs torch (ort-training-local / export profile)")
+pytest.importorskip("transformers", reason="needs transformers")
+pytest.importorskip("peft", reason="needs peft")
+
+from peft import PeftType, get_peft_model  # noqa: E402
+
+# Same compat shim as `export/training_export.py`: peft 0.15 renamed the PeftType -> tuner-class
+# registry. Mirrored rather than imported from there, because that module pulls optimum.
+try:  # pragma: no cover - one branch per peft line
+    from peft.peft_model import PEFT_TYPE_TO_MODEL_MAPPING  # noqa: E402
+except ImportError:  # pragma: no cover
+    from peft.peft_model import PEFT_TYPE_TO_TUNER_MAPPING as PEFT_TYPE_TO_MODEL_MAPPING  # noqa: E402
+
+from mobiletransformers.peft.mars.config import MarsConfig  # noqa: E402
+from mobiletransformers.peft.mars.layer import Linear as MarsLinear  # noqa: E402
+from mobiletransformers.peft.mars.model import MarsModel  # noqa: E402
+
+
+def _register_mars_peft_type() -> None:
+    """Register MARS with peft the same way `export/training_export.py` does at import time.
+
+    Duplicated deliberately: importing that module here would pull optimum in, and the point of this
+    file is to test the PEFT wrap, not the export stack.
+    """
+    PeftType.MARS = "MARS"  # type: ignore[attr-defined]
+    PeftType._value2member_map_["MARS"] = "MARS"
+    PEFT_TYPE_TO_MODEL_MAPPING[PeftType("MARS")] = MarsModel
+
+
+_register_mars_peft_type()
+
+NUM_LAYERS = 2
+
+
+def _tiny_encoder():
+    """A 2-layer BERT classifier built from a config — no download, no token."""
+    from transformers import BertConfig, BertForSequenceClassification
+
+    config = BertConfig(
+        vocab_size=64,
+        hidden_size=32,
+        num_hidden_layers=NUM_LAYERS,
+        num_attention_heads=2,
+        intermediate_size=37,
+        max_position_embeddings=64,
+        num_labels=2,
+    )
+    torch.manual_seed(0)
+    return BertForSequenceClassification(config)
+
+
+def _tiny_decoder():
+    """The decoder regression twin — same size, same wrap, `q_proj`/`v_proj` naming."""
+    from transformers import LlamaConfig, LlamaForCausalLM
+
+    config = LlamaConfig(
+        vocab_size=64,
+        hidden_size=32,
+        num_hidden_layers=NUM_LAYERS,
+        num_attention_heads=2,
+        num_key_value_heads=2,
+        intermediate_size=37,
+        max_position_embeddings=64,
+    )
+    torch.manual_seed(0)
+    return LlamaForCausalLM(config)
+
+
+def _wrap(model, target_modules):
+    config = MarsConfig(
+        peft_type="MARS",
+        r=4,
+        alpha=4,
+        onnx_export=True,
+        target_modules=list(target_modules),
+        task_type=None,
+    )
+    return get_peft_model(model, config, adapter_name="mars")
+
+
+def _distinct_shared_adapters(model):
+    """The DISTINCT `SharedAttentionAdapter` objects in the tree — one per attention block.
+
+    Counting `hasattr(m, "shared_qkv")` would over-count: `_replace_module` also gives every wrapped
+    projection a back-reference to its block's adapter (that back-reference is what makes the adapter
+    shared at all), so a 2-layer model with 2 targets per layer reports 6 holders of 2 objects.
+    """
+    from mobiletransformers.peft.mars.layer import SharedAttentionAdapter
+
+    by_id = {}
+    for _name, module in model.named_modules():
+        if isinstance(module, SharedAttentionAdapter):
+            by_id[id(module)] = module
+    return list(by_id.values())
+
+
+def _shared_adapter_holders(model):
+    """Every module carrying a `shared_qkv` reference: the anchors plus the wrapped projections."""
+    return [(n, m) for n, m in model.named_modules() if hasattr(m, "shared_qkv")]
+
+
+def _wrapped_projections(model):
+    return [(n, m) for n, m in model.named_modules() if isinstance(m, MarsLinear)]
+
+
+# --- the count assertions: a no-op fails here, a returned call does not -----------------------
+
+
+@pytest.mark.parametrize(
+    ("build", "targets", "expected_names"),
+    [
+        (_tiny_encoder, ("query", "value"), {"query", "value"}),
+        (_tiny_decoder, ("q_proj", "v_proj"), {"q_proj", "v_proj"}),
+    ],
+    ids=["encoder", "decoder-regression"],
+)
+def test_shared_adapter_is_attached_to_every_attention_block(build, targets, expected_names):
+    """One `SharedAttentionAdapter` per attention block — counted, not assumed."""
+    model = _wrap(build(), targets)
+
+    # Exactly one shared adapter per attention block. The anchor it is attached to is the module that
+    # DIRECTLY owns the projections: `self_attn` on a decoder, `attention.self` on BERT.
+    adapters = _distinct_shared_adapters(model)
+    assert len(adapters) == NUM_LAYERS, f"expected {NUM_LAYERS} shared QKV adapters, got {len(adapters)}"
+
+    wrapped = _wrapped_projections(model)
+    # Two targets per layer (the Wq/Wv LoRA convention).
+    assert len(wrapped) == NUM_LAYERS * len(expected_names)
+    assert {n.rsplit(".", 1)[-1] for n, _ in wrapped} == expected_names
+
+    # Every wrapped projection holds a reference to one of those adapters — the anchors plus the
+    # wrapped projections, and nothing else, carry `shared_qkv`.
+    holders = _shared_adapter_holders(model)
+    assert len(holders) == NUM_LAYERS + len(wrapped)
+
+
+@pytest.mark.parametrize(
+    ("build", "targets"),
+    [(_tiny_encoder, ("query", "value")), (_tiny_decoder, ("q_proj", "v_proj"))],
+    ids=["encoder", "decoder-regression"],
+)
+def test_wrapped_projections_are_shared_not_standalone(build, targets):
+    """`is_standalone=False` is what distinguishes MARS from a degraded per-module LoRA.
+
+    This is the assertion the old code would have failed on an encoder while looking entirely
+    healthy: `projection_type` stayed `None`, so every module silently became standalone.
+    """
+    model = _wrap(build(), targets)
+    wrapped = _wrapped_projections(model)
+    assert wrapped, "no MARS Linear was created at all"
+
+    for name, module in wrapped:
+        assert module.projection_type in ("q", "v"), (
+            f"{name}: projection_type={module.projection_type!r} — the module name never resolved to "
+            "a projection role, which silently downgrades MARS to unshared adapters"
+        )
+        assert module.is_standalone is False, f"{name}: adapter is standalone, i.e. NOT shared"
+        # The shared adapter must actually be reachable from the wrapped module, not merely exist
+        # somewhere in the tree — `_replace_module` is what wires this, and it used to miss.
+        assert hasattr(module, "shared_qkv"), f"{name}: no reference to the block's shared adapter"
+
+
+# --- the across-the-seam assertion ------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("build", "targets", "forward"),
+    [
+        (
+            _tiny_encoder,
+            ("query", "value"),
+            lambda m: m(input_ids=torch.arange(8, dtype=torch.long).reshape(1, 8)).logits,
+        ),
+        (
+            _tiny_decoder,
+            ("q_proj", "v_proj"),
+            lambda m: m(input_ids=torch.arange(8, dtype=torch.long).reshape(1, 8)).logits,
+        ),
+    ],
+    ids=["encoder", "decoder-regression"],
+)
+def test_shared_parameters_are_on_the_compute_graph(build, targets, forward):
+    """Perturbing only the SHARED parameters must change the logits.
+
+    This is the seam. Counting wrapped modules proves the wrap happened; it does not prove the shared
+    adapter's output ever reaches the base layer. If the transfer had degraded to standalone
+    adapters, `shared_qkv` would be dead weight and these logits would be byte-identical.
+
+    `up_project` is zero-initialised (so a freshly wrapped model is output-identical to its base),
+    which is why it is filled first — otherwise the whole adapter branch multiplies to zero and the
+    test would pass for the wrong reason.
+    """
+    model = _wrap(build(), targets)
+    model.eval()
+
+    with torch.no_grad():
+        for name, param in model.named_parameters():
+            if "up_project" in name:
+                param.fill_(0.05)
+
+        before = forward(model).clone()
+
+        shared = [p for n, p in model.named_parameters() if "shared_qkv" in n]
+        assert shared, "no shared_qkv parameters exist at all"
+        for param in shared:
+            param.add_(0.5)
+
+        after = forward(model)
+
+    assert not torch.allclose(before, after), (
+        "perturbing the shared QKV adapter did not move the logits — the shared adapter is not on "
+        "the compute graph, i.e. the MARS transfer is a silent no-op"
+    )
+
+
+# --- the adapter mapping the codec consumes ---------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("build", "targets"),
+    [(_tiny_encoder, ("query", "value")), (_tiny_decoder, ("q_proj", "v_proj"))],
+    ids=["encoder", "decoder-regression"],
+)
+def test_adapter_mapping_has_the_same_shape_for_encoder_and_decoder(build, targets):
+    """#33's spike gate: the mapping must join cleanly, and every projection must know what it shares.
+
+    `named_modules()` surfaces a shared object exactly once, so only one projection per attention
+    block finds `shared_qkv` in its own subtree; the rest get a back-pointer from the builder's
+    fallback. That fallback used to test `"v_proj" in base_layer_name` — a decoder literal — so on an
+    encoder BERT's `value` silently ended up with no `shared_A` at all while `query` had one, i.e.
+    the two halves of a layer disagreed about whether they shared a tensor.
+
+    The assertion is therefore that **every** entry names the shared pair, and that both projections
+    of a layer name the **same** one. Encoder and decoder must agree on this shape.
+    """
+    from mobiletransformers.config.constants import PEFTMethod
+    from mobiletransformers.config.registry.peft import build_adapter_mapping
+
+    model = _wrap(build(), targets)
+    mapping = build_adapter_mapping(PEFTMethod.MARS, model)
+
+    assert len(mapping) == NUM_LAYERS * len(targets)
+    assert all(key.endswith(".base_layer") for key in mapping), "codec keys are base-layer paths"
+    # Every entry has its own up-projection and knows its shared pair.
+    assert all("adapter_B" in entry for entry in mapping.values())
+    assert all("shared_A" in entry for entry in mapping.values()), (
+        "a wrapped projection with no `shared_A` does not know it shares a tensor — the codec would "
+        "emit it as an independent adapter"
+    )
+    assert all("intermediate" in entry for entry in mapping.values())
+
+    # Exactly one shared pair per layer, named identically by both of that layer's projections.
+    distinct_shared = {entry["shared_A"] for entry in mapping.values()}
+    assert len(distinct_shared) == NUM_LAYERS, (
+        f"expected {NUM_LAYERS} distinct shared_A tensors (one per layer), got {sorted(distinct_shared)}"
+    )
+
+
+# --- fail-closed, rather than silently applying decoder naming --------------------------------
+
+
+def test_unknown_architecture_fails_closed_instead_of_assuming_decoder_naming():
+    from mobiletransformers.exceptions import UnsupportedModelError
+
+    model = _tiny_encoder()
+    # An architecture the registry does not know: previously this silently used `self_attn`/`q_proj`
+    # and produced a wrap that looked fine and shared nothing.
+    model.__class__ = type("TotallyMadeUpForSequenceClassification", (type(model),), {})
+    with pytest.raises(UnsupportedModelError, match="unsupported architecture"):
+        _wrap(model, ("query", "value"))
diff --git a/tests/integration/test_ort_training_smoke.py b/tests/integration/test_ort_training_smoke.py
new file mode 100644
index 0000000..bce1c1e
--- /dev/null
+++ b/tests/integration/test_ort_training_smoke.py
@@ -0,0 +1,89 @@
+"""ORT-training toolchain smoke (Gate 0.3): prove the source-built wheel is *alive*.
+
+Skips unless ``onnxruntime.training`` imports, so it only runs in the ``ort-training-local`` profile
+(Python 3.12). Mirrors ``artifact/onnx_builder.py::gen_artifacts``: split initializers into
+requires_grad / frozen_params, call ``generate_artifacts`` with AdamW, and assert the four training
+artifacts are produced. An extended check loads them via ``Module``/``Optimizer`` and runs one
+train step, asserting a finite loss.
+
+Run:  uv run --python 3.12 --group ort-training-local --no-default-groups \
+          pytest tests/integration/test_ort_training_smoke.py -q
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import onnx
+import pytest
+
+pytest.importorskip("torch", reason="ort-training-local profile only")
+ort_artifacts = pytest.importorskip(
+    "onnxruntime.training.artifacts", reason="ort-training-local profile only"
+)
+
+FIXTURE_DIR = Path(__file__).parent.parent / "fixtures"
+MODEL_PATH = FIXTURE_DIR / "tiny_trainable.onnx"
+CONFIG_PATH = FIXTURE_DIR / "training_config.json"
+
+ARTIFACT_NAMES = ("training_model.onnx", "eval_model.onnx", "optimizer_model.onnx", "checkpoint")
+
+
+def _split_initializers() -> tuple[list[str], list[str]]:
+    """Reproduce gen_artifacts' requires_grad / frozen split from the fixture + config."""
+    model = onnx.load(str(MODEL_PATH))
+    config = json.loads(CONFIG_PATH.read_text())
+    requires_grad, frozen = [], []
+    for init in model.graph.initializer:
+        if any(sub in init.name for sub in config["requires_grad"]):
+            requires_grad.append(init.name)
+        else:
+            frozen.append(init.name)
+    return requires_grad, frozen
+
+
+def test_generate_artifacts_produces_four_outputs(tmp_path):
+    requires_grad, frozen = _split_initializers()
+    assert requires_grad, "fixture must have at least one trainable initializer"
+
+    ort_artifacts.generate_artifacts(
+        str(MODEL_PATH),
+        requires_grad=requires_grad,
+        frozen_params=frozen,
+        optimizer=ort_artifacts.OptimType.AdamW,
+        artifact_directory=str(tmp_path),
+    )
+
+    for name in ARTIFACT_NAMES:
+        produced = tmp_path / name
+        assert produced.exists(), f"generate_artifacts did not produce {name}"
+
+
+def test_one_train_step_finite_loss(tmp_path):
+    from onnxruntime.training.api import CheckpointState, Module, Optimizer
+
+    requires_grad, frozen = _split_initializers()
+    ort_artifacts.generate_artifacts(
+        str(MODEL_PATH),
+        requires_grad=requires_grad,
+        frozen_params=frozen,
+        optimizer=ort_artifacts.OptimType.AdamW,
+        artifact_directory=str(tmp_path),
+    )
+
+    state = CheckpointState.load_checkpoint(str(tmp_path / "checkpoint"))
+    model = Module(str(tmp_path / "training_model.onnx"), state, str(tmp_path / "eval_model.onnx"))
+    optimizer = Optimizer(str(tmp_path / "optimizer_model.onnx"), model)
+
+    x = np.random.default_rng(0).standard_normal((2, 4)).astype(np.float32)
+    model.train()
+    loss = model(x)
+    optimizer.step()
+    model.lazy_reset_grad()
+
+    # Module returns a bare scalar (single 0-d output) or a list of outputs — handle both.
+    loss_arr = loss[0] if isinstance(loss, (list, tuple)) else loss
+    loss_value = float(np.asarray(loss_arr).reshape(-1)[0])
+    assert np.isfinite(loss_value), f"loss not finite: {loss_value}"
diff --git a/tests/integration/test_training_stage_smoke.py b/tests/integration/test_training_stage_smoke.py
new file mode 100644
index 0000000..6cbc329
--- /dev/null
+++ b/tests/integration/test_training_stage_smoke.py
@@ -0,0 +1,52 @@
+"""#15 training-stage smoke (ort-training-local profile): the `gen_artifacts` leg the training stage wires.
+
+Skips unless ``onnxruntime.training`` imports, so it only runs in the ``ort-training-local`` profile
+(Python 3.12). This is the automated-under-profile leg of `export/pipeline.py::_build_training_stage`
+step 2 — it drives `artifacts.builder::gen_artifacts` over the committed tiny fixture and asserts
+the four training artifacts + the extended training_config (with the peft_mapping the trainable-split
+step consumes). Step 1 (`optimum_hf_export`, a real HF model) and step 3 (`export_inference_package`,
+already core-tested) are the manual `make device-package` / #9-package legs.
+
+Run:  uv run --python 3.12 --group ort-training-local --no-default-groups \
+          pytest tests/integration/test_training_stage_smoke.py -q
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("torch", reason="ort-training-local profile only")
+pytest.importorskip("onnxruntime.training.artifacts", reason="ort-training-local profile only")
+
+FIXTURE_DIR = Path(__file__).parent.parent / "fixtures"
+
+
+def test_gen_artifacts_produces_training_artifacts_and_extended_config(tmp_path):
+    from mobiletransformers.artifacts.builder import gen_artifacts
+
+    # gen_artifacts reads <train_dir>/quant_model.onnx + training_config.json (the shape #15 step 1 writes).
+    train_dir = tmp_path / "train_export"
+    train_dir.mkdir()
+    shutil.copy(FIXTURE_DIR / "tiny_trainable.onnx", train_dir / "quant_model.onnx")
+    shutil.copy(FIXTURE_DIR / "training_config.json", train_dir / "training_config.json")
+
+    artifact_dir = tmp_path / "train"
+    extended = gen_artifacts(
+        train_dir=str(train_dir),
+        artifact_dir=str(artifact_dir),
+        model_name="quant_model.onnx",
+        training_config={},
+    )
+
+    for name in ("training_model.onnx", "eval_model.onnx", "optimizer_model.onnx"):
+        assert (artifact_dir / name).is_file(), f"missing {name}"
+    assert (artifact_dir / "checkpoint").exists()
+
+    # The extended config carries the peft_mapping the trainable split (step 3) consumes.
+    assert extended["peft_mapping"] == {"linear.weight": "linear.weight"}
+    on_disk = json.loads((artifact_dir / "training_config.json").read_text())
+    assert on_disk["peft_mapping"] == extended["peft_mapping"]
diff --git a/tests/support/__init__.py b/tests/support/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/support/test_render.py b/tests/support/test_render.py
new file mode 100644
index 0000000..294edd2
--- /dev/null
+++ b/tests/support/test_render.py
@@ -0,0 +1,34 @@
+"""#31 compatibility-matrix renderer + committed-doc drift guard (core env; no torch/optimum)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mobiletransformers.config.constants import MergerVariant, PEFTMethod, QuantizationType
+from mobiletransformers.support.render import render_matrix_markdown
+from tests.fixtures.gen_compat_matrix_doc import build_sample_matrix
+
+
+def _docs_path() -> Path:
+    return Path(__file__).resolve().parents[2] / "docs" / "COMPATIBILITY_MATRIX.md"
+
+
+def test_render_has_headers_axes_and_rows():
+    md = render_matrix_markdown(build_sample_matrix())
+    assert md.startswith("# Compatibility Matrix")
+    # Axes enumerated from the enums (no drift): every enum value appears in the legend.
+    for member in (*PEFTMethod, *QuantizationType, *MergerVariant):
+        assert member.value in md
+    # Every sample model + its blocker/evidence renders.
+    assert "HuggingFaceTB/SmolLM2-135M" in md
+    assert "MARS/PEFT target modules not verified for this architecture" in md
+    assert "no android probe recorded for android_inference_ready" in md
+
+
+def test_committed_doc_matches_render():
+    # F6: the doc is rendered, not hand-edited. Re-render the sample and assert the committed copy
+    # matches, so an edit to the renderer/enums that changes the doc fails CI until regenerated
+    # (`python tests/fixtures/gen_compat_matrix_doc.py`).
+    expected = render_matrix_markdown(build_sample_matrix())
+    committed = _docs_path().read_text(encoding="utf-8")
+    assert committed == expected, "COMPATIBILITY_MATRIX.md is stale; regenerate with gen_compat_matrix_doc.py"
diff --git a/tests/support/test_support_matrix.py b/tests/support/test_support_matrix.py
new file mode 100644
index 0000000..7370f7b
--- /dev/null
+++ b/tests/support/test_support_matrix.py
@@ -0,0 +1,159 @@
+"""#20 support matrix: inheritance, detection (mocked), probe merge, JSON shape, filtered docs, CLI."""
+
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+from mobiletransformers.support.matrix import build_matrix, detect_candidate, evaluate_statuses
+from mobiletransformers.support.models import CandidateEntry
+from mobiletransformers.support.statuses import (
+    STATUS_ORDER,
+    USER_FACING_STATUSES,
+    apply_inheritance,
+    first_blocked,
+)
+
+# --- inheritance ------------------------------------------------------------
+
+
+def test_apply_inheritance_zeros_after_first_false():
+    got = apply_inheritance(
+        {
+            "optimum_exportable": True,
+            "mobile_package_exportable": True,
+            "train_artifacts_exportable": False,
+            "android_inference_ready": True,  # must be forced false
+            "rag_ready": True,
+        }
+    )
+    assert got["train_artifacts_exportable"] is False
+    assert got["android_inference_ready"] is False
+    assert got["android_training_ready"] is False
+    assert got["rag_ready"] is False
+    assert list(got.keys()) == list(STATUS_ORDER)
+
+
+def test_first_blocked():
+    assert first_blocked({k: True for k in STATUS_ORDER}) is None
+    assert first_blocked({"optimum_exportable": False}) == "optimum_exportable"
+
+
+# --- detection (mocked, no network) ----------------------------------------
+
+
+def _loader(model_type, architectures):
+    return lambda mid, trc: SimpleNamespace(model_type=model_type, architectures=architectures)
+
+
+def test_detect_supported_llama():
+    entry = detect_candidate(
+        "org/llama",
+        config_loader=_loader("llama", ["LlamaForCausalLM"]),
+        tasks_lookup=lambda mt: ["text-generation", "text-generation-with-past"],
+        versions={"optimumOnnxVersion": "0.1.0", "transformersVersion": "4.46.2"},
+    )
+    assert entry.selected_task == "text-generation-with-past"
+    assert entry.mars_target_modules_known is True  # LlamaForCausalLM is in the registry
+
+
+def test_detect_unsupported_task_sets_no_selected():
+    entry = detect_candidate(
+        "org/weird",
+        config_loader=_loader("weird", ["WeirdModel"]),
+        tasks_lookup=lambda mt: [],
+        versions={},
+    )
+    assert entry.selected_task is None
+    assert entry.mars_target_modules_known is False
+
+
+# --- status evaluation + probe merge ---------------------------------------
+
+
+def test_evaluate_no_probe_leaves_ready_false_with_blocker():
+    entry = CandidateEntry(
+        model_id="org/llama",
+        architectures=("LlamaForCausalLM",),
+        selected_task="text-generation-with-past",
+        mars_target_modules_known=True,
+    )
+    evaluate_statuses(entry, probe=None)
+    assert entry.statuses["train_artifacts_exportable"] is True
+    assert entry.statuses["android_inference_ready"] is False
+    assert any("android probe" in b for b in entry.blockers)
+
+
+def test_evaluate_with_full_probe_promotes_ready():
+    entry = CandidateEntry(
+        model_id="org/llama",
+        architectures=("LlamaForCausalLM",),
+        selected_task="text-generation-with-past",
+        mars_target_modules_known=True,
+    )
+    evaluate_statuses(entry, probe={"inferenceOk": True, "trainStepOk": True, "mergeOk": True, "ragOk": True})
+    assert all(entry.statuses[s] for s in STATUS_ORDER)
+    assert entry.blockers == []
+
+
+def test_unexportable_forces_everything_false():
+    entry = CandidateEntry(model_id="org/x", selected_task=None)
+    evaluate_statuses(entry, probe={"inferenceOk": True})
+    assert not any(entry.statuses.values())
+    assert first_blocked(entry.statuses) == "optimum_exportable"
+
+
+# --- build_matrix + JSON shape + filtered docs -----------------------------
+
+
+def test_build_matrix_json_shape_and_filtered(tmp_path):
+    probes = tmp_path / "android_probes.json"
+    probes.write_text(
+        json.dumps({"org/llama": {"inferenceOk": True, "trainStepOk": True, "mergeOk": True, "ragOk": False}})
+    )
+    matrix = build_matrix(
+        [{"modelId": "org/llama"}, {"modelId": "org/x"}],
+        probes_path=probes,
+        generated_at="2026-07-14T00:00:00Z",
+        config_loader=lambda mid, trc: SimpleNamespace(
+            model_type="llama" if mid == "org/llama" else "weird",
+            architectures=["LlamaForCausalLM"] if mid == "org/llama" else ["WeirdModel"],
+        ),
+        tasks_lookup=lambda mt: ["text-generation-with-past"] if mt == "llama" else [],
+        versions={"optimumOnnxVersion": "0.1.0", "transformersVersion": "4.46.2"},
+    )
+    d = matrix.to_dict()
+    assert d["statusOrder"] == list(STATUS_ORDER)
+    assert {m["modelId"] for m in d["models"]} == {"org/llama", "org/x"}
+    llama = next(m for m in d["models"] if m["modelId"] == "org/llama")
+    assert llama["statuses"]["android_inference_ready"] is True
+    assert llama["statuses"]["rag_ready"] is False  # ragOk was false
+    # filtered docs: org/x (no user-facing true) dropped; contributor-only statuses stripped.
+    filt = matrix.filtered_docs_dict()
+    assert {m["modelId"] for m in filt["models"]} == {"org/llama"}
+    assert set(filt["models"][0]["statuses"]) == set(USER_FACING_STATUSES)
+
+
+def test_support_matrix_cli_smoke(tmp_path, monkeypatch):
+    # Drive the CLI with an injected build via a candidates file + mocked detection through monkeypatch.
+    import mobiletransformers.support.matrix as mtx
+
+    monkeypatch.setattr(
+        mtx,
+        "_default_config_loader",
+        lambda mid, trc: SimpleNamespace(model_type="llama", architectures=["LlamaForCausalLM"]),
+    )
+    monkeypatch.setattr(mtx, "_default_tasks_lookup", lambda mt: ["text-generation-with-past"])
+    monkeypatch.setattr(
+        mtx, "_default_versions", lambda: {"optimumOnnxVersion": "0.1.0", "transformersVersion": "4.46.2"}
+    )
+
+    from mobiletransformers.cli.main import main
+
+    cands = tmp_path / "cands.json"
+    cands.write_text(json.dumps(["org/llama"]))
+    out = tmp_path / "matrix.json"
+    code = main(["support-matrix", "--candidates", str(cands), "--out", str(out)])
+    assert code == 0
+    written = json.loads(out.read_text())
+    assert written["models"][0]["modelId"] == "org/llama"
diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/unit/test_architecture_head_resolution.py b/tests/unit/test_architecture_head_resolution.py
new file mode 100644
index 0000000..d8f054b
--- /dev/null
+++ b/tests/unit/test_architecture_head_resolution.py
@@ -0,0 +1,73 @@
+"""The architecture registry keys on the loaded class, not the checkpoint's declared architecture (#33).
+
+`config.architectures` describes the **checkpoint**. A sentence-transformers encoder declares
+`["BertModel"]` even when loaded through `AutoModelForSequenceClassification` as a
+`BertForSequenceClassification` — so resolving from the config alone sends an encoder fine-tune to the
+un-headed, untrainable row. The head is part of the architecture identity.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.config.constants import TaskType
+from mobiletransformers.config.registry.architecture import (
+    ARCHITECTURE_REGISTRY,
+    resolve_architecture,
+)
+from mobiletransformers.exceptions import UnsupportedModelError
+
+
+class _Config:
+    """Stands in for a HF config; only `architectures` is read."""
+
+    def __init__(self, architectures):
+        self.architectures = architectures
+
+
+def test_config_lookup_is_unchanged_when_no_override_is_given():
+    assert resolve_architecture(_Config(["LlamaForCausalLM"])).architecture == "LlamaForCausalLM"
+
+
+def test_loaded_class_overrides_the_checkpoints_declared_architecture():
+    """The #33 case: same config, different head, different row."""
+    config = _Config(["BertModel"])
+
+    assert resolve_architecture(config).task is TaskType.FEATURE_EXTRACTION
+    resolved = resolve_architecture(config, architecture="BertForSequenceClassification")
+    assert resolved.architecture == "BertForSequenceClassification"
+    assert resolved.task is TaskType.SEQUENCE_CLASSIFICATION
+
+
+def test_override_still_fails_closed_on_an_unknown_head():
+    with pytest.raises(UnsupportedModelError, match="ElectraForSequenceClassification"):
+        resolve_architecture(_Config(["BertModel"]), architecture="ElectraForSequenceClassification")
+
+
+def test_decoder_rows_agree_with_what_automodel_would_load():
+    """For every decoder the loaded class name IS `architectures[0]`, so the override is a no-op.
+
+    This is what makes passing `type(model).__name__` strictly more accurate rather than a behaviour
+    change for the paths that already worked.
+    """
+    for name, spec in ARCHITECTURE_REGISTRY.items():
+        if spec.task is not TaskType.TEXT_GENERATION:
+            continue
+        assert resolve_architecture(_Config([name]), architecture=name) is spec
+
+
+@pytest.mark.parametrize(
+    ("architecture", "expected"),
+    [
+        ("BertForSequenceClassification", ("query", "value")),
+        ("RobertaForSequenceClassification", ("query", "value")),
+        # DistilBERT names its projections differently — the per-architecture difference the registry
+        # exists to hold as data rather than as a branch.
+        ("DistilBertForSequenceClassification", ("q_lin", "v_lin")),
+    ],
+)
+def test_encoder_rows_carry_their_own_projection_names(architecture, expected):
+    spec = ARCHITECTURE_REGISTRY[architecture]
+    assert spec.target_modules == expected
+    assert spec.attention_module_name == "attention"
+    assert spec.task is TaskType.SEQUENCE_CLASSIFICATION
diff --git a/tests/unit/test_checkpoint_names.py b/tests/unit/test_checkpoint_names.py
new file mode 100644
index 0000000..47a9802
--- /dev/null
+++ b/tests/unit/test_checkpoint_names.py
@@ -0,0 +1,157 @@
+"""The export-time merge-contract check (`artifacts/checkpoint_names.py`).
+
+Each test here encodes a defect that reached a device because nothing verified, on the host, that the
+names the handoff map publishes are names the checkpoint actually contains.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from mobiletransformers.artifacts.checkpoint_names import (
+    checkpoint_weight_param,
+    to_checkpoint_name,
+    verify_handoff_names_resolve,
+    with_base_layer,
+)
+from mobiletransformers.exceptions import ExportError
+
+RAW = "base_model.model.model.layers.9.self_attn.q_proj"
+CHECKPOINT_PARAM = "backbone.model.layers.9.self_attn.q_proj.base_layer.weight"
+
+
+def _write_map(tmp_path, training_names):
+    path = tmp_path / "weight_handoff_map.json"
+    path.write_text(
+        json.dumps(
+            {
+                "entries": [
+                    {"inferenceName": f"t{i}", "trainingBaseLayerName": n}
+                    for i, n in enumerate(training_names)
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    return path
+
+
+def _write_checkpoint(tmp_path, param_names):
+    """A stand-in for the ORT flatbuffer: names appear as plain UTF-8, which is all the check reads."""
+    path = tmp_path / "checkpoint"
+    path.write_bytes(b"\x00\x11flatbufferish\x00" + b"\x00".join(n.encode() for n in param_names))
+    return path
+
+
+def test_name_derivation_matches_the_cpp_twin():
+    assert to_checkpoint_name(RAW) == "backbone.model.layers.9.self_attn.q_proj"
+    assert checkpoint_weight_param(RAW) == CHECKPOINT_PARAM
+
+
+def test_base_layer_suffix_is_idempotent():
+    """The map records `trainingBaseLayerName` WITH the suffix; doubling it misses as surely as omitting."""
+    once = with_base_layer(RAW)
+    assert with_base_layer(once) == once
+    assert checkpoint_weight_param(once) == CHECKPOINT_PARAM
+
+
+def test_passes_when_every_name_resolves(tmp_path):
+    handoff = _write_map(tmp_path, [RAW])
+    adapter = "backbone.model.layers.9.self_attn.q_proj.lora_A.lora.weight"
+    ckpt = _write_checkpoint(tmp_path, [CHECKPOINT_PARAM, adapter])
+
+    assert verify_handoff_names_resolve(handoff, ckpt) == [CHECKPOINT_PARAM]
+
+
+def test_catches_the_missing_base_layer_defect(tmp_path):
+    """The real bug: the merger asked for `<layer>.weight`; peft stores `<layer>.base_layer.weight`.
+
+    A checkpoint holding only the un-suffixed name must fail the check — that package's merge would
+    find no base weight for any layer.
+    """
+    handoff = _write_map(tmp_path, [RAW])
+    ckpt = _write_checkpoint(tmp_path, ["backbone.model.layers.9.self_attn.q_proj.weight"])
+
+    with pytest.raises(ExportError, match="does not exist"):
+        verify_handoff_names_resolve(handoff, ckpt)
+
+
+def test_catches_a_wrong_prefix(tmp_path):
+    """The other half: a checkpoint keyed with peft's raw wrapper rather than ORT's `backbone.`."""
+    handoff = _write_map(tmp_path, [RAW])
+    ckpt = _write_checkpoint(tmp_path, [RAW + ".base_layer.weight"])
+
+    with pytest.raises(ExportError, match="name-shape disagreement"):
+        verify_handoff_names_resolve(handoff, ckpt)
+
+
+def test_error_names_the_offenders_and_counts_them(tmp_path):
+    handoff = _write_map(tmp_path, [f"base_model.model.model.layers.{i}.self_attn.q_proj" for i in range(9)])
+    ckpt = _write_checkpoint(tmp_path, ["unrelated"])
+
+    with pytest.raises(ExportError) as excinfo:
+        verify_handoff_names_resolve(handoff, ckpt)
+    message = str(excinfo.value)
+    assert "9 of 9" in message
+    assert "and 4 more" in message  # 5 shown, the rest summarised
+
+
+def test_empty_map_fails_closed(tmp_path):
+    """An empty map means nothing can be merged; publishing it as train-capable is a lie."""
+    handoff = _write_map(tmp_path, [])
+    ckpt = _write_checkpoint(tmp_path, [CHECKPOINT_PARAM])
+
+    with pytest.raises(ExportError, match="no entries"):
+        verify_handoff_names_resolve(handoff, ckpt)
+
+
+def test_missing_checkpoint_fails_closed(tmp_path):
+    handoff = _write_map(tmp_path, [RAW])
+
+    with pytest.raises(ExportError, match="checkpoint not found"):
+        verify_handoff_names_resolve(handoff, tmp_path / "absent")
+
+
+def test_entry_without_a_training_name_is_reported(tmp_path):
+    path = tmp_path / "weight_handoff_map.json"
+    path.write_text(json.dumps({"entries": [{"inferenceName": "t0"}]}), encoding="utf-8")
+    ckpt = _write_checkpoint(tmp_path, [CHECKPOINT_PARAM])
+
+    with pytest.raises(ExportError, match="no trainingBaseLayerName"):
+        verify_handoff_names_resolve(path, ckpt)
+
+
+# --- the encoder namespace (#33) --------------------------------------------
+
+#: Real names, taken from an `all-MiniLM-L6-v2` LoRA export + its ORT checkpoint (2026-08-10).
+ENCODER_RAW = "base_model.model.bert.encoder.layer.0.attention.self.query"
+ENCODER_PARAM = "backbone.bert.encoder.layer.0.attention.self.query.base_layer.weight"
+
+
+def test_the_rule_is_the_wrapper_pair_not_a_decoders_module_path():
+    """`base_model.model.` -> `backbone.`, whatever the model's own first module is.
+
+    Written as `base_model.model.model.` -> `backbone.model.` it is the same rule with a DECODER's
+    `model.layers…` baked in: identical output for every decoder, and a no-op for an encoder. The #33
+    encoder export failed closed on exactly that — 12/12 handoff entries naming
+    `base_model.model.bert.…base_layer.weight` against a checkpoint holding `backbone.bert.…`.
+    """
+    assert to_checkpoint_name(ENCODER_RAW) == "backbone.bert.encoder.layer.0.attention.self.query"
+    assert checkpoint_weight_param(ENCODER_RAW) == ENCODER_PARAM
+    # ... and the decoder mapping is byte-identical to what the narrower rule produced.
+    assert to_checkpoint_name(RAW) == "backbone.model.layers.9.self_attn.q_proj"
+
+
+def test_encoder_names_resolve_end_to_end(tmp_path):
+    handoff = _write_map(tmp_path, [ENCODER_RAW])
+    ckpt = _write_checkpoint(tmp_path, [ENCODER_PARAM])
+
+    assert verify_handoff_names_resolve(handoff, ckpt) == [ENCODER_PARAM]
+
+
+def test_an_unwrapped_name_is_left_alone():
+    """Only the peft wrapper is rewritten; a name already in checkpoint space must not be re-prefixed."""
+    already = "backbone.bert.encoder.layer.0.attention.self.query"
+    assert to_checkpoint_name(already) == already
diff --git a/tests/unit/test_config_models.py b/tests/unit/test_config_models.py
new file mode 100644
index 0000000..fe388ae
--- /dev/null
+++ b/tests/unit/test_config_models.py
@@ -0,0 +1,57 @@
+"""Typed config models: round-trip stability, discriminated union, and fail-closed parsing."""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from mobiletransformers.config.models import (
+    CROSS_BOUNDARY_MODELS,
+    CosineScheduler,
+    GenerationConfig,
+    LinearScheduler,
+    TrainingConfig,
+)
+
+
+@pytest.mark.parametrize("name,model", list(CROSS_BOUNDARY_MODELS.items()))
+def test_round_trip_is_byte_stable(name, model):
+    dumped = model().model_dump(by_alias=True, mode="json")
+    reparsed = model.model_validate(dumped).model_dump(by_alias=True, mode="json")
+    assert reparsed == dumped
+
+
+@pytest.mark.parametrize("name,model", list(CROSS_BOUNDARY_MODELS.items()))
+def test_version_block_present(name, model):
+    dumped = model().model_dump(by_alias=True, mode="json")
+    assert dumped["schemaVersion"] == "1.0"
+    assert dumped["minReaderVersion"] == "1.0"
+
+
+def test_scheduler_union_selects_by_wire_tag():
+    linear = TrainingConfig(scheduler=LinearScheduler()).model_dump(by_alias=True, mode="json")
+    cosine = TrainingConfig(scheduler=CosineScheduler()).model_dump(by_alias=True, mode="json")
+    assert linear["scheduler"]["schedulerType"] == "linear"
+    assert cosine["scheduler"]["schedulerType"] == "cosine"
+    assert isinstance(TrainingConfig.model_validate(cosine).scheduler, CosineScheduler)
+    assert isinstance(TrainingConfig.model_validate(linear).scheduler, LinearScheduler)
+
+
+def test_unknown_field_tolerated():
+    dumped = GenerationConfig().model_dump(by_alias=True, mode="json")
+    # additive minor bumps must not break older readers (extra="ignore")
+    GenerationConfig.model_validate({**dumped, "someFutureField": 123})
+
+
+def test_unknown_enum_value_fails_closed():
+    dumped = GenerationConfig().model_dump(by_alias=True, mode="json")
+    dumped["sampling"]["method"] = "definitely-not-a-method"
+    with pytest.raises(ValidationError):
+        GenerationConfig.model_validate(dumped)
+
+
+def test_camelcase_aliases_on_wire():
+    dumped = GenerationConfig().model_dump(by_alias=True, mode="json")
+    assert "maxSequenceLength" in dumped
+    assert "deviceOptions" in dumped
+    assert dumped["sampling"]["topK"] == 10  # alias, not top_k
diff --git a/tests/unit/test_dependency_profiles.py b/tests/unit/test_dependency_profiles.py
new file mode 100644
index 0000000..222296d
--- /dev/null
+++ b/tests/unit/test_dependency_profiles.py
@@ -0,0 +1,116 @@
+"""Profile-fork invariants (#2/#3, and #37's unblocking).
+
+The pins in `pyproject.toml` are two different KINDS of thing that look identical:
+
+* **upstream ceilings** — `optimum~=2.1.0`, `transformers<4.58`. Not ours; fighting them fails to
+  install. They are recorded in IMPLEMENTATION_ORDER's "Upstream version ceilings" table.
+* **paired-stack reproductions** — `torch==2.7.1`, `peft==0.13.2`, `transformers==4.46.2`,
+  `numpy<2` in `ort-training-local`. These reproduce the environment the source-built ORT-training
+  wheel was compiled against (`third_party/onnxruntime/manifest.json`). They may be forked per
+  profile, but never floated inside that group.
+
+Confusing the two costs a cycle in either direction: "the pins are stale, bump them" breaks
+`get_peft_model`, and "the pins are untouchable" left #37 unable to load Gemma-3 at all. These tests
+pin the distinction so the lock cannot silently collapse the fork back onto one version.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+#: Raw text, not a TOML parse: `tomllib` is 3.11+ and the dev/CI profile floors at 3.10. The rest of
+#: the guard tests (`test_version_sites`, `test_gate_ratchet`) read pyproject the same way.
+PYPROJECT = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
+
+
+def _requirement(block_pattern: str, package: str) -> str | None:
+    """The requirement string for `package` inside the first line matching `block_pattern`."""
+    block = re.search(block_pattern, PYPROJECT, re.MULTILINE)
+    if block is None:
+        return None
+    found = re.search(rf'"({re.escape(package)}[^"]*)"', block.group(0))
+    return found.group(1) if found else None
+
+
+def test_the_abi_coupled_pins_stay_exact() -> None:
+    """The paired-stack pins that are REAL constraints must never float.
+
+    These four are ABI/format couplings to the source-built ORT-training wheel, and manifest.json's
+    notes call them out as such:
+
+    * ``torch==2.7.1`` / ``peft==0.13.2`` — floating peft to 0.19 renamed
+      ``PEFT_TYPE_TO_MODEL_MAPPING`` and required ``torch.distributed.tensor`` (torch>=2.8), so
+      ``get_peft_model`` died with ``AttributeError``.
+    * ``numpy<2`` — the C extension is built against the numpy 1.26 ABI.
+    * ``onnx<1.19`` — ORT 1.23 supports max ONNX IR 11; onnx>=1.19 emits IR 13.
+
+    ``transformers`` is deliberately NOT in this list. It is the one paired_stack entry with no ABI
+    relationship to the wheel — pure Python — and it was raised off ``==4.46.2`` on 2026-08-15 after
+    three controls (llama decoder, BERT encoder, gemma3) came back identical or better. Confusing
+    "recorded in paired_stack" with "load-bearing" is what kept Gemma-3 training blocked for months
+    behind a pin that was never the cause.
+    """
+    for requirement in ("torch==2.7.1", "peft==0.13.2"):
+        assert f'"{requirement}"' in PYPROJECT, (
+            f"{requirement} is an ABI coupling to the source-built ORT wheel and must stay exact"
+        )
+    for requirement in ("numpy<2", "onnx<1.19"):
+        assert f"\"{requirement}; python_version == '3.12'\"" in PYPROJECT, (
+            f"{requirement} is a runtime constraint of the ORT extension and must stay pinned"
+        )
+
+
+def test_training_can_resolve_a_gemma3_capable_transformers() -> None:
+    """The training profile must be able to LOAD Gemma-3, or it cannot export a graph for it.
+
+    ``transformers`` below 4.50 has no ``Gemma3ForCausalLM``, no ``Gemma3Config`` and no ``gemma3`` row
+    in ``CONFIG_MAPPING_NAMES``, so ``AutoModelForCausalLM.from_pretrained`` fails before any question
+    about the exported graph arises. This is the floor that makes
+    ``mobiletransformers/functiongemma-270m-it`` buildable at all.
+
+    Asserted as a FLOOR, not an exact version: the point is the capability, not a particular release.
+    """
+    training = _requirement(r'^\s*"transformers>=[^"]*",\s*$', "transformers")
+    assert training is not None, "no transformers requirement in ort-training-local"
+    assert ">=4.50" in training, (
+        f"the training profile must floor transformers at 4.50 to load Gemma-3, got {training!r}"
+    )
+    # A REQUIREMENT line, not a mention: the pin's history is written in the comment right above it,
+    # and a substring search for "==4.46.2" matches that prose too.
+    assert not re.search(r'^\s*"transformers==', PYPROJECT, re.MULTILINE), (
+        "an exact transformers== pin is back in pyproject — 4.46.2 cannot load Gemma-3 at all, and it "
+        "was removed with evidence (three controls) rather than by guess"
+    )
+
+
+def test_upstream_ceiling_is_preserved() -> None:
+    """`<4.58` is optimum-onnx 0.1.0's own declared bound, not a project preference."""
+    export = _requirement(r"^export\s*=\s*\[.*$", "transformers")
+    assert export is not None and "<4.58" in export
+
+
+def test_lock_carries_a_gemma3_capable_transformers() -> None:
+    """The resolved lock must actually contain a transformers that can load Gemma-3.
+
+    This test used to assert the OPPOSITE — that the lock carried both 4.46.2 and a newer line, proving
+    the export/training fork survived `uv lock`. That fork was retired on 2026-08-15 when the training
+    profile adopted the same range, so a single version now satisfies both and the lock holds one. The
+    invariant worth guarding is the capability, not the split.
+    """
+    lock = (REPO_ROOT / "uv.lock").read_text()
+    versions = set()
+    for block in lock.split("[[package]]"):
+        if re.search(r'^name = "transformers"', block, re.MULTILINE):
+            versions.update(re.findall(r'^version = "([^"]+)"', block, re.MULTILINE))
+
+    assert versions, "no transformers in the lock at all"
+
+    def _parts(version: str) -> tuple[int, ...]:
+        return tuple(int(p) for p in re.findall(r"\d+", version)[:2])
+
+    assert any(_parts(v) >= (4, 50) for v in versions), (
+        f"the lock holds no transformers >= 4.50, so Gemma-3 cannot be loaded; found {sorted(versions)}"
+    )
diff --git a/tests/unit/test_docs.py b/tests/unit/test_docs.py
new file mode 100644
index 0000000..f1c1f35
--- /dev/null
+++ b/tests/unit/test_docs.py
@@ -0,0 +1,314 @@
+"""Docs guards: relative links resolve, and pages don't drift out of sync with the code.
+
+`docs/RAG.md` claimed #26/#27 were "not yet implemented" long after they landed, and
+`docs/PUBLIC_API.md`'s CLI table omitted a registered subcommand. Both are the kind of drift a test
+catches for free.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DOCS = REPO_ROOT / "docs"
+MARKDOWN = sorted(DOCS.glob("*.md")) + [REPO_ROOT / "README.md", REPO_ROOT / "CHANGELOG.md"]
+
+#: EVERY tracked markdown file.
+#:
+#: The link check used to cover `docs/` + README + CHANGELOG only, and was widened in 2026-08-14 to
+#: every tracked page after the review found the worst reference rot in `agent_docs/`. That directory
+#: was untracked on 2026-08-17, so it now falls out of this scan by the same `git ls-files` rule that
+#: excludes build output — deliberately, and worth stating: the shipped docs are what this gate is
+#: for, and the planning material is no longer part of the repo's public surface.
+#:
+#: Deliberately relative links only. Checking external URLs needs the network, goes red for reasons
+#: outside this repo, and would make the one gate that always runs the flakiest one.
+#:
+#: Enumerated with `git ls-files` rather than `rglob` + an exclude list. An `rglob` sweep reported 8
+#: "broken" pages that were all vendored nlohmann/json docs under `.cxx/_deps/` — build output whose
+#: links are not ours to fix — and every new vendored dependency would have needed another exclusion.
+#: Tracked-files-only is self-maintaining: anything gitignored is out by construction.
+
+
+def _tracked_markdown() -> list[Path]:
+    import subprocess
+
+    result = subprocess.run(
+        ["git", "ls-files", "*.md"], cwd=REPO_ROOT, capture_output=True, text=True, check=False
+    )
+    if result.returncode != 0:
+        return []
+    return sorted(REPO_ROOT / line for line in result.stdout.split() if (REPO_ROOT / line).is_file())
+
+
+_LINK = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+
+
+def _broken_links(page: Path) -> list[str]:
+    broken = []
+    for match in _LINK.finditer(page.read_text(encoding="utf-8", errors="replace")):
+        target = match.group(2)
+        if target.startswith(("http://", "https://", "#", "mailto:")):
+            continue
+        path = target.partition("#")[0]
+        if path and not (page.parent / path).resolve().exists():
+            broken.append(f"[{match.group(1)}]({target})")
+    return broken
+
+
+@pytest.mark.parametrize("page", MARKDOWN, ids=lambda p: p.name)
+def test_relative_links_resolve(page: Path) -> None:
+    assert not _broken_links(page), f"{page.name}: broken relative link(s): {_broken_links(page)}"
+
+
+def test_no_tracked_markdown_links_to_a_missing_file() -> None:
+    """The repo-wide sweep, reported in one place so a rename shows every page it broke at once."""
+    pages = _tracked_markdown()
+    if not pages:
+        pytest.skip("git not available or not a checkout")
+    # Vacuity floor: this sweep is only meaningful if it is actually seeing the repo, and a `git
+    # ls-files` that returns nothing useful would otherwise pass silently. Lowered from 50 to 20 on
+    # 2026-08-17 when `agent_docs/` (52 tracked pages) was untracked — re-pointed rather than deleted,
+    # because the assertion still does its job at the new size (30 pages today).
+    assert len(pages) > 20, f"only {len(pages)} markdown files found — the sweep is not seeing the repo"
+
+    broken = {str(page.relative_to(REPO_ROOT)): links for page in pages if (links := _broken_links(page))}
+    assert not broken, (
+        "markdown link(s) pointing at files that do not exist — a renamed or deleted file leaves "
+        f"these behind silently:\n{broken}"
+    )
+
+
+def test_cli_table_lists_every_registered_subcommand() -> None:
+    """`federated` was registered in the parser but missing from the documented table."""
+    from mobiletransformers.cli.main import build_parser
+
+    parser = build_parser()
+    registered = {
+        name
+        for action in parser._subparsers._group_actions  # noqa: SLF001 - argparse has no public API
+        for name in action.choices
+    }
+    documented = (DOCS / "PUBLIC_API.md").read_text(encoding="utf-8")
+    missing = sorted(cmd for cmd in registered if f"`{cmd}`" not in documented)
+    assert not missing, f"docs/PUBLIC_API.md does not document: {missing}"
+
+
+#: Kotlin sources for the public facade. The internal packages are deliberately excluded — the point is
+#: to prove the *documented* surface exists, not to inventory everything under the namespace.
+_KOTLIN_FACADE_ROOT = (
+    REPO_ROOT
+    / "android"
+    / "MobileTransformers"
+    / "MobileTransformers"
+    / "src"
+    / "main"
+    / "java"
+    / "com"
+    / "martinkorelic"
+    / "mobiletransformers"
+)
+
+_KOTLIN_DECL = re.compile(
+    r"\b(?:data class|sealed class|enum class|value class|abstract class|open class|class|interface|"
+    r"fun interface|object)\s+([A-Z][A-Za-z0-9_]*)"
+)
+
+#: UpperCamelCase enum ENTRIES (`ModelFeature.Inference`), which are not declarations but which the
+#: docs legitimately name. The existing SCREAMING_CASE carve-out does not reach them.
+_KOTLIN_ENUM_BODY = re.compile(r"\benum class\s+[A-Z][A-Za-z0-9_]*[^{]*\{(.*?)(?:\n\s*;|\n\})", re.DOTALL)
+_KOTLIN_ENUM_ENTRY = re.compile(r"^\s*([A-Z][A-Za-z0-9_]*)\s*(?:\(|,|$)", re.MULTILINE)
+
+#: Kotlin stdlib types a doc table names as a *column value* (`Boolean`, `Long`), not as a symbol this
+#: repo declares. Listing them beats loosening the identifier pattern, which would stop catching a
+#: genuinely renamed type.
+_KOTLIN_BUILTINS = frozenset(
+    {"Boolean", "Long", "Int", "String", "Float", "Double", "Set", "List", "Map", "Unit", "Any"}
+)
+
+
+def test_documented_kotlin_facade_symbols_exist() -> None:
+    """Every type named in the Kotlin facade table must be a real declaration.
+
+    The Python `__all__` surface is guarded by `public_api.txt` and the CLI table by the test above;
+    the Kotlin half of the same page had no guard at all, and its table sat marked "pending #17/#19"
+    long after both landed. This closes that asymmetry: the doc can now only name types that exist.
+
+    Method names inside the table cells are not checked here — `FacadeDelegationTest` (Android JVM)
+    already pins the model handle's methods by calling them.
+    """
+    if not _KOTLIN_FACADE_ROOT.is_dir():
+        pytest.skip("Android sources not present in this checkout")
+
+    declared: set[str] = set(_KOTLIN_BUILTINS)
+    for source in _KOTLIN_FACADE_ROOT.rglob("*.kt"):
+        text = source.read_text(encoding="utf-8")
+        declared.update(_KOTLIN_DECL.findall(text))
+        for body in _KOTLIN_ENUM_BODY.findall(text):
+            declared.update(_KOTLIN_ENUM_ENTRY.findall(body))
+
+    page = (DOCS / "PUBLIC_API.md").read_text(encoding="utf-8")
+    section = page.partition("## Kotlin facade")[2].partition("\n## ")[0]
+    assert section.strip(), "docs/PUBLIC_API.md has no Kotlin facade section"
+
+    # ANDROID_SDK.md's capability/result/tool-call tables name the same types and were unguarded, so
+    # the 2026-08-17 doc sweep could have invented a property name and nothing would have noticed.
+    # Only the TABLE rows are scanned: the prose around them legitimately names Java/Android types
+    # (`WorkManager`, `Play`) that are not declarations in this repo.
+    sdk = (DOCS / "ANDROID_SDK.md").read_text(encoding="utf-8")
+    section += "\n" + "\n".join(line for line in sdk.splitlines() if line.startswith("| `"))
+
+    # Types are the backticked identifiers in UpperCamelCase. SCREAMING_CASE tokens are enum *values*
+    # (`NATIVE`, `GENAI`), which `make parity` already checks against the Python enums wire-value by
+    # wire-value — a stronger check than existence, so re-testing them here would add nothing.
+    named = {
+        token
+        for token in re.findall(r"`([^`]+)`", section)
+        if re.fullmatch(r"[A-Z][A-Za-z0-9_]*", token) and not token.isupper()
+    }
+    assert named, "the Kotlin facade table names no types — the guard would pass vacuously"
+
+    missing = sorted(name for name in named if name not in declared)
+    assert not missing, (
+        f"docs/PUBLIC_API.md names Kotlin types that do not exist: {missing}. "
+        "Either the facade renamed them or the doc drifted."
+    )
+
+
+def test_every_doc_page_is_reachable() -> None:
+    """A page nobody links to is a page nobody reads.
+
+    There are now **two** front doors, and a page needs only one of them:
+
+    - `README.md`, for someone reading the repository on GitHub.
+    - `mkdocs.yml`'s `nav`, for someone reading the published site.
+
+    Checking the README alone was right when it was the only index. It stopped being right when the
+    documentation site moved into this repository: `index.md` is the site's home page and would be a
+    strange thing to link from the README, while a page missing from the **nav** is invisible on the
+    site no matter how well the README links it. Requiring either catches both kinds of orphan.
+    """
+    readme = (REPO_ROOT / "README.md").read_text(encoding="utf-8")
+    mkdocs = (REPO_ROOT / "mkdocs.yml").read_text(encoding="utf-8")
+    # Generated/checklist pages are referenced from their owning docs, not the README index.
+    exempt = {"RELEASE_CHECKLIST.md", "mobile_evaluation.md", "COMPATIBILITY_MATRIX.md"}
+    unlinked = sorted(
+        p.name
+        for p in DOCS.glob("*.md")
+        if p.name not in exempt and f"docs/{p.name}" not in readme and f": {p.name}" not in mkdocs
+    )
+    assert not unlinked, (
+        f"unreachable from both README.md and the mkdocs nav: {unlinked}. Add it to the README's "
+        "documentation table, or to `nav` in mkdocs.yml, or both."
+    )
+
+
+def test_the_site_nav_names_only_pages_that_exist() -> None:
+    """The other half: `nav` must not point at a page that is not there.
+
+    `mkdocs build --strict` catches this too, but only where mkdocs is installed — this keeps it in
+    the gate that always runs, so a renamed page fails in `make check` rather than in CI.
+    """
+    mkdocs = (REPO_ROOT / "mkdocs.yml").read_text(encoding="utf-8")
+    referenced = set(re.findall(r"^\s+\S.*?:\s+(\S+\.md)\s*$", mkdocs, re.MULTILINE))
+    assert referenced, "mkdocs.yml nav names no pages — this guard would pass vacuously"
+    missing = sorted(name for name in referenced if not (DOCS / name).is_file())
+    assert not missing, f"mkdocs.yml nav names pages that do not exist: {missing}"
+
+
+#: Types a Kotlin snippet may legitimately name without the SDK declaring them: Kotlin/Java stdlib,
+#: Android framework, coroutines, and the generated `BuildConfig`. Kept explicit rather than "skip
+#: anything we cannot find", which would make the guard pass on a typo.
+_COOKBOOK_EXTERNAL_TYPES = frozenset(
+    {
+        "Boolean",
+        "Byte",
+        "ByteArray",
+        "Double",
+        "Float",
+        "Int",
+        "List",
+        "Long",
+        "Map",
+        "Set",
+        "String",
+        "Unit",
+        "Array",
+        "Pair",
+        "Context",
+        "Intent",
+        "Log",
+        "File",
+        "System",
+        "BuildConfig",
+        "Exception",
+        "Throwable",
+    }
+)
+
+#: `object`/`companion` members and enum values are not declarations `_KOTLIN_DECL` can see; they are
+#: covered by `make parity` (enum wire values) or by the JVM suites that call them.
+# Enum constants and sealed-class members: the scan cannot tell `MemoryConfigId.HIGH_PERF` from a
+# type name, and the enum itself is already checked.
+_COOKBOOK_IGNORED_TOKENS = frozenset(
+    {
+        "GREEDY",
+        "NATIVE",
+        "GENAI",
+        "HIGH_PERF",
+        "DEFAULT",
+        "Accepted",
+        "Rejected",
+        "Inference",
+        "Training",
+    }
+)
+
+
+def test_cookbook_snippets_only_name_kotlin_types_that_exist() -> None:
+    """`docs/COOKBOOK.md`'s snippets must not name a Kotlin type the facade does not declare.
+
+    The cookbook's whole value is that it can be pasted into a real app. A snippet naming a renamed or
+    deleted type is worse than no snippet, and this is exactly how `docs/RAG.md` rotted before the
+    Kotlin-facade guard above was added — nothing checked the code, only the prose links.
+
+    Scans ```kotlin fences (not the whole page), so prose may still discuss a type by name in the past
+    tense while the code stays honest.
+    """
+    if not _KOTLIN_FACADE_ROOT.is_dir():
+        pytest.skip("Android sources not present in this checkout")
+
+    page = DOCS / "COOKBOOK.md"
+    assert page.is_file(), "docs/COOKBOOK.md is missing"
+
+    declared: set[str] = set()
+    for source in _KOTLIN_FACADE_ROOT.rglob("*.kt"):
+        declared.update(_KOTLIN_DECL.findall(source.read_text(encoding="utf-8")))
+    assert declared, "no Kotlin declarations found — the guard would pass vacuously"
+
+    blocks = re.findall(r"```kotlin\n(.*?)```", page.read_text(encoding="utf-8"), re.DOTALL)
+    assert blocks, "COOKBOOK.md has no kotlin snippets — the guard would pass vacuously"
+
+    named: set[str] = set()
+    for block in blocks:
+        # Strip line comments and string literals: a repo id, an intent name or a prose comment is
+        # not a type reference, and treating one as such would make the guard fail on correct code.
+        code = re.sub(r"//.*", "", block)
+        code = re.sub(r'"[^"]*"', '""', code)
+        named.update(re.findall(r"\b([A-Z][A-Za-z0-9_]*)\b", code))
+
+    unknown = sorted(
+        name
+        for name in named
+        if name not in declared
+        and name not in _COOKBOOK_EXTERNAL_TYPES
+        and name not in _COOKBOOK_IGNORED_TOKENS
+    )
+    assert not unknown, (
+        f"docs/COOKBOOK.md names Kotlin types that do not exist: {unknown}. "
+        "Either the facade renamed them or the cookbook drifted — fix the snippet, because it is "
+        "meant to be copy-pasteable."
+    )
diff --git a/tests/unit/test_enum_parity.py b/tests/unit/test_enum_parity.py
new file mode 100644
index 0000000..4cfddd5
--- /dev/null
+++ b/tests/unit/test_enum_parity.py
@@ -0,0 +1,34 @@
+"""Cross-language enum parity (F2): Kotlin wire values == Python enum values, schemas regenerable."""
+
+from __future__ import annotations
+
+from mobiletransformers.codegen.enums import (
+    KOTLIN_CONSTANTS_RELPATH,
+    check,
+    enums_golden,
+    find_repo_root,
+    parse_kotlin_enums,
+)
+from mobiletransformers.config.constants import ENUM_REGISTRY
+
+
+def test_parity_check_passes():
+    # Equivalent to `python -m mobiletransformers.codegen.enums --check`.
+    drifts = check(find_repo_root())
+    assert drifts == [], "enum/schema parity drift:\n" + "\n".join(drifts)
+
+
+def test_kotlin_wire_values_equal_python():
+    repo_root = find_repo_root()
+    kotlin = parse_kotlin_enums(repo_root / KOTLIN_CONSTANTS_RELPATH)
+    for name, enum in ENUM_REGISTRY.items():
+        assert kotlin.get(name) == {m.value for m in enum}, f"{name} Kotlin/Python drift"
+
+
+def test_golden_enums_json_matches_source():
+    import json
+
+    repo_root = find_repo_root()
+    golden = json.loads((repo_root / "schemas" / "enums.json").read_text())
+    # declaration-order lists in enums.json == the Python source
+    assert golden == enums_golden()
diff --git a/tests/unit/test_exceptions.py b/tests/unit/test_exceptions.py
new file mode 100644
index 0000000..c98306c
--- /dev/null
+++ b/tests/unit/test_exceptions.py
@@ -0,0 +1,41 @@
+"""The exception hierarchy is rooted at MobileTransformersError and mirrors the Kotlin names."""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.exceptions import (
+    ConfigValidationError,
+    ExportError,
+    HandoffError,
+    HubError,
+    ManifestError,
+    MergeError,
+    MobileTransformersError,
+    UnsupportedModelError,
+)
+
+_SUBCLASSES = [
+    ConfigValidationError,
+    ExportError,
+    ManifestError,
+    HandoffError,
+    MergeError,
+    UnsupportedModelError,
+    HubError,
+]
+
+
+@pytest.mark.parametrize("exc", _SUBCLASSES)
+def test_every_error_derives_from_root(exc):
+    assert issubclass(exc, MobileTransformersError)
+
+
+@pytest.mark.parametrize("exc", _SUBCLASSES)
+def test_catchable_as_root(exc):
+    with pytest.raises(MobileTransformersError):
+        raise exc("boom")
+
+
+def test_root_is_an_exception():
+    assert issubclass(MobileTransformersError, Exception)
diff --git a/tests/unit/test_export_inference_package.py b/tests/unit/test_export_inference_package.py
new file mode 100644
index 0000000..c232a35
--- /dev/null
+++ b/tests/unit/test_export_inference_package.py
@@ -0,0 +1,153 @@
+"""Unified inference-export package builder (#9): base/trainable external split + handoff-map emit.
+
+onnx-only (core env). Builds a synthetic Llama-shaped graph with one adapted MatMul + one frozen base
+tensor, exports the package, and asserts the flat layout, the handoff map (which self-validates on load),
+per-tensor checksums, and the emitted merger model.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import onnx
+import pytest
+from onnx import TensorProto, helper, numpy_helper
+
+from mobiletransformers.artifacts.handoff_map import HandoffMap
+from mobiletransformers.config.constants import HandoffMode, PEFTMethod
+from mobiletransformers.exceptions import ExportError
+from mobiletransformers.export.inference_package import FROZEN_BASE_BLOB, export_inference_package
+
+TRAINABLE_WEIGHT = "model.layers.0.attn.q_proj.MatMul.weight"
+FROZEN_WEIGHT = "model.embed_tokens.weight"
+BASE_LAYER = "backbone.model.layers.0.self_attn.q_proj"
+
+
+class _Config:
+    architectures = ["LlamaForCausalLM"]
+
+
+def _build_input_model(path) -> None:
+    x = helper.make_tensor_value_info("X", TensorProto.FLOAT, ["batch", 4])
+    logits = helper.make_tensor_value_info("logits", TensorProto.FLOAT, ["batch", 3])
+    rng = np.random.default_rng(0)
+    w = numpy_helper.from_array(rng.standard_normal((4, 3)).astype(np.float32), name=TRAINABLE_WEIGHT)
+    bias = numpy_helper.from_array(np.zeros((3,), dtype=np.float32), name=FROZEN_WEIGHT)
+    mm = helper.make_node("MatMul", ["X", TRAINABLE_WEIGHT], ["mm"])
+    add = helper.make_node("Add", ["mm", FROZEN_WEIGHT], ["logits"])
+    graph = helper.make_graph([mm, add], "tiny", [x], [logits], initializer=[w, bias])
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)])
+    onnx.save(model, str(path))
+
+
+def _training_config() -> dict:
+    return {
+        "requires_grad": ["lora"],
+        "peft_mapping": {BASE_LAYER: {"adapter_A": "lora_A", "adapter_B": "lora_B"}},
+    }
+
+
+def test_export_produces_flat_package(tmp_path):
+    src = tmp_path / "src_model.onnx"
+    _build_input_model(src)
+    out = tmp_path / "inference"
+
+    pkg = export_inference_package(
+        model_path=src,
+        output_dir=out,
+        training_config=_training_config(),
+        model_config=_Config(),
+        peft_method=PEFTMethod.LORA,
+        quant_in=False,
+        quant_out=False,
+    )
+
+    # Flat layout: model.onnx, one trainable .bin (+.sha256), frozen base blob, handoff map, merger onnx.
+    assert pkg.model_path.exists()
+    assert len(pkg.trainable_bins) == 1
+    bin_path = pkg.trainable_bins[0]
+    assert bin_path.name == f"{TRAINABLE_WEIGHT}.bin"
+    assert bin_path.exists()
+    assert (bin_path.parent / (bin_path.name + ".sha256")).exists()
+    assert pkg.frozen_base_blob is not None and pkg.frozen_base_blob.name == FROZEN_BASE_BLOB
+    assert pkg.frozen_base_blob.exists()
+
+    # Merger model emitted and recorded under its variant tag.
+    assert pkg.merger_models  # {"lora": "merger_lora_fpin_fpout.onnx"}
+    for filename in pkg.merger_models.values():
+        assert (out / filename).exists()
+
+
+def test_handoff_map_is_valid_and_keys_observed_names(tmp_path):
+    src = tmp_path / "src_model.onnx"
+    _build_input_model(src)
+    out = tmp_path / "inference"
+    export_inference_package(
+        model_path=src,
+        output_dir=out,
+        training_config=_training_config(),
+        model_config=_Config(),
+        peft_method=PEFTMethod.LORA,
+        quant_in=False,
+        quant_out=False,
+    )
+
+    # load() runs check_compat + validate(): a bad map raises here.
+    handoff = HandoffMap.load(out / "weight_handoff_map.json")
+    assert len(handoff.entries) == 1
+    entry = handoff.entries[0]
+    assert entry.inference_initializer_names["weight"] == TRAINABLE_WEIGHT
+    assert entry.external_data_location["weight"] == f"{TRAINABLE_WEIGHT}.bin"
+    # sha256 recorded matches the sidecar written for the .bin.
+    sidecar = (out / f"{TRAINABLE_WEIGHT}.bin.sha256").read_text().strip()
+    assert entry.sha256["weight"] == sidecar
+
+
+def test_frozen_base_is_not_a_trainable_bin(tmp_path):
+    src = tmp_path / "src_model.onnx"
+    _build_input_model(src)
+    out = tmp_path / "inference"
+    pkg = export_inference_package(
+        model_path=src,
+        output_dir=out,
+        training_config=_training_config(),
+        model_config=_Config(),
+        peft_method=PEFTMethod.LORA,
+        quant_in=False,
+        quant_out=False,
+    )
+    # The frozen tensor must never be one of the per-tensor trainable files.
+    assert all(FROZEN_WEIGHT not in b.name for b in pkg.trainable_bins)
+    assert not (out / f"{FROZEN_WEIGHT}.bin").exists()
+
+
+def test_model_input_mode_fails_closed(tmp_path):
+    src = tmp_path / "src_model.onnx"
+    _build_input_model(src)
+    with pytest.raises(NotImplementedError, match="not supported in v1"):
+        export_inference_package(
+            model_path=src,
+            output_dir=tmp_path / "inference",
+            training_config=_training_config(),
+            model_config=_Config(),
+            peft_method=PEFTMethod.LORA,
+            quant_in=False,
+            quant_out=False,
+            handoff_mode=HandoffMode.MODEL_INPUT,
+        )
+
+
+def test_naming_drift_fails_closed(tmp_path):
+    """A peft_mapping base layer with no matching inference initializer aborts (no silent fallback)."""
+    src = tmp_path / "src_model.onnx"
+    _build_input_model(src)
+    cfg = {"requires_grad": ["lora"], "peft_mapping": {"backbone.model.layers.9.self_attn.k_proj": {}}}
+    with pytest.raises(ExportError, match="naming drifted"):
+        export_inference_package(
+            model_path=src,
+            output_dir=tmp_path / "inference",
+            training_config=cfg,
+            model_config=_Config(),
+            peft_method=PEFTMethod.LORA,
+            quant_in=False,
+            quant_out=False,
+        )
diff --git a/tests/unit/test_gate_ratchet.py b/tests/unit/test_gate_ratchet.py
new file mode 100644
index 0000000..5c5157b
--- /dev/null
+++ b/tests/unit/test_gate_ratchet.py
@@ -0,0 +1,104 @@
+"""Every migration ratchet must shrink, and none may go stale.
+
+The migration relies on several allow-lists that trade "gated" for "tracked":
+
+* `pyproject.toml` `[tool.ruff.lint.per-file-ignores]` — lint codes tolerated in freshly-moved code
+* `pyproject.toml` `[[tool.mypy.overrides]]` marked `MIGRATION RATCHET` — modules not yet typed
+* `tests/unit/test_guards.py::DISPATCH_ALLOWLIST` — remaining #6 dispatch literals
+* `tests/unit/test_no_src_to_legacy_imports.py::ALLOWED` — remaining `src/` → legacy arrows
+
+Each of those has its own shrink check. This module guards the property they share: an entry naming a
+file that no longer exists, or a code that no longer fires, is a lie that makes the debt look bigger
+than it is — and hides the next real violation behind a blanket exemption.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PYPROJECT = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
+
+_RATCHET_MARKER = "MIGRATION RATCHET"
+
+
+def _per_file_ignores() -> dict[str, list[str]]:
+    """Parse `[tool.ruff.lint.per-file-ignores]` without a TOML parser (core env is Python 3.10)."""
+    if "[tool.ruff.lint.per-file-ignores]" not in PYPROJECT:
+        return {}
+    block = PYPROJECT.split("[tool.ruff.lint.per-file-ignores]", 1)[1].split("\n[", 1)[0]
+    entries: dict[str, list[str]] = {}
+    for match in re.finditer(r'^"([^"]+)"\s*=\s*\[([^\]]*)\]', block, re.MULTILINE):
+        codes = re.findall(r'"([^"]+)"', match.group(2))
+        entries[match.group(1)] = codes
+    return entries
+
+
+def _ratchet_override_modules() -> list[str]:
+    """Modules in `MIGRATION RATCHET`-marked mypy override blocks."""
+    modules: list[str] = []
+    for block in PYPROJECT.split("[[tool.mypy.overrides]]")[1:]:
+        head = block.split("\n[", 1)[0]
+        if _RATCHET_MARKER not in head:
+            continue
+        modules.extend(re.findall(r'"([^"]+)"', head.split("module", 1)[1].split("\n", 2)[0] or ""))
+        for match in re.finditer(r"module\s*=\s*\[([^\]]*)\]", head, re.DOTALL):
+            modules.extend(re.findall(r'"([^"]+)"', match.group(1)))
+    return sorted(set(modules))
+
+
+def test_ruff_per_file_ignores_name_existing_files() -> None:
+    stale = [path for path in _per_file_ignores() if not (REPO_ROOT / path).exists()]
+    assert not stale, f"per-file-ignores name file(s) that no longer exist: {stale}"
+
+
+def test_ruff_per_file_ignores_still_fire() -> None:
+    """An ignore whose codes no longer trigger must be deleted — otherwise the ratchet never tightens."""
+    for path, codes in _per_file_ignores().items():
+        if not codes or not (REPO_ROOT / path).is_file():
+            continue
+        result = subprocess.run(
+            ["uv", "run", "ruff", "check", "--isolated", "--select", ",".join(codes), path],
+            capture_output=True,
+            text=True,
+            cwd=REPO_ROOT,
+            check=False,
+        )
+        assert result.returncode != 0, (
+            f"{path}: none of {codes} fire any more — drop the per-file-ignores entry"
+        )
+
+
+def test_mypy_ratchet_overrides_name_existing_modules() -> None:
+    for module in _ratchet_override_modules():
+        package = module.removesuffix(".*").replace(".", "/")
+        candidates = [REPO_ROOT / "src" / f"{package}.py", REPO_ROOT / "src" / package]
+        assert any(c.exists() for c in candidates), (
+            f"MIGRATION RATCHET override names {module}, which does not exist — drop it"
+        )
+
+
+def test_dispatch_allowlist_is_tracked_not_forgotten() -> None:
+    """Cross-check: the #6 allow-list must name real files and carry a stated owner *while it has debt*.
+
+    The owner requirement is conditional on the allow-list being non-empty. It is empty now — #6 closed
+    when `inference/builder.py`'s 14-branch ladder became registry rows — and demanding an owner for
+    debt that no longer exists would force a fake entry to keep the gate green.
+    """
+    from tests.unit.test_guards import DISPATCH_ALLOWLIST
+
+    for path in DISPATCH_ALLOWLIST:
+        assert (REPO_ROOT / path).is_file(), f"DISPATCH_ALLOWLIST names a missing file: {path}"
+
+    if DISPATCH_ALLOWLIST:
+        guards = (REPO_ROOT / "tests" / "unit" / "test_guards.py").read_text(encoding="utf-8")
+        assert "Owner:" in guards, "DISPATCH_ALLOWLIST must record who owns the remaining debt"
+
+
+def test_legacy_import_allowlist_is_tracked() -> None:
+    from tests.unit.test_no_src_to_legacy_imports import ALLOWED, SRC
+
+    for module in ALLOWED:
+        assert (SRC / module).is_file(), f"ALLOWED names a missing module: {module}"
diff --git a/tests/unit/test_guards.py b/tests/unit/test_guards.py
new file mode 100644
index 0000000..7271033
--- /dev/null
+++ b/tests/unit/test_guards.py
@@ -0,0 +1,869 @@
+"""Repository-wide grep guards (#4 secrets, #6 registry dispatch) — the CI ratchets.
+
+Two guards were described in the plans as CI gates but existed in neither the ``Makefile`` nor
+``ci.yml``: the #4 secret-read guard, and a #6 dispatch guard covering anything beyond
+``src/mobiletransformers``. ``tests/unit/test_registries.py`` already guards ``src/`` itself; this
+module extends the same idea to the **legacy roots** and the **C++ tree**, which is where every
+violation the audit found actually lives.
+
+Both allow-lists are RATCHETS: an entry may only be removed. A file that drops below its allowed
+count fails the test, forcing the allowance down with the fix rather than letting it rot.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+# --- #6: registry dispatch --------------------------------------------------------------------
+
+#: Patterns that mean "branching on a closed-set wire value instead of resolving it via a registry".
+DISPATCH_PATTERNS = (
+    r"architectures\[0\]\s*==",
+    r'peft_method\s*==\s*["\']',
+    r'train_method\s*==\s*["\']',
+    r'merger_type\s*==\s*["\']',
+)
+
+#: Legacy roots still outside the new package. **EMPTY — S9 deleted all seven.** Kept as a named
+#: constant (rather than deleted) so re-introducing a root outside `src/` is a one-line, visible
+#: change rather than an invisible omission.
+LEGACY_ROOTS: tuple[str, ...] = ()
+
+#: First-party Python that lives OUTSIDE the wheel and is therefore ungated by ruff/mypy: the paper
+#: experiments, the shell/Python helpers, and the gate spikes.
+#:
+#: 2026-08-14: this replaces `LEGACY_ROOTS` as the dispatch guard's subject. With `LEGACY_ROOTS`
+#: empty, `test_legacy_dispatch_debt_only_shrinks` and `test_allowlist_entries_still_exist` scanned
+#: NOTHING — 2 of the 7 guards asserted nothing at all while reading as if they were enforcing. These
+#: directories are the real remaining un-gated first-party Python, and `research/` genuinely carries
+#: the debt below.
+NON_PACKAGE_PY_ROOTS: tuple[str, ...] = ("research", "scripts", "spikes")
+
+#: repo-relative path -> the number of dispatch hits currently tolerated. ENTRIES MAY ONLY SHRINK.
+#:
+#: **EMPTY — #6 is closed.** `inference/builder.py`'s 14-branch architecture ladder is gone; it now
+#: resolves through `ARCHITECTURE_REGISTRY`, side effects included (PhiMoE's cuda+int4 forcing, Phi3V's
+#: exclude_embeds, ChatGLM's hidden_act=swiglu are `option_overrides` / `extra_option_overrides` /
+#: `config_overrides` on the row). Verified class-for-class: all 15 branches resolve to the same class
+#: objects the ladder constructed.
+#:
+#: This sat at 14 for months behind "the module is unimportable under every declared profile". The real
+#: cause was one renamed ORT import (see `export/quantizer_compat.py`).
+#:
+#: Within `src/` this is closed and stays closed — `tests/unit/test_registries.py` asserts it there.
+#:
+#: The counts below are `research/`'s, measured 2026-08-14 when this guard was re-pointed at
+#: `NON_PACKAGE_PY_ROOTS`. They are the paper's ablation scripts: `offline_train_eval.py` branches over
+#: the PEFT methods it compares, which is what an experiment harness legitimately does — it is out of
+#: the wheel and out of ruff/mypy for the same reason. The ratchet's job here is that **no new**
+#: dispatch appears, and that these numbers only fall (e.g. if a script is retired).
+#:
+#: Owner: `research/` is the paper's, not the library's — it is excluded from the wheel, from ruff and
+#: from mypy by `pyproject.toml`, and its READMEs record why it is kept. No plan owns migrating it.
+DISPATCH_ALLOWLIST: dict[str, int] = {
+    "research/offline_train_eval.py": 10,
+    "research/pytorch_experiments/dynamic_model_training.py": 3,
+}
+
+# --- #33/#6: architecture-name literals -------------------------------------------------------
+
+#: Decoder module names spelled as string literals. These belong in `config/registry/architecture.py`
+#: as data (`ArchitectureSpec.projection_names` / `attention_module_name`) and nowhere else.
+#:
+#: This guard exists because #33 found **six** of them in `peft/mars/model.py` alone — the attention
+#: lookup, the hidden-states hook, three `register_proj_hook` calls and the `projection_type` ladder —
+#: plus a seventh in `peft/mapping.py`. Every one of them was invisible on a decoder and wrong on an
+#: encoder, and the failure mode was a SILENT no-op: MARS degraded to unshared adapters with no error.
+#: A grep guard is the cheap way to keep them from creeping back, and it immediately found a live
+#: defect the first time it ran (`training_export.py`'s `--lora_target` still defaulted to the
+#: decoder-specific `["q_proj", "k_proj"]` the registry had replaced, silently overriding it).
+#:
+#: Deliberately NOT included: `query`/`key`/`value`. They are BERT's projection names but also
+#: ordinary English used throughout the RAG and hub code, so they would drown the signal.
+ARCHITECTURE_LITERAL_PATTERNS = (
+    r"[\"']self_attn[\"']",
+    r"[\"'][qkvo]_proj[\"']",
+    r"[\"'](gate|up|down)_proj[\"']",
+    r"[\"'][qkv]_lin[\"']",
+)
+
+#: Files allowed to spell them, and why.
+ARCHITECTURE_LITERAL_ALLOWLIST: dict[str, int] = {
+    # The vendored ONNX Runtime GenAI builder. Upstream code, treated as upstream (see #6/#7).
+    "src/mobiletransformers/inference/builder.py": 10_000,
+    # `artifacts/validation.py` is GONE from this list as of 2026-08-10: the spec is threaded in
+    # (`ONNXModelGenerator(architecture_spec=...)` -> `_attention_module_name()`), which is the fix the
+    # note here asked for rather than a wider allowance. Do not re-add it.
+}
+
+# --- #4: secrets ------------------------------------------------------------------------------
+
+#: Direct environment reads of credential-shaped names. Settings must come from `config/settings.py`
+#: (CLI > env > YAML > default), never an ad-hoc `os.environ[...]` scattered through the code.
+SECRET_PATTERNS = (
+    r"os\.environ\[[\"'][A-Z_]*(TOKEN|SECRET|PASSWORD|API_KEY|APIKEY)[A-Z_]*[\"']\]",
+    r"os\.getenv\(\s*[\"'][A-Z_]*(TOKEN|SECRET|PASSWORD|API_KEY|APIKEY)[A-Z_]*[\"']",
+)
+
+#: Hardcoded credential literals (an assignment to a secret-shaped name with a non-empty literal).
+SECRET_LITERAL_PATTERN = (
+    r'(?i)\b(api_?key|secret|password|access_token|auth_token)\s*=\s*["\'][A-Za-z0-9_\-]{16,}["\']'
+)
+
+#: 2026-08-14: widened from `("src", "tests")` — the secret guard could not see `research/`,
+#: `scripts/` or `spikes/`, which is precisely where a quick experiment script would paste a key.
+SCAN_DIRS = ("src", "tests", *LEGACY_ROOTS, *NON_PACKAGE_PY_ROOTS)
+
+
+def _is_in_comment(line_text: str, pattern: str) -> bool:
+    """True when the match sits inside a `#` or `//` comment (or a docstring-ish prose line).
+
+    A known trap with grep guards (recorded in HANDOFF's gotchas): they hit prose that *mentions* the
+    banned pattern, e.g. a comment saying "replaces the `merger_type == \"lora\"` dispatch". Rather
+    than contorting the prose, the guard ignores matches that begin after a comment marker.
+    """
+    match = re.search(pattern, line_text)
+    if match is None:
+        return False
+    prefix = line_text[: match.start()]
+    return "#" in prefix or "//" in prefix or prefix.lstrip().startswith(("*", '"""', "'''"))
+
+
+def _grep(patterns: tuple[str, ...], paths: list[Path], includes: tuple[str, ...]) -> list[str]:
+    """Return `path:line:text` hits, or [] when nothing matches. Missing paths are skipped."""
+    existing = [str(p) for p in paths if p.exists()]
+    if not existing:
+        return []
+    cmd = ["grep", "-rnE", *[f"--include={g}" for g in includes], "|".join(patterns), *existing]
+    result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if result.returncode not in (0, 1):  # 1 == no match
+        raise RuntimeError(f"grep failed: {result.stderr}")
+    hits = []
+    for line in result.stdout.splitlines():
+        if not line.strip():
+            continue
+        # `path:lineno:text`
+        text = line.split(":", 2)[2] if line.count(":") >= 2 else line
+        if any(not _is_in_comment(text, p) for p in patterns if re.search(p, text)):
+            hits.append(line)
+    return hits
+
+
+def _relative(hit: str) -> str:
+    return str(Path(hit.split(":", 1)[0]).resolve().relative_to(REPO_ROOT))
+
+
+def test_no_dispatch_literals_in_cpp() -> None:
+    """The C++ merger used `merger_type == "lora"` etc.; it now dispatches on a typed MergerVariant.
+
+    The `src/`-only guard could never see this, which is why five sites survived every gate.
+    """
+    cpp = REPO_ROOT / "android/MobileTransformers/MobileTransformers/src/main/cpp"
+    if not cpp.is_dir():
+        pytest.skip("Android cpp tree not present")
+    hits = [
+        h
+        for h in _grep(DISPATCH_PATTERNS, [cpp], ("*.cpp", "*.h"))
+        # Vendored third-party trees are not ours to police.
+        if not re.search(r"/(onnxruntime|onnxruntime-genai|tokenizers|proto|includes)/", h)
+    ]
+    assert not hits, "string-literal dispatch found in cpp/:\n" + "\n".join(hits)
+
+
+def test_legacy_dispatch_debt_only_shrinks() -> None:
+    """Ratchet over first-party Python outside the wheel: no NEW dispatch, known ones only decrease."""
+    roots = [REPO_ROOT / r for r in (*LEGACY_ROOTS, *NON_PACKAGE_PY_ROOTS)]
+    counts: dict[str, int] = {}
+    for hit in _grep(DISPATCH_PATTERNS, roots, ("*.py",)):
+        counts[_relative(hit)] = counts.get(_relative(hit), 0) + 1
+
+    unlisted = {p: n for p, n in counts.items() if p not in DISPATCH_ALLOWLIST}
+    assert not unlisted, (
+        "new string-literal dispatch outside the registries — resolve it via "
+        f"config/registry/ instead:\n{unlisted}"
+    )
+
+    for path, allowed in DISPATCH_ALLOWLIST.items():
+        actual = counts.get(path, 0)
+        assert actual <= allowed, f"{path}: dispatch literals grew from {allowed} to {actual}"
+        assert actual == allowed, (
+            f"{path}: down to {actual} dispatch literals (allowance {allowed}) — "
+            "lower DISPATCH_ALLOWLIST so the ratchet holds"
+        )
+
+
+def test_no_direct_secret_environment_reads() -> None:
+    """#4: credentials come from `config/settings.py`, never an ad-hoc os.environ read."""
+    hits = _grep(SECRET_PATTERNS, [REPO_ROOT / d for d in SCAN_DIRS], ("*.py",))
+    # settings.py is the ONE place allowed to read the environment.
+    hits = [h for h in hits if not _relative(h).endswith("config/settings.py")]
+    assert not hits, (
+        "direct credential reads from the environment — route them through "
+        "mobiletransformers.config.settings:\n" + "\n".join(hits)
+    )
+
+
+def test_no_hardcoded_credential_literals() -> None:
+    """#4: no credential-shaped literal is ever committed."""
+    hits = _grep((SECRET_LITERAL_PATTERN,), [REPO_ROOT / d for d in SCAN_DIRS], ("*.py",))
+    assert not hits, "hardcoded credential literal:\n" + "\n".join(hits)
+
+
+def test_allowlist_entries_still_exist() -> None:
+    """A stale allow-list entry must fail, so the ratchet cannot silently rot."""
+    for path in DISPATCH_ALLOWLIST:
+        assert (REPO_ROOT / path).is_file(), (
+            f"DISPATCH_ALLOWLIST names {path}, which no longer exists — drop the entry"
+        )
+
+
+def test_no_architecture_literals_outside_the_registry() -> None:
+    """Per-architecture module names are registry DATA; a literal elsewhere is a latent encoder bug.
+
+    Ratchet, like the dispatch guard: an allow-list entry may only shrink. The registry itself is
+    excluded because it is where these names are supposed to live.
+    """
+    src = REPO_ROOT / "src"
+    registry = "src/mobiletransformers/config/registry/"
+
+    counts: dict[str, int] = {}
+    for hit in _grep(ARCHITECTURE_LITERAL_PATTERNS, [src], ("*.py",)):
+        rel = _relative(hit)
+        if rel.startswith(registry):
+            continue
+        counts[rel] = counts.get(rel, 0) + 1
+
+    unlisted = {p: n for p, n in counts.items() if p not in ARCHITECTURE_LITERAL_ALLOWLIST}
+    assert not unlisted, (
+        "hardcoded architecture module names outside config/registry/ — put them on the "
+        f"ArchitectureSpec row instead (projection_names / attention_module_name):\n{unlisted}"
+    )
+
+    for path, allowed in ARCHITECTURE_LITERAL_ALLOWLIST.items():
+        actual = counts.get(path, 0)
+        assert actual <= allowed, f"{path}: architecture literals grew from {allowed} to {actual}"
+
+
+# --- G2: stage-path concatenation ---------------------------------------------------------------
+
+#: Building a package STAGE path by appending its name to a string.
+#:
+#: A package has two on-disk layouts — the hub's `variants/<id>/train` and the flat device cache's
+#: `<cacheDir>/<repoId>/train` — and the manifest declares the first in `variant.paths`. Before G2,
+#: exactly ONE consumer in the repo read those declarations (`cli/federated.py`); every other site
+#: spelled the join by hand, in Python and Kotlin, and the two layouts were routinely confused.
+#:
+#: That confusion is not hypothetical: the #35 simulation looked for `<package>/train/` — the CACHE
+#: layout — inside a hub package, and ORT reported `INVALID_ARGUMENT : Invalid fd was supplied: -1`,
+#: naming no file. It cost a cycle.
+#:
+#: Resolve through `artifacts/package_paths.py::PackagePaths` (Python) or `packages/PackagePaths.kt`
+#: (Kotlin) instead. **C++ is deliberately NOT scanned**: it never resolves a stage — Kotlin hands it
+#: an already-resolved directory over JNI, and its joins (`inference_dir + "/weight_handoff_map.json"`)
+#: append a FILENAME to a resolved dir, which is not this defect.
+STAGE_PATH_PATTERNS = (
+    # Python: `something / "train"`, `something / "inference"`, `something / "embedding"`
+    r'/\s*"(train|inference|embedding)"',
+    # Kotlin: `File(x, "train")`, `"$cacheDir/$repoId/train"`, `"…/inference"`
+    r'File\([^)]*,\s*"(train|inference|embedding|tokenizer)"\s*\)',
+    r'"\$[A-Za-z_{][^"]*/(train|inference|embedding)(/|")',
+)
+
+#: repo-relative path -> hits currently tolerated. ENTRIES MAY ONLY SHRINK.
+#:
+#: `export/pipeline.py` is the package PRODUCER: it creates `variants/<id>/<stage>` on disk, so it is
+#: the one place that legitimately writes the layout rather than reading it. It is listed rather than
+#: exempted by rule so that any growth still has to be argued for.
+#: The two PRODUCERS are listed rather than exempted by rule, so growth still has to be argued for:
+#: `export/pipeline.py` creates `variants/<id>/<stage>` on disk, and `ModelPackageInstaller.kt` is the
+#: function that CONVERTS the hub layout into the flat cache layout. Something has to write each
+#: layout down once; everything else reads it through PackagePaths.
+#:
+#: The two RAG sites were the recorded debt here, and they are now ZERO: `PackagePaths` grew
+#: `embeddingDatabase`/`embeddingTokenizer` (sub-paths of the embedding stage, created at ingest time
+#: rather than shipped) and `ORTRetriever`/`ORTVectorDatabase` resolve through it. The prose comment
+#: they carried had already drifted from the code — it described the store as `<repo>/database/` while
+#: the code wrote `<repo>/embedding/database/` — which is precisely the drift this guard exists for.
+_SDK = "android/MobileTransformers/MobileTransformers/src/main/java/com/martinkorelic/mobiletransformers"
+
+STAGE_PATH_ALLOWLIST: dict[str, int] = {
+    "src/mobiletransformers/export/pipeline.py": 8,
+    f"{_SDK}/packages/ModelPackageInstaller.kt": 1,
+}
+
+#: Files that necessarily spell a layout: the resolvers themselves and their tests.
+_RESOLVER_FILES = ("package_paths.py", "PackagePaths.kt", "PackagePathsTest.kt", "test_package_paths.py")
+
+
+def test_no_stage_path_concatenation() -> None:
+    """Stage directories come from PackagePaths, not from appending a stage name to a string.
+
+    Covers Kotlin as well as Python — the guards historically included only `*.py`/`*.cpp`/`*.h`, and
+    Kotlin is where most of these sites lived.
+    """
+    scan = [REPO_ROOT / "src", REPO_ROOT / "android"]
+    counts: dict[str, int] = {}
+    for hit in _grep(STAGE_PATH_PATTERNS, scan, ("*.py", "*.kt")):
+        rel = _relative(hit)
+        if rel.endswith(_RESOLVER_FILES):
+            continue
+        # Test fixtures build synthetic packages on purpose.
+        if rel.startswith("tests/") or "/androidTest/" in rel or "/src/test/" in rel:
+            continue
+        counts[rel] = counts.get(rel, 0) + 1
+
+    unlisted = {p: n for p, n in counts.items() if p not in STAGE_PATH_ALLOWLIST}
+    assert not unlisted, (
+        "stage paths built by string concatenation — resolve them through PackagePaths "
+        f"(artifacts/package_paths.py / packages/PackagePaths.kt) instead:\n{unlisted}"
+    )
+
+    for path, allowed in STAGE_PATH_ALLOWLIST.items():
+        actual = counts.get(path, 0)
+        assert actual <= allowed, f"{path}: stage-path concatenation grew from {allowed} to {actual}"
+
+
+# --- #17/#19: the showcase app must use the public facade, nothing else -------------------------
+
+#: The sample app's Kotlin sources. `MobileTransformersApp` is the reference example every external
+#: consumer is pointed at, so anything it reaches for is, in practice, public API.
+_APP = "android/MobileTransformers/MobileTransformersApp/src/main"
+
+#: Library sources, used to DERIVE the banned set rather than hand-list it.
+_SDK_MAIN = f"{_SDK}"
+
+#: Files whose declarations are internal machinery by construction. A type declared in one of these
+#: is banned from app code no matter what it is called.
+#:
+#: Deriving from the declaring FILE is the point. The obvious guard — ban `ORT*`, `*Native`,
+#: `*Repository` by name — has a hole big enough to drive the old app through: it also imported
+#: `DeviceOptions`, `SamplingOptions`, `SchedulerConfig`, `InferenceProgress`, `TrainingProgress` and
+#: `RagResult`, none of which match any of those patterns, yet all six are declared inside
+#: `ORTGenerationConfig.kt` / `ORTTrainingConfig.kt` / `ORTProgress.kt` and exist only to build or
+#: receive an `ORT*` config. A name-based guard would have reported "migrated" with the app still
+#: wired to the engine. This cannot rot as new types are added to those files.
+_INTERNAL_DECL_FILE_GLOB = "ORT*.kt"
+
+#: Name patterns that are internal regardless of where they are declared.
+_INTERNAL_NAME_RE = re.compile(r"^[A-Z][A-Za-z0-9_]*(Native|Repository)$")
+
+_KOTLIN_DECL_RE = re.compile(
+    r"\b(?:data class|sealed class|enum class|value class|abstract class|open class|class|interface|"
+    r"fun interface|object)\s+([A-Z][A-Za-z0-9_]*)"
+)
+
+
+def _banned_sdk_symbols() -> set[str]:
+    """Every library type the sample app must not import, derived from the library sources."""
+    sdk = REPO_ROOT / _SDK_MAIN
+    banned: set[str] = set()
+    for source in sdk.rglob("*.kt"):
+        declared = set(_KOTLIN_DECL_RE.findall(source.read_text(encoding="utf-8")))
+        # (1) anything declared in an ORT*.kt file, (2) anything *Native / *Repository anywhere.
+        if source.match(_INTERNAL_DECL_FILE_GLOB):
+            banned |= declared
+        banned |= {name for name in declared if _INTERNAL_NAME_RE.match(name)}
+    return banned
+
+
+def test_the_sample_app_uses_only_the_public_facade() -> None:
+    """`MobileTransformersApp` may not reach past the facade into the engine layer.
+
+    #17/#19 built a public SDK surface — `MobileTransformers.fromPretrained`,
+    `MobileTransformerModel`, the `config/` types — and then nothing exercised it: the app that ships
+    with the library drove `LLMRepository`/`TrainingRepository`/`RagRepository`/`InferenceRepository`
+    and the `ORT*` configs directly, so the ergonomics of the documented API had never met a real
+    screen and there was no worked example of the thing consumers are told to adopt.
+
+    This guard is what makes "migrated" checkable rather than claimed. It is deliberately a source
+    grep over imports: an app that cannot *name* an internal type cannot reach one.
+
+    Note the third rule — the `internal/` package. Kotlin's `internal` is module-scoped, and the app
+    is a separate Gradle module, so the compiler already stops it; the check is here so the intent is
+    stated in one place with the other two rather than depending on a module boundary staying put.
+    """
+    app = REPO_ROOT / _APP
+    if not app.is_dir():
+        pytest.skip("Android sample app not present in this checkout")
+
+    banned = _banned_sdk_symbols()
+    assert banned, "the banned set is empty — this guard would pass vacuously"
+
+    sources = sorted(app.rglob("*.kt"))
+    assert sources, f"no Kotlin sources under {_APP} — the guard would pass vacuously"
+
+    violations: list[str] = []
+    for source in sources:
+        rel = str(source.relative_to(REPO_ROOT))
+        for lineno, line in enumerate(source.read_text(encoding="utf-8").splitlines(), 1):
+            stripped = line.strip()
+            if not stripped.startswith("import com.martinkorelic.mobiletransformers"):
+                continue
+            symbol = stripped.removeprefix("import ").split(" as ")[0].rsplit(".", 1)[-1]
+            if ".internal." in stripped:
+                violations.append(f"{rel}:{lineno}: {stripped}  (internal package)")
+            elif symbol in banned:
+                violations.append(f"{rel}:{lineno}: {stripped}  ({symbol} is engine-layer)")
+
+    assert not violations, (
+        "the sample app reaches past the public facade. Use `MobileTransformers.fromPretrained` and "
+        "the `config/` types instead; if the facade cannot express what the screen needs, FIX THE "
+        "FACADE and record it against #17/#19 — a reach-around is the debt reappearing under a new "
+        "name:\n" + "\n".join(violations)
+    )
+
+
+# --- #21/#22: the library manifest must declare the permissions its own code needs ----------------
+
+#: The library manifest. Permissions belong HERE, not in the consuming app: an integrator who calls
+#: only the documented entry point cannot be expected to discover that it opens a socket.
+_SDK_MANIFEST = "android/MobileTransformers/MobileTransformers/src/main/AndroidManifest.xml"
+
+#: Permission -> the library code path that cannot run without it. Each entry names a call an app
+#: reaches through the PUBLIC facade, which is what makes the permission the library's to declare.
+_REQUIRED_PERMISSIONS: dict[str, str] = {
+    "android.permission.INTERNET": (
+        "HubDownloader/PackageDownloader (OkHttp) and AdapterUploader — reached from "
+        "MobileTransformers.fromPretrained whenever the package is not already installed"
+    ),
+    "android.permission.FOREGROUND_SERVICE": "TrainingScheduler's foreground WorkManager worker (#34)",
+    "android.permission.POST_NOTIFICATIONS": "the foreground worker's mandatory progress notification",
+    "android.permission.WAKE_LOCK": "held by WorkManager for the duration of a training chunk",
+}
+
+
+def test_the_library_manifest_declares_the_permissions_its_own_code_needs() -> None:
+    """Every permission the SDK's own code paths require must be in the LIBRARY manifest.
+
+    This guard exists because ``INTERNET`` was absent for the entire life of the #21 Hub-download
+    feature. The whole stack — ``HubResolver``, ``DownloadPlanner``, ``PackageDownloader`` (streaming,
+    HTTP Range-resume, sha256 verify-and-retry), ``PackageDownloadWorker``, ``ModelPackageInstaller`` —
+    was written, reviewed and JVM-tested against MockWebServer, and **could never have run on a
+    device**: the first real GET throws ``SecurityException``. MockWebServer talks to localhost from
+    the JVM, where no Android permission applies, so the test suite could not see it either.
+
+    That is the general shape worth guarding: a permission is invisible to every automated test that
+    is not an instrumented one, so nothing else in this repo can catch its absence.
+    """
+    manifest = REPO_ROOT / _SDK_MANIFEST
+    assert manifest.is_file(), f"{_SDK_MANIFEST} is missing — this guard would pass vacuously"
+    declared = set(
+        re.findall(r'<uses-permission\s+android:name="([^"]+)"', manifest.read_text(encoding="utf-8"))
+    )
+    assert declared, f"{_SDK_MANIFEST} declares no permissions at all — the guard would pass vacuously"
+
+    missing = {name: reason for name, reason in _REQUIRED_PERMISSIONS.items() if name not in declared}
+    assert not missing, (
+        f"{_SDK_MANIFEST} is missing permissions the library's OWN code needs. A consumer calling the "
+        "public facade cannot be expected to discover these, and no JVM test can catch their absence "
+        "— only a device run can:\n"
+        + "\n".join(f"  {name} — {reason}" for name, reason in sorted(missing.items()))
+    )
+
+
+# --- portability: no machine-specific absolute paths in tracked files ---------------------------
+
+#: Absolute paths that only resolve on one developer's machine. `/home/<user>` and `/Users/<user>`
+#: leak an identity and break for everyone else; `/opt/android-studio` is a *Linux Android Studio*
+#: install location that is simply absent on macOS, on a CI runner, and under any standalone JDK.
+_MACHINE_PATH_PATTERNS = (
+    re.compile(r"/home/[a-z][a-z0-9_-]*/"),
+    re.compile(r"/Users/[A-Za-z][A-Za-z0-9_-]*/"),
+    re.compile(r"/opt/android-studio"),
+)
+
+#: repo-relative path -> why this file is allowed to name one. **Deliberately tiny.** Each entry is a
+#: documented fallback of last resort, not a dependency: every one of them probes for a portable
+#: answer first and reaches the literal only when nothing else is found.
+_MACHINE_PATH_ALLOWLIST: dict[str, str] = {
+    "Makefile": "JAVA_HOME fallback, after probing PATH for a JDK 17+",
+    "scripts/lib/java_home.sh": "the shared JAVA_HOME probe — the one place the fallback is defined",
+    "spikes/genai_external_swap/README.md": "a spike's recorded command line, not a code path",
+    # A guard cannot avoid spelling out what it forbids: the patterns, the docstring explaining them
+    # and the can-it-fail samples all contain literal matches. This is gotcha 8 in the operational
+    # notes ("grep guards match docstrings") in its unavoidable form — hence the separate
+    # `test_the_machine_path_guard_can_actually_fail`, which is what keeps this file honest given
+    # that it exempts itself.
+    "tests/unit/test_guards.py": "defines the patterns and the samples proving they still match",
+}
+
+#: Extensions worth scanning. Binary and vendored trees are excluded by `git ls-files` naturally
+#: (they are gitignored), so this is about keeping the scan cheap and the failures readable.
+_MACHINE_PATH_SUFFIXES = (
+    ".py",
+    ".sh",
+    ".kt",
+    ".kts",
+    ".java",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cmake",
+    ".md",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".properties",
+    ".gradle",
+    ".xml",
+    ".cff",
+)
+
+
+def _tracked_files() -> list[str]:
+    """Tracked paths only. `git ls-files` rather than `rglob` so gitignored trees — `build/`, the
+    vendored `jniLibs/`, every `.venv` — are excluded by construction rather than by an exclude list
+    that rots. The same choice `tests/unit/test_docs.py` documents."""
+    out = subprocess.run(["git", "ls-files"], cwd=REPO_ROOT, capture_output=True, text=True, check=True)
+    return out.stdout.splitlines()
+
+
+def test_no_machine_specific_absolute_paths_in_tracked_files() -> None:
+    """A fresh clone on another machine must not inherit this one's filesystem layout.
+
+    Written for the portability pass: `/opt/android-studio/jbr` was the *only* JAVA_HOME fallback in
+    the Makefile and four scripts, so on macOS or a CI runner Gradle failed with a Java-version error
+    naming neither JAVA_HOME nor the file that set it. They now share `scripts/lib/java_home.sh`,
+    which probes PATH first — and this guard is what stops the literal spreading back out.
+
+    Verified able to fail: reverting any of those five files to its hardcoded form turns this red.
+    """
+    violations: list[str] = []
+    for rel in _tracked_files():
+        if not rel.endswith(_MACHINE_PATH_SUFFIXES) or rel in _MACHINE_PATH_ALLOWLIST:
+            continue
+        path = REPO_ROOT / rel
+        if not path.is_file():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        for lineno, line in enumerate(text.splitlines(), 1):
+            for pattern in _MACHINE_PATH_PATTERNS:
+                if pattern.search(line):
+                    violations.append(f"  {rel}:{lineno}: {line.strip()[:110]}")
+
+    assert not violations, (
+        "machine-specific absolute paths in tracked files — a fresh clone on another machine cannot "
+        "use these. Probe for the value (see scripts/lib/java_home.sh) or take it from the "
+        "environment; add to _MACHINE_PATH_ALLOWLIST only for a documented last-resort fallback:\n"
+        + "\n".join(violations)
+    )
+
+
+def test_machine_path_allowlist_entries_still_exist() -> None:
+    """A stale allow-list entry must fail, so this ratchet cannot silently rot."""
+    for rel in _MACHINE_PATH_ALLOWLIST:
+        assert (REPO_ROOT / rel).is_file(), (
+            f"_MACHINE_PATH_ALLOWLIST names {rel}, which no longer exists — drop the entry"
+        )
+
+
+def test_the_machine_path_guard_can_actually_fail() -> None:
+    """The guard's own regexes, exercised against a literal. A grep guard whose pattern silently
+    stopped matching passes forever and asserts nothing — the failure mode this repo calls
+    "scanning the void"."""
+    samples = ("/home/someone/Projects/x", "/Users/Someone/Projects/x", "/opt/android-studio/jbr")
+    for sample in samples:
+        assert any(p.search(sample) for p in _MACHINE_PATH_PATTERNS), f"no pattern matches {sample}"
+    assert not any(p.search("~/Android/Sdk") for p in _MACHINE_PATH_PATTERNS)
+    assert not any(p.search("$HOME/Android/Sdk") for p in _MACHINE_PATH_PATTERNS)
+
+
+# --- internal plan identifiers must not reach a reader ------------------------------------------
+
+#: `#12`, `#37` etc. — the numbering of this project's internal implementation plans. They are
+#: meaningless to anyone outside the build, and `agent_docs/` (where they were defined) is no longer
+#: even in the repository, so every one of them is now a reference to nothing.
+_PLAN_ID = re.compile(r"(^|[^0-9A-Za-z_&])#[0-9]{1,2}\b")
+
+#: Paths into the untracked planning material. These are dead references by construction.
+_PLAN_PATH = re.compile(r"agent_docs/|IMPLEMENTATION_ORDER|\d\d_code_plans/")
+
+#: Areas that are CLEAN and must stay clean. A hit here fails the build.
+#:
+#: These were chosen because they are what a reader outside this project actually encounters: the
+#: shipped documentation, the sample app that an integrator reads as the reference consumer, and —
+#: most importantly — anything a *user* can see at runtime.
+#: 2026-08-17, second pass: the first pass guarded `docs/` and the app and left everything else to
+#: the ratchet below — which covers `src`, `android/.../MobileTransformers/src` and `scripts` and
+#: therefore covered NONE of the repo root, the CI workflows, `config/` or `examples/`. The owner
+#: found `#35` still sitting in `pyproject.toml`. A ratchet only holds the ground it is pointed at,
+#: and "everything else" was nobody's ground. `"."` closes that: it scans tracked files at the repo
+#: ROOT plus any directory not otherwise listed, so a new top-level file is covered by default
+#: rather than by someone remembering to add it here.
+_PLAN_ID_CLEAN_AREAS = (
+    "docs",
+    "android/MobileTransformers/MobileTransformersApp/src/main",
+    ".github",
+    "config",
+    "examples",
+    ".",
+)
+
+#: repo-relative dir -> plan-identifier hits currently tolerated. ENTRIES MAY ONLY SHRINK.
+#:
+#: These are internal implementation comments. The 2026-08-17 pass cleaned the reader-facing surfaces
+#: above and stopped there, deliberately: mechanically deleting `(#8 schema)` from prose leaves
+#: `(schema)`, and a whole-tree regex rewrite of comments was attempted on 2026-08-16 and had to be
+#: fully reverted — a test suite cannot validate a rewrite of comments, because comments do not affect
+#: behaviour, so every gate stayed green over 300 files of mangled prose. Each of these is a sentence
+#: that has to be re-written by a human, not a substitution.
+#:
+#: The ratchet's job is that the numbers only fall.
+_PLAN_ID_ALLOWLIST: dict[str, int] = {
+    "src": 175,
+    "android/MobileTransformers/MobileTransformers/src": 383,
+    # 18 -> 17: `device_package.sh` printed one to an operator's terminal on every run, which made it
+    # program output rather than an internal comment. Fixed at the source and the allowance lowered
+    # with it, which is the only way this ratchet stays honest.
+    "scripts": 17,
+}
+
+#: File types this guard reads.
+#:
+#: The 2026-08-17 first pass omitted `.toml`, `.yml`, `.yaml`, `.json`, `.properties` and `.cff` — so
+#: `pyproject.toml` and all three CI workflows were **structurally invisible** to it. The guard read
+#: as if it covered the repo and did not, which is worse than an absent guard: the owner found `#35`
+#: in `pyproject.toml` by eye, on a tree this test had just passed.
+#:
+#: The lesson is the one this repo keeps relearning about ratchets — a scan is only as wide as its
+#: filter, and a filter that silently excludes is indistinguishable from a clean result. Any config
+#: format that carries comments belongs here.
+_PLAN_ID_SUFFIXES = (
+    ".py",
+    ".kt",
+    ".kts",
+    ".java",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".md",
+    ".sh",
+    ".xml",
+    ".txt",
+    ".toml",
+    ".yml",
+    ".yaml",
+    ".json",
+    ".properties",
+    ".cff",
+    ".cmake",
+    "Makefile",
+    "CMakeLists.txt",
+)
+
+
+def _scan_tracked(area: str, pattern: re.Pattern[str]) -> list[str]:
+    """`pattern` hits in TRACKED files under `area`, as `path:line: text`.
+
+    Tracked-only, via `git ls-files`, and the reason is a bug this guard shipped with for one run: an
+    `rglob` sweep read `android/**/build/tmp/kapt3/stubs/**/*.java` — generated Kotlin stubs that
+    copy every KDoc comment verbatim — and reported ~60 phantom hits in build output nobody can edit.
+    Anything gitignored is out by construction, which is the same choice `test_docs.py` documents.
+    """
+    prefix = "" if area == "." else f"{area}/"
+    hits: list[str] = []
+    for rel in _tracked_files():
+        if not rel.startswith(prefix) or not rel.endswith(_PLAN_ID_SUFFIXES):
+            continue
+        path = REPO_ROOT / rel
+        if not path.is_file():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            continue
+        for lineno, line in enumerate(text.splitlines(), 1):
+            if pattern.search(line):
+                hits.append(f"  {rel}:{lineno}: {line.strip()[:100]}")
+    return hits
+
+
+#: Trees whose plan-identifier debt is ACCEPTED and tracked by `_PLAN_ID_ALLOWLIST` instead, plus the
+#: gate spikes. Excluded from the repo-root sweep so the two do not double-report the same lines.
+#:
+#: `spikes/` is deliberately out of both: they are recorded gate experiments, referenced from the
+#: operational notes by the identifiers they were run under, and rewriting that prose would make the
+#: record harder to follow rather than easier.
+_PLAN_ID_ROOT_EXCLUDES = (
+    "src/",
+    "android/",
+    "scripts/",
+    "docs/",
+    "tests/",
+    "spikes/",
+    "research/",
+    ".github/",
+    "config/",
+    "examples/",
+)
+
+
+def _plan_id_hits(area: str) -> list[str]:
+    hits = _scan_tracked(area, _PLAN_ID)
+    if area == ".":
+        hits = [h for h in hits if not h.strip().startswith(_PLAN_ID_ROOT_EXCLUDES)]
+    return hits
+
+
+@pytest.mark.parametrize("area", _PLAN_ID_CLEAN_AREAS)
+def test_no_plan_identifiers_in_reader_facing_areas(area: str) -> None:
+    """The shipped docs and the sample app must not cite this project's internal plan numbering."""
+    if not (REPO_ROOT / area).is_dir():
+        pytest.skip(f"{area} not present in this checkout")
+    hits = _plan_id_hits(area)
+    assert not hits, (
+        f"internal plan identifiers in {area} — these mean nothing to a reader and point at "
+        "`agent_docs/`, which is not in the repository. Rewrite the sentence without the "
+        "identifier:\n" + "\n".join(hits)
+    )
+
+
+def test_no_plan_identifiers_in_user_visible_strings() -> None:
+    """The strongest form of this rule: a *user* must never see one.
+
+    Three did reach here — one of them inside `ModelNotInstalledException`'s message, which is a
+    string an integrator hits on their first wrong call.
+
+    Two output surfaces, because a user is a user whichever one they are looking at:
+
+    - **Kotlin string literals** in `main` source sets, where every user-facing SDK message lives.
+    - **`echo` in shell scripts.** `device_package.sh` printed "staging the #10 GenAI spike dir" to
+      an operator's terminal on every run. That is output, not a comment — so the decision to leave
+      the *comments* alone does not cover it, and the Kotlin-only scan could never have seen it.
+    """
+    android = REPO_ROOT / "android"
+    scripts = REPO_ROOT / "scripts"
+    if not android.is_dir() and not scripts.is_dir():
+        pytest.skip("neither Android sources nor scripts present in this checkout")
+
+    literal = re.compile(r'"[^"\n]*"')
+    hits: list[str] = []
+
+    for path in sorted(android.rglob("src/main/**/*.kt")) if android.is_dir() else []:
+        for lineno, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+            for match in literal.findall(line):
+                # `"#$rank"` and friends are Kotlin string templates rendering a real number.
+                if _PLAN_ID.search(match) and "$" not in match:
+                    hits.append(f"  {path.relative_to(REPO_ROOT)}:{lineno}: {match[:100]}")
+
+    # Whole `echo`/`printf` lines rather than quoted spans: shell quoting is too varied to parse,
+    # and an unquoted `echo >> #12 ...` is just as visible to the operator as a quoted one.
+    emits = re.compile(r"^\s*(echo|printf)\s")
+    for path in sorted(scripts.rglob("*.sh")) if scripts.is_dir() else []:
+        for lineno, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+            if emits.match(line) and _PLAN_ID.search(line):
+                hits.append(f"  {path.relative_to(REPO_ROOT)}:{lineno}: {line.strip()[:100]}")
+
+    assert not hits, "a plan identifier is reachable in a user-visible string:\n" + "\n".join(hits)
+
+
+def test_no_dead_references_to_the_untracked_planning_material() -> None:
+    """`agent_docs/` was untracked on 2026-08-17, so any pointer to it from shipped code is dead.
+
+    Covers the plan directories too (`00_code_plans/…`, `IMPLEMENTATION_ORDER`): they live in the same
+    untracked tree, so a comment citing one sends a reader to an address that does not exist in the
+    repository they cloned.
+
+    `tests/` is exempt because several of its comments *explain* the untracking and necessarily name
+    the directory — the same unavoidable self-reference the machine-path guard has.
+
+    **Scans EVERY tracked file.** It used to scan `src`, `docs`, `scripts`, `android` and two files at
+    the root, and three live dead pointers survived in the gap: `research/genai/README.md` (a shipped
+    README citing a plan document), `third_party/onnxruntime/BUILD.md`, and a CHANGELOG line telling
+    the reader to "see" a file nobody who clones can open. A guard whose scope is an enumerated list
+    of the places you happened to think of reports green about everywhere else.
+    """
+    # `.gitignore` and CHANGELOG describe the untracking itself and cannot do so without naming the
+    # directory. Everything else in the tree is fair game.
+    exempt_prefixes = ("tests/", ".gitignore", "CHANGELOG.md")
+    hits = [h for h in _scan_tracked(".", _PLAN_PATH) if not h.strip().startswith(exempt_prefixes)]
+    assert not hits, (
+        "reference(s) to the untracked planning material from shipped files. That tree is not in the "
+        "repository, so these point at nothing for anyone who clones it:\n" + "\n".join(hits)
+    )
+
+
+def test_plan_identifier_debt_only_shrinks() -> None:
+    """Internal comments still carry them; the count may only fall. See `_PLAN_ID_ALLOWLIST`."""
+    for area, allowed in _PLAN_ID_ALLOWLIST.items():
+        if not (REPO_ROOT / area).is_dir():
+            continue
+        actual = len(_plan_id_hits(area))
+        assert actual <= allowed, (
+            f"{area}: {actual} plan identifiers, allowance {allowed} — a NEW one was introduced. "
+            "Write the comment without the identifier."
+        )
+        assert actual == allowed, (
+            f"{area}: down to {actual} plan identifiers (allowance {allowed}) — lower "
+            "_PLAN_ID_ALLOWLIST so the ratchet holds"
+        )
+
+
+# --- every `uv run` in a workflow must be `--frozen` -------------------------------------------
+
+#: A `uv run` invocation whose flags do not include `--frozen`.
+#:
+#: Deliberately matches the *invocation*, not the words "uv run" anywhere: the `#` lines in
+#: `checks.yml` and the `Makefile` explain this exact trap in prose, and a guard that fires on its
+#: own rationale is a guard nobody can keep.
+_BARE_UV_RUN = re.compile(r"(?<!\S)uv run(?!\S)")
+
+
+def _uv_run_invocations(text: str) -> list[tuple[int, str]]:
+    """`(lineno, line)` for each YAML line that RUNS `uv run` — comments excluded."""
+    found: list[tuple[int, str]] = []
+    for lineno, line in enumerate(text.splitlines(), 1):
+        stripped = line.strip()
+        if stripped.startswith("#") or not _BARE_UV_RUN.search(line):
+            continue
+        found.append((lineno, stripped))
+    return found
+
+
+def test_every_uv_run_in_a_workflow_is_frozen() -> None:
+    """A bare `uv run` in CI fails on a wheel the job never needed.
+
+    `[tool.uv.sources]` points `onnxruntime-training` at `third_party/wheels/…whl`, which is
+    git-ignored and 662 MB. A bare `uv run` validates every source in the lock *before* executing,
+    so a runner without that wheel dies with "failed to query metadata of file … No such file or
+    directory" — on the docs gate, which has nothing to do with training. That is exactly how the
+    `python (lint, typecheck, parity, guards, tests)` job failed on 2026-08-17.
+
+    The Makefile solved this with `$(UVRUN) := uv run --frozen`; the workflows call `uv` directly
+    and had no equivalent. This is that equivalent.
+
+    Verified able to fail: dropping `--frozen` from either docs-gate step turns this red.
+    """
+    workflows = sorted((REPO_ROOT / ".github" / "workflows").glob("*.yml"))
+    assert workflows, ".github/workflows holds no .yml files — this guard is scanning the void"
+    violations: list[str] = []
+    for path in workflows:
+        for lineno, line in _uv_run_invocations(path.read_text(encoding="utf-8")):
+            if "--frozen" not in line:
+                violations.append(f"  .github/workflows/{path.name}:{lineno}: {line[:110]}")
+    assert not violations, (
+        "`uv run` without `--frozen` in a workflow. The lock is committed and covers every profile, "
+        "so there is nothing to re-resolve — and re-resolving reads a git-ignored 662 MB wheel that "
+        "no runner has:\n" + "\n".join(violations)
+    )
+
+
+def test_the_uv_run_guard_can_actually_fail() -> None:
+    """The guard's own matcher, exercised. A pattern that silently stopped matching passes forever."""
+    assert _uv_run_invocations("        run: uv run pytest -q\n")
+    assert _uv_run_invocations("        run: uv run --frozen pytest -q\n")
+    # A comment explaining the trap must not register as an invocation, or the two files that
+    # document it could never mention it.
+    assert not _uv_run_invocations("# a bare `uv run` validates every source in the lock\n")
+    # Nor may a longer flag swallow the match.
+    assert not _uv_run_invocations("        run: uv running-shoes\n")
diff --git a/tests/unit/test_handoff_map.py b/tests/unit/test_handoff_map.py
new file mode 100644
index 0000000..edd5a0e
--- /dev/null
+++ b/tests/unit/test_handoff_map.py
@@ -0,0 +1,429 @@
+"""Unit tests for HandoffMap.validate() invariants + the canonical check_compat (#8)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.handoff_map import (
+    ALREADY_TRANSPOSED,
+    HANDOFF_MAP_READER_VERSION,
+    HandoffEntry,
+    HandoffMap,
+    TrainableTensorCodec,
+    derive_transpose_policy,
+)
+from mobiletransformers.artifacts.versioning import SchemaVersionError, check_compat
+from mobiletransformers.config.constants import HandoffMode
+from mobiletransformers.exceptions import HandoffError
+
+_CASES = json.loads((Path(__file__).parent.parent / "fixtures" / "check_compat_cases.json").read_text())[
+    "cases"
+]
+
+
+def _good_entry(idx: int = 0) -> HandoffEntry:
+    name = f"model.layers.{idx}.attn.q_proj.MatMul.weight"
+    return HandoffEntry(
+        training_base_layer_name=f"backbone.model.layers.{idx}.self_attn.q_proj.base_layer",
+        dtype="float16",
+        shape=(4096, 4096),
+        merged_tensor_names={"weight": name},
+        inference_initializer_names={"weight": name},
+        external_data_location={"weight": name + ".bin"},
+    )
+
+
+# --- check_compat (shared cross-language fixture) --------------------------------------------------
+@pytest.mark.parametrize("case", _CASES, ids=[c["why"] for c in _CASES])
+def test_check_compat_matches_shared_fixture(case: dict) -> None:
+    if case["expect"] == "accept":
+        check_compat(case["doc"], case["minReader"], case["reader"])  # must not raise
+    else:
+        with pytest.raises(SchemaVersionError):
+            check_compat(case["doc"], case["minReader"], case["reader"])
+
+
+def test_reader_version_tracks_the_schema_minor() -> None:
+    """1.1 added `adapterDtypes`/`adapterShapes`, which is ADDITIVE.
+
+    `minReaderVersion` deliberately stays 1.0: a 1.0 reader ignores unknown fields by the canonical
+    rule and keeps working, and maps written at 1.0 still load (they simply cannot describe their
+    adapter factors, which `codec_tensor_specs` reports as a fail-closed error rather than a guess).
+    """
+    assert HANDOFF_MAP_READER_VERSION == "1.1"
+    assert HandoffMap().schema_version == "1.1"
+    assert HandoffMap().min_reader_version == "1.0"
+
+
+# --- validate() invariants ------------------------------------------------------------------------
+def test_valid_external_initializer_map_passes() -> None:
+    HandoffMap(entries=[_good_entry(0), _good_entry(1)]).validate()
+
+
+def test_merged_must_equal_inference_name() -> None:
+    e = _good_entry()
+    e.merged_tensor_names = {"weight": "model.layers.0.attn.q_proj.MatMul.WRONG"}
+    with pytest.raises(HandoffError, match="mergedTensorNames"):
+        HandoffMap(entries=[e]).validate()
+
+
+def test_quantized_scale_from_base_layer_name_is_rejected() -> None:
+    # The documented bug: scale derived from base_layer_name instead of the observed inference init.
+    seed = "model.layers.0.attn.q_proj.MatMul"
+    e = HandoffEntry(
+        training_base_layer_name="backbone.model.layers.0.self_attn.q_proj.base_layer",
+        dtype="int4",
+        shape=(4096, 2048),
+        merged_tensor_names={
+            "weight_quantized": f"{seed}.qweight",
+            "scale": f"{seed}.scales",
+            "zero_point": f"{seed}.qzeros",
+        },
+        inference_initializer_names={
+            "weight_quantized": f"{seed}.qweight",
+            "scale": f"{seed}.scales",
+            "zero_point": f"{seed}.qzeros",
+        },
+        external_data_location={
+            "weight_quantized": f"{seed}.qweight.bin",
+            "scale": f"{seed}.scales.bin",
+            "zero_point": f"{seed}.qzeros.bin",
+        },
+        quantization={
+            "weightQuantizedName": f"{seed}.qweight",
+            # BUG: derived from base_layer_name, not the observed inference init
+            "scaleName": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight_scale",
+            "zeroPointName": f"{seed}.qzeros",
+        },
+    )
+    with pytest.raises(HandoffError, match="not derived from base_layer_name"):
+        HandoffMap(entries=[e]).validate()
+
+
+# --- per-role on-disk dtype/shape (the raw-bytes device loader's only source) ----------------------
+def test_per_role_dtype_shape_round_trip() -> None:
+    e = _good_entry()
+    e.tensor_dtypes = {"weight": "float16"}
+    e.tensor_shapes = {"weight": (4096, 4096)}
+    restored = HandoffEntry.from_dict(e.to_dict())
+    assert restored.tensor_dtypes == {"weight": "float16"}
+    assert restored.tensor_shapes == {"weight": (4096, 4096)}
+    assert restored.dtype_for("weight") == "float16"
+    assert restored.shape_for("weight") == (4096, 4096)
+
+
+def test_per_role_lookup_falls_back_to_entry_level() -> None:
+    """Maps written before tensorDtypes/tensorShapes existed still resolve their single role."""
+    e = _good_entry()
+    assert not e.tensor_dtypes and not e.tensor_shapes
+    assert e.dtype_for("weight") == "float16"
+    assert e.shape_for("weight") == (4096, 4096)
+
+
+def test_tensor_specs_report_each_roles_own_dtype_and_shape() -> None:
+    """A scale tensor is not shaped like the weight it scales — reporting the weight's was wrong."""
+    e = _good_entry()
+    seed = "model.layers.0.attn.q_proj.MatMul"
+    e.merged_tensor_names = {"weight_quantized": f"{seed}.qweight", "scale": f"{seed}.scales"}
+    e.inference_initializer_names = dict(e.merged_tensor_names)
+    e.external_data_location = {r: f"{n}.bin" for r, n in e.merged_tensor_names.items()}
+    e.tensor_dtypes = {"weight_quantized": "uint8", "scale": "float16"}
+    e.tensor_shapes = {"weight_quantized": (4096, 2048), "scale": (4096, 32)}
+
+    by_role = {spec.role: spec for spec in e.tensor_specs()}
+    assert (by_role["weight_quantized"].dtype, by_role["weight_quantized"].shape) == (
+        "uint8",
+        (4096, 2048),
+    )
+    assert (by_role["scale"].dtype, by_role["scale"].shape) == ("float16", (4096, 32))
+
+
+def test_role_missing_per_role_dtype_is_rejected() -> None:
+    e = _good_entry()
+    e.tensor_shapes = {"weight": (4096, 4096)}  # shapes declared, dtypes not
+    with pytest.raises(HandoffError, match="missing tensorDtypes"):
+        HandoffMap(entries=[e]).validate()
+
+
+def test_quantized_entry_without_per_role_dtype_shape_is_rejected() -> None:
+    """The entry-level dtype/shape describes only the weight-like role, so it cannot stand in here."""
+    seed = "model.layers.0.attn.q_proj.MatMul"
+    e = _good_entry()
+    e.merged_tensor_names = {
+        "weight_quantized": f"{seed}.qweight",
+        "scale": f"{seed}.scales",
+        "zero_point": f"{seed}.qzeros",
+    }
+    e.inference_initializer_names = dict(e.merged_tensor_names)
+    e.external_data_location = {r: f"{n}.bin" for r, n in e.merged_tensor_names.items()}
+    e.quantization = {
+        "weightQuantizedName": f"{seed}.qweight",
+        "scaleName": f"{seed}.scales",
+        "zeroPointName": f"{seed}.qzeros",
+    }
+    with pytest.raises(HandoffError, match="must declare per-role tensorDtypes/tensorShapes"):
+        HandoffMap(entries=[e]).validate()
+
+
+def test_duplicate_external_location_rejected() -> None:
+    a, b = _good_entry(0), _good_entry(1)
+    b.external_data_location = dict(a.external_data_location)  # collide
+    with pytest.raises(HandoffError, match="duplicate externalDataLocation"):
+        HandoffMap(entries=[a, b]).validate()
+
+
+def test_duplicate_inference_name_rejected() -> None:
+    a, b = _good_entry(0), _good_entry(1)
+    b.inference_initializer_names = dict(a.inference_initializer_names)
+    b.merged_tensor_names = dict(a.merged_tensor_names)
+    with pytest.raises(HandoffError, match="duplicate inferenceInitializerName"):
+        HandoffMap(entries=[a, b]).validate()
+
+
+def test_model_input_mode_fails_closed_v1() -> None:
+    with pytest.raises(HandoffError, match="not supported"):
+        HandoffMap(entries=[_good_entry()], handoff_mode=HandoffMode.MODEL_INPUT).validate()
+
+
+def test_adapter_mode_fails_closed_v1() -> None:
+    with pytest.raises(HandoffError, match="not supported"):
+        HandoffMap(entries=[_good_entry()], handoff_mode=HandoffMode.ADAPTER).validate()
+
+
+def test_unsupported_major_fails_closed() -> None:
+    with pytest.raises(SchemaVersionError):
+        HandoffMap(entries=[_good_entry()], schema_version="2.0").validate()
+
+
+def test_save_load_round_trip(tmp_path: Path) -> None:
+    path = tmp_path / "weight_handoff_map.json"
+    HandoffMap(entries=[_good_entry(0), _good_entry(1)]).save(path)
+    loaded = HandoffMap.load(path)
+    assert len(loaded.entries) == 2
+    assert loaded.handoff_mode == HandoffMode.EXTERNAL_INITIALIZER
+
+
+class _ArchSpec:
+    """Minimal stand-in for the #6 architecture-registry row (only the rewrite field is read)."""
+
+    def __init__(self, attention_module_name: str = "self_attn") -> None:
+        self.attention_module_name = attention_module_name
+
+
+def test_candidate_seeds_cover_both_attention_spellings():
+    """Two inference exporters name the attention module differently; the seed must accept both.
+
+    The legacy `inference/builder.py` graphs (and the `weight_merger.cpp:904` mirror) use `attn`;
+    the Optimum export that #7 made the front door keeps HF-canonical `self_attn`. Seeding only the
+    rewritten spelling meant no trainable tensor in an Optimum-produced package could ever be matched,
+    so `export_inference_package` failed with "inference/training naming drifted" and no handoff map
+    could be built for the packages the project actually ships.
+    """
+    seeds = TrainableTensorCodec.candidate_inference_names(
+        "backbone.model.layers.0.self_attn.q_proj.base_layer", _ArchSpec()
+    )
+    assert "model.layers.0.attn.q_proj.MatMul" in seeds
+    assert "model.layers.0.self_attn.q_proj.MatMul" in seeds
+
+
+def test_canonical_name_still_returns_the_cpp_mirror_spelling():
+    """`canonical_inference_name` is mirrored in C++, so its result must not change."""
+    assert (
+        TrainableTensorCodec.canonical_inference_name(
+            "backbone.model.layers.0.self_attn.q_proj.base_layer", _ArchSpec()
+        )
+        == "model.layers.0.attn.q_proj.MatMul"
+    )
+
+
+def test_candidate_seeds_are_deduped_when_the_module_is_already_attn():
+    seeds = TrainableTensorCodec.candidate_inference_names(
+        "model.layers.0.attn.q_proj.base_layer", _ArchSpec(attention_module_name="attn")
+    )
+    assert seeds == ("model.layers.0.attn.q_proj.MatMul",)
+
+
+# --- transpose policy: observed, not declared (2026-08-14) -------------------------------------
+
+
+def test_transpose_policy_is_observed_from_the_adapter_and_weight_shapes() -> None:
+    """The orientation of the on-disk weight must be *derived*, never defaulted.
+
+    Regression guard for the most expensive defect this project has had. ``ObservedInit.transposed``
+    was a declared field nothing ever assigned, so ``transposePolicy`` was ``no_transpose`` by
+    omission on every package ever produced. The on-device merge honoured it and wrote every merged
+    weight TRANSPOSED, which is invisible to shape checks (``q_proj`` is square), to element counts
+    (``v_proj`` has the same count either way) and to L2/absmax (both transpose-invariant).
+
+    The shapes below are the real ones from a SmolLM2-135M export.
+    """
+    from mobiletransformers.artifacts.handoff_map import (
+        ALREADY_TRANSPOSED,
+        NO_TRANSPOSE,
+        derive_transpose_policy,
+    )
+
+    lora = {"adapter_A": (8, 576), "adapter_B": (192, 8)}
+    # v_proj: B @ A is (192, 576) while the graph stores (576, 192) -> the on-disk tensor IS the
+    # transpose. This is the case that was silently wrong.
+    assert derive_transpose_policy((576, 192), lora) == ALREADY_TRANSPOSED
+    # ... and the same factors against a weight already in merger orientation need no conversion.
+    assert derive_transpose_policy((192, 576), lora) == NO_TRANSPOSE
+
+    # Square weights genuinely cannot decide their own orientation; the function must not pretend to.
+    square = {"adapter_A": (8, 576), "adapter_B": (576, 8)}
+    assert derive_transpose_policy((576, 576), square) == NO_TRANSPOSE
+
+    # Undescribed adapters -> nothing observable, keep the historical value rather than invent one.
+    assert derive_transpose_policy((4, 3), {}) == NO_TRANSPOSE
+
+
+def test_a_delta_that_cannot_be_added_to_its_weight_is_refused() -> None:
+    """Factors whose product is neither the weight shape nor its transpose are incoherent.
+
+    The merge would be adding tensors that cannot be added, so the map must refuse to describe the
+    layer rather than emit a contract no consumer can honour.
+    """
+    from mobiletransformers.artifacts.handoff_map import derive_transpose_policy
+
+    with pytest.raises(ValueError, match="neither the on-disk weight shape"):
+        derive_transpose_policy((10, 20), {"adapter_A": (8, 576), "adapter_B": (192, 8)})
+
+
+def test_one_package_cannot_mix_two_weight_orientations() -> None:
+    """A square layer inherits the orientation the non-square layers prove; disagreement fails closed."""
+    from mobiletransformers.artifacts.handoff_map import (
+        ALREADY_TRANSPOSED,
+        NO_TRANSPOSE,
+        HandoffEntry,
+        resolve_package_transpose_policy,
+    )
+
+    def entry(shape: tuple[int, int], policy: str, adapters: bool = True) -> HandoffEntry:
+        return HandoffEntry(
+            training_base_layer_name="l",
+            dtype="float32",
+            shape=shape,
+            tensor_dtypes={"weight": "float32"},
+            tensor_shapes={"weight": shape},
+            checkpoint_names={"weight": "w"},
+            adapter_dtypes={},
+            adapter_shapes={"adapter_A": (8, 576), "adapter_B": (192, 8)} if adapters else {},
+            merger_output_names={"weight": "merged_weight"},
+            merged_tensor_names={"weight": "w"},
+            inference_initializer_names={"weight": "w"},
+            external_data_location={"weight": "w.bin"},
+            transpose_policy=policy,
+        )
+
+    # One decidable (non-square) entry settles the package, including for the square one.
+    decided = [entry((576, 192), ALREADY_TRANSPOSED), entry((576, 576), NO_TRANSPOSE)]
+    assert resolve_package_transpose_policy(decided) == ALREADY_TRANSPOSED
+
+    # Two non-square entries that disagree cannot both be right.
+    with pytest.raises(ValueError, match="disagree about weight orientation"):
+        resolve_package_transpose_policy(
+            [entry((576, 192), ALREADY_TRANSPOSED), entry((192, 576), NO_TRANSPOSE)]
+        )
+
+    # Nothing decidable -> the historical default, not a guess.
+    assert resolve_package_transpose_policy([entry((576, 576), NO_TRANSPOSE, adapters=False)]) == NO_TRANSPOSE
+
+
+def test_the_derivation_agrees_with_a_real_exported_package() -> None:
+    """Run the derivation over a REAL export's shapes, not a fixture the same author invented.
+
+    The three tests above use synthetic shapes, so they prove the function is self-consistent — not
+    that it describes a package this project actually produces. That gap is how the original defect
+    survived: the fixtures agreed with the broken code because both said ``no_transpose``.
+
+    This reads whatever export is on disk (skipping when there is none, so it never blocks a clean
+    checkout) and asserts the derivation reaches ``already_transposed_for_inference`` — the same
+    answer ``weight_merger.cpp`` independently *observes* at merge time from the tensors themselves
+    (logged as ``merge orientation: transpose_for_inference=1``). Two implementations in two languages
+    agreeing on real data is the assertion; a change that breaks either side breaks the agreement.
+    """
+    import json
+
+    maps = sorted(Path("build").glob("**/weight_handoff_map.json"))
+    if not maps:
+        pytest.skip("no exported package on disk (run scripts/device_package.sh)")
+
+    from mobiletransformers.artifacts.handoff_map import (
+        ALREADY_TRANSPOSED,
+        derive_transpose_policy,
+    )
+
+    # Take the first package that can actually ANSWER the question, not simply the first on disk.
+    #
+    # Orientation is only observable from a non-square adapted weight, and two real cases produce
+    # none: an encoder whose attention projections are square (all-MiniLM-L6-v2 adapts
+    # `query`/`value` at 384x384), and a package exported for inference only, whose map has no
+    # entries at all. Both are perfectly good packages — they just cannot settle this question — so
+    # picking `maps[0]` made the suite's result depend on which export happened to sort first.
+    chosen: Path | None = None
+    entries: list = []
+    for candidate in maps:
+        rows = json.loads(candidate.read_text()).get("entries") or []
+        if any(e["shape"][0] != e["shape"][1] for e in rows):
+            chosen, entries = candidate, rows
+            break
+    if chosen is None:
+        pytest.skip(
+            "no export on disk has a non-square adapted weight, so orientation is unobservable "
+            f"(looked at {len(maps)} package(s))"
+        )
+
+    # The square layers (q_proj, [576,576]) genuinely cannot be decided alone and must NOT be
+    # over-claimed; the non-square ones (v_proj) are what settles the package.
+    decidable = {
+        e["inferenceInitializerNames"]["weight"]: derive_transpose_policy(e["shape"], e["adapterShapes"])
+        for e in entries
+        if e["shape"][0] != e["shape"][1]
+    }
+    assert decidable, "export has no non-square adapted weight, so orientation is unobservable"
+    assert set(decidable.values()) == {ALREADY_TRANSPOSED}, (
+        f"derivation disagrees with the orientation the device merge observes: {decidable}"
+    )
+
+
+def test_mars_orientation_is_observed_not_defaulted() -> None:
+    """MARS names its down-projection `shared_A`; orientation must still be observed.
+
+    The regression this pins: `derive_transpose_policy` read only `adapter_A`, so every MARS layer
+    fell through to the "nothing to observe" branch and declared `no_transpose` — for shapes that
+    decide the question unambiguously. A consumer honouring that value would write every merged
+    weight transposed, which is the exact defect this function exists to prevent, re-introduced
+    through a naming difference rather than an unassigned field.
+
+    Real shapes, from `mobiletransformers/gemma-3-270m-it` (the first MARS package published).
+    """
+    # q_proj: [640, 1024] on disk; B @ A = [1024, 8] @ [8, 640] = [1024, 640] — the reverse.
+    assert (
+        derive_transpose_policy((640, 1024), {"adapter_B": (1024, 8), "shared_A": (8, 640)})
+        == ALREADY_TRANSPOSED
+    )
+    # v_proj: [640, 256] on disk; B @ A = [256, 8] @ [8, 640] = [256, 640] — also the reverse.
+    assert (
+        derive_transpose_policy((640, 256), {"adapter_B": (256, 8), "shared_A": (8, 640)})
+        == ALREADY_TRANSPOSED
+    )
+    # And the LoRA spelling still resolves the same way, so the fix did not move the other convention.
+    assert (
+        derive_transpose_policy((576, 192), {"adapter_A": (8, 576), "adapter_B": (192, 8)})
+        == ALREADY_TRANSPOSED
+    )
+
+
+def test_an_unknown_down_projection_name_refuses_rather_than_defaulting() -> None:
+    """A third naming convention must fail loudly, not silently declare `no_transpose`.
+
+    The whole family of defects here is "a value nobody computed, honoured by a consumer". Returning
+    a default for shapes we simply failed to parse is how that happens, so this path raises and names
+    the keys it saw.
+    """
+    with pytest.raises(ValueError, match="down-projection"):
+        derive_transpose_policy((640, 1024), {"adapter_B": (1024, 8), "future_A": (8, 640)})
diff --git a/tests/unit/test_import_compat.py b/tests/unit/test_import_compat.py
new file mode 100644
index 0000000..6a193d5
--- /dev/null
+++ b/tests/unit/test_import_compat.py
@@ -0,0 +1,18 @@
+"""Import smoke for the package itself.
+
+The legacy-shim tests that lived here were deleted with the shims (`trainer/`, `artifact/`,
+`inference/`, `tools/`, `peft_models/`, `database/`, `evaluation/` in S9; root `config.py` on
+2026-08-14). Their coverage moved, and got stronger: `test_symbol_golden.py` proves every public
+symbol survived to its new home (including the two modules that were SPLIT across files, which no
+shim test ever checked as a union), `test_no_src_to_legacy_imports.py` keeps both allow-lists empty,
+and `test_import_weight.py` proves the built wheel is self-contained.
+"""
+
+
+def test_mobiletransformers_imports():
+    import mobiletransformers
+
+    # The version is asserted against pyproject.toml (the single write-site) in test_version_sites.py;
+    # hardcoding it here made a THIRD place to update on every release.
+    assert isinstance(mobiletransformers.__version__, str)
+    assert mobiletransformers.__version__
diff --git a/tests/unit/test_import_weight.py b/tests/unit/test_import_weight.py
new file mode 100644
index 0000000..7bb330e
--- /dev/null
+++ b/tests/unit/test_import_weight.py
@@ -0,0 +1,100 @@
+"""`import mobiletransformers` must stay cheap.
+
+The package deliberately defers every heavy dependency: the CLI has to start, `--dry-run` has to work,
+and `make check` has to run in a core environment with no torch, no onnxruntime and no optimum. The
+legacy roots do the opposite — `trainer/builder.py` imports torch at module level,
+`trainer/utils.py` imports `deepeval.benchmarks`, `database/vector_entity.py` star-imports objectbox —
+so moving them into the package is exactly the change most likely to break this, silently, by making
+the top-level import drag one of them in.
+
+A subprocess is used because pytest has already imported plenty by the time a test runs; only a fresh
+interpreter can answer "what does importing this package alone cost?".
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+#: Importing the package must not pull any of these in.
+HEAVY = (
+    "torch",
+    "onnxruntime",
+    "optimum",
+    "transformers",
+    "peft",
+    "deepeval",
+    "objectbox",
+    "tensorflow",
+    "flwr",
+    "safetensors",
+)
+
+_PROBE = """
+import json, sys
+import mobiletransformers  # noqa: F401
+print(json.dumps(sorted(m for m in sys.modules if "." not in m)))
+"""
+
+
+def _top_level_modules_after_import() -> set[str]:
+    result = subprocess.run(
+        [sys.executable, "-c", _PROBE], capture_output=True, text=True, cwd=REPO_ROOT, check=False
+    )
+    assert result.returncode == 0, f"importing mobiletransformers failed:\n{result.stderr}"
+    return set(json.loads(result.stdout.strip().splitlines()[-1]))
+
+
+def test_importing_the_package_pulls_in_no_heavy_dependency() -> None:
+    loaded = _top_level_modules_after_import()
+    leaked = sorted(set(HEAVY) & loaded)
+    assert not leaked, (
+        f"`import mobiletransformers` now pulls in {leaked}. Move that import inside the function "
+        "that needs it (see the `# noqa: PLC0415` lazy-import convention used throughout the package)."
+    )
+
+
+def test_cli_help_runs_without_the_heavy_profiles() -> None:
+    """The CLI must be usable in the core env — `--help` importing torch would be a regression."""
+    result = subprocess.run(
+        [sys.executable, "-m", "mobiletransformers.cli.main", "--help"],
+        capture_output=True,
+        text=True,
+        cwd=REPO_ROOT,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
+    assert "export" in result.stdout
+
+
+def test_placeholder_subpackages_stay_empty_until_they_are_migrated() -> None:
+    """The Migration Map's target subpackages are empty placeholders.
+
+    When one gains content it must also gain a `MODULE_LOCATIONS` entry in `test_symbol_golden.py`;
+    this catches code landing there without the move being recorded.
+    """
+    from tests.fixtures.symbol_tools import public_symbols
+    from tests.unit.test_symbol_golden import MIGRATED_PATHS, MODULE_LOCATIONS
+
+    targets = ("peft", "training", "inference", "rag", "evaluation")
+    recorded = set(MODULE_LOCATIONS.values()) | MIGRATED_PATHS
+    for name in targets:
+        package = REPO_ROOT / "src" / "mobiletransformers" / name
+        if not package.is_dir():
+            continue
+        for module in sorted(package.rglob("*.py")):
+            rel = str(module.relative_to(REPO_ROOT))
+            if module.name == "__init__.py" and not public_symbols(module):
+                # A placeholder, or a package `__init__.py` that only carries a docstring. Neither
+                # defines a symbol, so there is nothing for the symbol golden to follow — and a
+                # migrated subpackage SHOULD get a docstring explaining what it now owns. The check
+                # is about code landing here unrecorded, which `public_symbols` measures directly.
+                continue
+            assert rel in recorded, (
+                f"{rel} exists but is recorded in neither MODULE_LOCATIONS nor MIGRATED_PATHS — "
+                "record the move so the symbol golden follows the module"
+            )
diff --git a/tests/unit/test_layernorm_grad_outputs.py b/tests/unit/test_layernorm_grad_outputs.py
new file mode 100644
index 0000000..8feba46
--- /dev/null
+++ b/tests/unit/test_layernorm_grad_outputs.py
@@ -0,0 +1,106 @@
+"""Regression for the LayerNorm gradient-output patch (#33, `artifacts/builder.py`).
+
+ORT's `LayerNormalizationGrad` reads the forward node's optional **second and third outputs** (saved
+mean and inverse standard deviation) instead of recomputing them. `torch.onnx` exports the node with
+only `Y`, so building a gradient graph through it trips an assertion deep inside ORT that names
+neither the op nor the node:
+
+    GradientBuilderBase::O(size_t, bool) const i < node_->OutputDefs().size() was false
+
+Decoders never hit it — Llama-family RMSNorm exports as `SimplifiedLayerNormalization`, which already
+carries 2 outputs — so encoder support was the first thing to need this. These tests run on `onnx`
+alone (core profile); the end-to-end proof is the env-gated encoder integration test.
+"""
+
+from __future__ import annotations
+
+import onnx
+import pytest
+from onnx import TensorProto, helper
+
+from mobiletransformers.artifacts.graph_prep import ensure_layernorm_grad_outputs
+
+
+def _model(nodes, path) -> str:
+    graph = helper.make_graph(
+        nodes=nodes,
+        name="g",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, ["b", 4])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, ["b", 4])],
+        initializer=[
+            helper.make_tensor("scale", TensorProto.FLOAT, [4], b"\x00" * 16, raw=True),
+            helper.make_tensor("bias", TensorProto.FLOAT, [4], b"\x00" * 16, raw=True),
+        ],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)])
+    onnx.save(model, str(path))
+    return str(path)
+
+
+def _layernorm(name="ln", outputs=("y",)):
+    return helper.make_node("LayerNormalization", ["x", "scale", "bias"], list(outputs), name=name)
+
+
+def test_single_output_layernorm_gains_mean_and_inv_std(tmp_path):
+    src = _model([_layernorm()], tmp_path / "m.onnx")
+
+    out = ensure_layernorm_grad_outputs(src)
+
+    assert out != src, "a rewrite was needed, so a new path must be returned"
+    node = onnx.load(out).graph.node[0]
+    assert len(node.output) == 3
+    # Order is fixed by the ONNX spec: Y, Mean, InvStdDev. Y must not move.
+    assert node.output[0] == "y"
+    assert node.output[1] != node.output[2]
+
+
+def test_rewrite_is_written_beside_the_source_so_external_data_still_resolves(tmp_path):
+    """External-data references are relative to the model file; a temp dir elsewhere would break them."""
+    src = _model([_layernorm()], tmp_path / "quant_model.onnx")
+
+    out = ensure_layernorm_grad_outputs(src)
+
+    assert str(tmp_path) == str(__import__("pathlib").Path(out).parent)
+
+
+def test_already_complete_layernorm_is_left_alone(tmp_path):
+    """No rewrite, and the original path is returned unchanged — the common case must stay free."""
+    src = _model([_layernorm(outputs=("y", "mean", "inv_std"))], tmp_path / "m.onnx")
+
+    assert ensure_layernorm_grad_outputs(src) == src
+
+
+def test_decoder_style_norm_is_untouched(tmp_path):
+    """`SimplifiedLayerNormalization` (RMSNorm) already carries its 2 outputs and is a different op.
+
+    This is what makes the patch a no-op on every decoder package that already works.
+    """
+    node = helper.make_node("SimplifiedLayerNormalization", ["x", "scale"], ["y", "inv_std"], name="rms")
+    src = _model([node], tmp_path / "m.onnx")
+
+    assert ensure_layernorm_grad_outputs(src) == src
+
+
+def test_every_single_output_layernorm_is_patched(tmp_path):
+    src = _model(
+        [_layernorm(name=f"ln{i}", outputs=(f"t{i}",)) for i in range(4)] + [_layernorm(name="last")],
+        tmp_path / "m.onnx",
+    )
+
+    out = ensure_layernorm_grad_outputs(src)
+
+    model = onnx.load(out)
+    assert all(len(n.output) == 3 for n in model.graph.node)
+    names = [o for n in model.graph.node for o in n.output]
+    assert len(names) == len(set(names)), "generated output names must be unique across nodes"
+
+
+@pytest.mark.parametrize("outputs", [("y",), ("y", "mean")])
+def test_patching_is_idempotent(tmp_path, outputs):
+    src = _model([_layernorm(outputs=outputs)], tmp_path / "m.onnx")
+
+    once = ensure_layernorm_grad_outputs(src)
+    twice = ensure_layernorm_grad_outputs(once)
+
+    assert twice == once, "a patched graph needs no second rewrite"
+    assert len(onnx.load(once).graph.node[0].output) == 3
diff --git a/tests/unit/test_manifest.py b/tests/unit/test_manifest.py
new file mode 100644
index 0000000..c4fd59f
--- /dev/null
+++ b/tests/unit/test_manifest.py
@@ -0,0 +1,104 @@
+"""#13 manifest validator + variant selection. Uses the committed tiny package fixture (onnx-free)."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.manifest import MobileTransformersManifest
+from mobiletransformers.artifacts.versioning import SchemaVersionError
+from mobiletransformers.exceptions import ManifestError, NoCompatibleVariant
+
+PKG = Path(__file__).resolve().parents[1] / "fixtures" / "tiny_package"
+MANIFEST = PKG / "mobiletransformers_manifest.json"
+
+
+def _copy_pkg(dst: Path) -> Path:
+    shutil.copytree(PKG, dst)
+    return dst
+
+
+def test_valid_fixture_passes():
+    m = MobileTransformersManifest.load(MANIFEST)
+    m.validate(PKG)  # no raise
+
+
+def test_round_trip_preserves_unknown_fields():
+    data = json.loads(MANIFEST.read_text())
+    data["someFutureField"] = {"nested": 1}
+    m = MobileTransformersManifest.from_dict(data)
+    assert m.to_dict()["someFutureField"] == {"nested": 1}
+    # deterministic serialization
+    assert m.to_json() == json.dumps(data, indent=2, sort_keys=True) + "\n"
+
+
+def test_bad_default_variant_rejected(tmp_path):
+    pkg = _copy_pkg(tmp_path / "p")
+    data = json.loads((pkg / "mobiletransformers_manifest.json").read_text())
+    data["defaultVariant"] = "does-not-exist"
+    (pkg / "mobiletransformers_manifest.json").write_text(json.dumps(data))
+    with pytest.raises(ManifestError, match="defaultVariant"):
+        MobileTransformersManifest.from_dict(data).validate(pkg)
+
+
+def test_unresolvable_weight_handoff_rejected(tmp_path):
+    pkg = _copy_pkg(tmp_path / "p")
+    # Delete a per-tensor .bin the handoff map references.
+    (pkg / "variants/cpu-int4/inference/model.layers.0.attn.q_proj.MatMul.weight.bin").unlink()
+    m = MobileTransformersManifest.load(pkg / "mobiletransformers_manifest.json")
+    with pytest.raises(ManifestError, match="missing external file"):
+        m.validate(pkg)
+
+
+def test_feature_without_path_rejected(tmp_path):
+    pkg = _copy_pkg(tmp_path / "p")
+    data = json.loads((pkg / "mobiletransformers_manifest.json").read_text())
+    for v in data["variants"]:
+        if v["id"] == "cpu-int4":
+            v["paths"].pop("inference")
+    with pytest.raises(ManifestError, match="inference"):
+        MobileTransformersManifest.from_dict(data).validate(pkg)
+
+
+def test_schema_major_bump_fails_closed(tmp_path):
+    pkg = _copy_pkg(tmp_path / "p")
+    data = json.loads((pkg / "mobiletransformers_manifest.json").read_text())
+    data["schemaVersion"] = "2.0"
+    data["minReaderVersion"] = "2.0"
+    with pytest.raises(SchemaVersionError):
+        MobileTransformersManifest.from_dict(data).validate(pkg)
+
+
+# --- variant selection ------------------------------------------------------
+
+
+def test_select_prefers_smallest_memory_then_default():
+    m = MobileTransformersManifest.load(MANIFEST)
+    # arm64 + core/inference on native: cpu-int4 (3072) beats cpu-fp16 (6144, and abi=null).
+    sel = m.select_variant(abis=["arm64-v8a"], requested_features=["core", "inference"])
+    assert sel.id == "cpu-int4"
+
+
+def test_select_requires_genai_engine_filters_out_native_only():
+    m = MobileTransformersManifest.load(MANIFEST)
+    sel = m.select_variant(abis=["arm64-v8a"], requested_engine="genai", requested_features=["genai"])
+    assert sel.id == "cpu-int4"  # only cpu-int4 supports genai
+
+
+def test_select_no_match_raises(tmp_path):
+    m = MobileTransformersManifest.load(MANIFEST)
+    # rag requested on an engine/abi combo that has it only on cpu-int4, but force a memory ceiling
+    # below both variants' requirements.
+    with pytest.raises(NoCompatibleVariant):
+        m.select_variant(abis=["arm64-v8a"], total_mem_mb=1024, requested_features=["core"])
+
+
+def test_select_memory_ceiling_picks_only_fitting_variant():
+    m = MobileTransformersManifest.load(MANIFEST)
+    # 4096 MB fits cpu-int4 (3072) but not cpu-fp16 (6144); abi any-match via arm64.
+    sel = m.select_variant(abis=["arm64-v8a"], total_mem_mb=4096, requested_features=["core", "inference"])
+    assert sel.id == "cpu-int4"
+    assert sel.recommended_device_memory_mb == 3072
diff --git a/tests/unit/test_merger_builder.py b/tests/unit/test_merger_builder.py
new file mode 100644
index 0000000..61faf4c
--- /dev/null
+++ b/tests/unit/test_merger_builder.py
@@ -0,0 +1,131 @@
+"""Golden-equivalence: ``build_merger_model`` reproduces the legacy ``*_2`` factory graphs (#9).
+
+The single parameterized ``build_merger_model`` (``config/registry/merger.py``) collapses the four
+``artifact/merger.py`` factories. This test pins its output — byte-for-byte, modulo doc_strings — to
+committed goldens generated from the legacy ``create_*_merger_model_2`` factories
+(``tests/fixtures/gen_merger_golden.py``), for the full family × quant_in × quant_out cross-product.
+
+Structural comparison uses only ``onnx`` (a core dep), so it runs in the default env. A numerical
+sanity check (validating the merge math end-to-end) is gated behind ``onnxruntime`` (export profile).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import onnx
+import pytest
+
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.config.registry.merger import build_merger_model, resolve_merger
+from tests.fixtures.gen_merger_golden import golden_name
+
+GOLDEN_DIR = Path(__file__).resolve().parents[1] / "fixtures" / "merger_golden"
+
+# (PEFTMethod, family-tag-for-golden). LoRA-family resolves to LORA/LORA_Q by quant_in; MARS -> MARS_Q.
+_METHODS = [(PEFTMethod.LORA, "lora"), (PEFTMethod.MARS, "mars")]
+CASES = [
+    (method, family, quant_in, quant_out)
+    for method, family in _METHODS
+    for quant_in in (False, True)
+    for quant_out in (False, True)
+]
+
+
+def _strip_doc_strings(model: onnx.ModelProto) -> onnx.ModelProto:
+    """Clear volatile doc_string fields so the comparison is structural, not cosmetic."""
+    model.doc_string = ""
+    graph = model.graph
+    graph.doc_string = ""
+    for node in graph.node:
+        node.doc_string = ""
+    for value_info in list(graph.input) + list(graph.output) + list(graph.value_info):
+        value_info.doc_string = ""
+    return model
+
+
+def _canonical_bytes(model: onnx.ModelProto) -> bytes:
+    return _strip_doc_strings(model).SerializeToString(deterministic=True)
+
+
+@pytest.mark.parametrize(
+    "method,family,quant_in,quant_out",
+    CASES,
+    ids=[f"{f}-{'qin' if qi else 'fpin'}-{'qout' if qo else 'fpout'}" for _, f, qi, qo in CASES],
+)
+def test_build_merger_model_matches_legacy_golden(method, family, quant_in, quant_out, tmp_path):
+    spec = resolve_merger(method, quant_in=quant_in, quant_out=quant_out)
+    out = tmp_path / "merger.onnx"
+    build_merger_model(spec, out)
+
+    built = onnx.load(str(out))
+    onnx.checker.check_model(built)  # emitted graph is valid
+
+    golden = onnx.load(str(GOLDEN_DIR / golden_name(family, quant_in, quant_out)))
+    assert _canonical_bytes(built) == _canonical_bytes(golden), (
+        f"build_merger_model output diverged from the legacy {family} "
+        f"(quant_in={quant_in}, quant_out={quant_out}) golden graph"
+    )
+
+
+def test_lora_and_mars_use_distinct_graphs():
+    """Guard the family dispatch: LoRA and MARS specs must not produce the same graph."""
+    lora = resolve_merger(PEFTMethod.LORA, quant_in=True, quant_out=True)
+    mars = resolve_merger(PEFTMethod.MARS, quant_in=True, quant_out=True)
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as d:
+        lp, mp = Path(d) / "l.onnx", Path(d) / "m.onnx"
+        build_merger_model(lora, lp)
+        build_merger_model(mars, mp)
+        assert _canonical_bytes(onnx.load(str(lp))) != _canonical_bytes(onnx.load(str(mp)))
+
+
+# ---------------------------------------------------------------------------
+# Numerical sanity (export profile only — needs a runtime).
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("family", ["lora", "mars"])
+def test_merge_math_matches_numpy_reference(family, tmp_path):
+    """Run the fp-in/fp-out graph through ORT and check merged = base + alpha*delta (numpy ref)."""
+    ort = pytest.importorskip("onnxruntime")
+    import numpy as np
+
+    rng = np.random.default_rng(0)
+    out_features, in_features, rank = 5, 4, 2
+    method = PEFTMethod.LORA if family == "lora" else PEFTMethod.MARS
+    spec = resolve_merger(method, quant_in=False, quant_out=False)
+    model_path = tmp_path / "merger.onnx"
+    build_merger_model(spec, model_path)
+
+    base = rng.standard_normal((out_features, in_features)).astype(np.float32)
+    alpha_val = 0.5
+    alpha = np.array(alpha_val, dtype=np.float32)  # scalar graph inputs must be 0-d arrays for ORT
+    adapter_B = rng.standard_normal((out_features, rank)).astype(np.float32)
+
+    if family == "lora":
+        adapter_A = rng.standard_normal((rank, in_features)).astype(np.float32)
+        feeds = {"weight": base, "adapter_A": adapter_A, "adapter_B": adapter_B, "alpha": alpha}
+        expected = base + alpha_val * (adapter_B @ adapter_A)
+    else:
+        shared_rank = 3
+        n_adapters = 2
+        adapter_index = 1
+        shared_A = rng.standard_normal((shared_rank, in_features)).astype(np.float32)
+        intermediate = rng.standard_normal((n_adapters * rank, shared_rank)).astype(np.float32)
+        chunk = intermediate[adapter_index * rank : (adapter_index + 1) * rank, :]
+        feeds = {
+            "weight": base,
+            "shared_A": shared_A,
+            "intermediate": intermediate,
+            "adapter_B": adapter_B,
+            "adapter_index": np.array(adapter_index, dtype=np.int64),
+            "rank": np.array(rank, dtype=np.int64),
+            "alpha": alpha,
+        }
+        expected = base + alpha_val * (adapter_B @ chunk @ shared_A)
+
+    sess = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
+    (merged,) = sess.run(["merged_weight"], feeds)
+    np.testing.assert_allclose(merged, expected, rtol=1e-4, atol=1e-4)
diff --git a/tests/unit/test_mobile_actions.py b/tests/unit/test_mobile_actions.py
new file mode 100644
index 0000000..aafc194
--- /dev/null
+++ b/tests/unit/test_mobile_actions.py
@@ -0,0 +1,130 @@
+"""#37: the per-user action dataset is generated FROM the app's allowlist, so it teaches the boundary.
+
+The property worth pinning is not "rows are produced" but that every completion is a call the Kotlin
+`FunctionCallValidator` would accept: declared action, exactly the declared parameter keys, and values
+satisfying the same `validationRules`. A generator that drifted from the validator would train the model
+to emit calls the app then rejects — the two halves each fine alone, disagreeing at the seam.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+import pytest
+
+from mobiletransformers.agent.mobile_actions import (
+    ActionSpec,
+    generate_examples,
+    load_allowlist,
+    write_jsonl,
+)
+from mobiletransformers.exceptions import ConfigValidationError
+
+ALARM = ActionSpec(
+    action_name="set_alarm",
+    parameters={"time": "string", "label": "string"},
+    allowed_intent="android.intent.action.SET_ALARM",
+    validation_rules={"time": "HH:mm"},
+    privacy_class="harmless-demo",
+)
+TIMER = ActionSpec(
+    action_name="set_timer",
+    parameters={"seconds": "string"},
+    allowed_intent="android.intent.action.SET_TIMER",
+    validation_rules={"seconds": "/[0-9]{1,4}/"},
+)
+
+HH_MM = re.compile(r"^([01]\d|2[0-3]):[0-5]\d$")
+
+
+def test_every_completion_is_a_call_the_validator_would_accept() -> None:
+    rows = generate_examples([ALARM, TIMER], per_action=6, seed=1)
+
+    specs = {s.action_name: s for s in (ALARM, TIMER)}
+    for row in rows:
+        call = json.loads(str(row["completion"]))
+        spec = specs[call["actionName"]]
+        # Exactly the declared keys: the validator rejects both unknown and missing parameters.
+        assert set(call["parameters"]) == set(spec.parameters)
+        for param, rule in spec.validation_rules.items():
+            value = call["parameters"][param]
+            if rule == "HH:mm":
+                assert HH_MM.match(value), f"{value!r} would be rejected by the HH:mm rule"
+            elif rule.startswith("/") and rule.endswith("/"):
+                assert re.fullmatch(rule[1:-1], value), f"{value!r} would be rejected by {rule}"
+
+
+def test_the_dataset_covers_every_declared_action() -> None:
+    # A user who declared an action must have training data for it; silently skipping one would teach
+    # the model that part of their own vocabulary does not exist.
+    rows = generate_examples([ALARM, TIMER], per_action=4, seed=0)
+    seen = {json.loads(str(r["completion"]))["actionName"] for r in rows}
+
+    assert seen == {"set_alarm", "set_timer"}
+    assert len(rows) == 8
+
+
+def test_generation_is_deterministic_for_a_seed() -> None:
+    # A per-user dataset that changed between runs makes "the model learned this user's actions"
+    # unfalsifiable.
+    assert generate_examples([ALARM], per_action=5, seed=7) == generate_examples(
+        [ALARM], per_action=5, seed=7
+    )
+
+
+def test_an_action_with_no_template_still_gets_data() -> None:
+    custom = ActionSpec(
+        action_name="water_plants",
+        parameters={"room": "string"},
+        allowed_intent="com.example.WATER",
+    )
+    rows = generate_examples([custom], per_action=3, seed=0)
+
+    assert len(rows) == 3
+    assert all("water plants" in str(r["prompt"]) for r in rows)
+
+
+def test_a_template_naming_an_undeclared_parameter_fails_closed() -> None:
+    with pytest.raises(ConfigValidationError, match="does not.*declare"):
+        generate_examples([ALARM], per_action=1, seed=0, templates={"set_alarm": ("ring at {nonexistent}",)})
+
+
+def test_an_empty_allowlist_is_rejected_rather_than_producing_nothing() -> None:
+    with pytest.raises(ConfigValidationError, match="empty allowlist"):
+        generate_examples([], per_action=4)
+
+
+def test_round_trips_through_the_action_schema_json(tmp_path) -> None:
+    schema = tmp_path / "actions.json"
+    schema.write_text(
+        json.dumps(
+            [
+                {
+                    "actionName": "set_alarm",
+                    "parameters": {"time": "string", "label": "string"},
+                    "allowedIntent": "android.intent.action.SET_ALARM",
+                    "validationRules": {"time": "HH:mm"},
+                    "privacyClass": "harmless-demo",
+                }
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    specs = load_allowlist(schema)
+    assert specs[0].action_name == "set_alarm"
+    assert specs[0].allowed_intent == "android.intent.action.SET_ALARM"
+
+    out = write_jsonl(generate_examples(specs, per_action=2, seed=3), tmp_path / "d.jsonl")
+    lines = out.read_text(encoding="utf-8").strip().split("\n")
+    assert len(lines) == 2
+    assert all(set(json.loads(line)) == {"prompt", "completion"} for line in lines)
+
+
+def test_a_malformed_action_schema_fails_closed(tmp_path) -> None:
+    bad = tmp_path / "bad.json"
+    bad.write_text(json.dumps([{"parameters": {}}]), encoding="utf-8")
+
+    with pytest.raises(ConfigValidationError, match="actionName"):
+        load_allowlist(bad)
diff --git a/tests/unit/test_mobile_actions_import.py b/tests/unit/test_mobile_actions_import.py
new file mode 100644
index 0000000..7c2f845
--- /dev/null
+++ b/tests/unit/test_mobile_actions_import.py
@@ -0,0 +1,254 @@
+"""#37: importing a real function-calling corpus into the tool-call training shape.
+
+Runs offline against `tests/fixtures/agent/mobile_actions_sample.jsonl` — five records excerpted from
+`google/mobile-actions` (CC-BY-4.0), chosen to cover single-call, multi-call and eval-split records.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.agent.mobile_actions_import import (
+    ANDROID_INTENT_BY_ACTION,
+    extract_allowlist,
+    read_records,
+    resolve_source,
+    to_training_rows,
+    write_action_schema,
+)
+from mobiletransformers.exceptions import ConfigValidationError
+
+FIXTURE = Path(__file__).resolve().parents[1] / "fixtures" / "agent" / "mobile_actions_sample.jsonl"
+
+
+@pytest.fixture
+def records() -> list[dict]:
+    return list(read_records(FIXTURE))
+
+
+# --- source resolution ------------------------------------------------------
+
+
+def test_local_path_is_used_as_is():
+    assert resolve_source(FIXTURE) == FIXTURE
+
+
+def test_repo_id_is_downloaded_through_the_injected_downloader():
+    calls = []
+
+    def fake(repo_id: str, filename: str) -> str:
+        calls.append((repo_id, filename))
+        return str(FIXTURE)
+
+    assert resolve_source("google/mobile-actions", downloader=fake) == FIXTURE
+    assert calls == [("google/mobile-actions", "dataset.jsonl")]
+
+
+def test_a_missing_local_file_fails_closed_rather_than_hitting_the_network():
+    with pytest.raises(ConfigValidationError, match="no such file"):
+        resolve_source("nope.jsonl")
+
+
+# --- allowlist derivation ---------------------------------------------------
+
+
+def test_allowlist_is_derived_from_the_corpus_tool_declarations(records):
+    specs = {s.action_name: s for s in extract_allowlist(records)}
+    assert set(specs) == {
+        "create_calendar_event",
+        "create_contact",
+        "open_wifi_settings",
+        "send_email",
+        "show_map",
+        "turn_off_flashlight",
+        "turn_on_flashlight",
+    }
+    assert [s.action_name for s in extract_allowlist(records)] == sorted(specs)
+
+
+def test_optional_parameters_are_not_treated_as_required(records):
+    """The case `ActionSpec.required_parameters` exists for — see the class docstring."""
+    specs = {s.action_name: s for s in extract_allowlist(records)}
+
+    email = specs["send_email"]
+    assert set(email.parameters) == {"to", "subject", "body"}
+    assert email.required == {"to", "subject"}, "body is optional in the corpus"
+
+    contact = specs["create_contact"]
+    assert contact.required == {"first_name", "last_name"}
+    assert "phone_number" in contact.parameters and "phone_number" not in contact.required
+
+
+def test_an_unmapped_action_gets_no_intent_rather_than_an_invented_one(records):
+    specs = {s.action_name: s for s in extract_allowlist(records)}
+    assert specs["show_map"].allowed_intent == ANDROID_INTENT_BY_ACTION["show_map"]
+    # The flashlight is a CameraManager torch call, not an intent. Empty, never guessed.
+    assert specs["turn_on_flashlight"].allowed_intent == ""
+
+
+def test_a_corpus_that_declares_one_action_two_ways_fails_closed():
+    a = {"tools": [{"function": {"name": "x", "parameters": {"properties": {"p": {"type": "STRING"}}}}}]}
+    b = {"tools": [{"function": {"name": "x", "parameters": {"properties": {}}}}]}
+    with pytest.raises(ConfigValidationError, match="declared two different ways"):
+        extract_allowlist([a, b])
+
+
+def test_a_corpus_with_no_tools_fails_closed():
+    with pytest.raises(ConfigValidationError, match="declares no tools"):
+        extract_allowlist([{"messages": []}])
+
+
+# --- training rows ----------------------------------------------------------
+
+
+def test_completions_are_exactly_what_the_validator_parses(records):
+    """The design property: training target and validation boundary are one object."""
+    specs = {s.action_name: s for s in extract_allowlist(records)}
+    rows = to_training_rows(records)
+    assert rows
+
+    for row in rows:
+        call = json.loads(row["completion"])
+        assert set(call) == {"actionName", "parameters"}
+        spec = specs[call["actionName"]]
+        supplied = call["parameters"]
+        assert all(isinstance(v, str) for v in supplied.values())
+        # Exactly the checks FunctionCallValidator.validate performs.
+        assert not (set(supplied) - set(spec.parameters)), "no undeclared parameter"
+        assert not (spec.required - set(supplied)), "every required parameter present"
+
+
+def test_multi_call_records_are_skipped_by_default(records):
+    default = to_training_rows(records)
+    kept = to_training_rows(records, multi_call="first")
+    assert len(kept) > len(default), "the fixture carries a multi-call record"
+
+
+def test_multi_call_policy_is_validated(records):
+    with pytest.raises(ConfigValidationError, match="unknown multi_call"):
+        to_training_rows(records, multi_call="explode")
+
+
+def test_split_filtering(records):
+    train = to_training_rows(records, split="train")
+    evaluation = to_training_rows(records, split="eval")
+    everything = to_training_rows(records, split=None)
+    assert train and evaluation
+    assert len(everything) == len(train) + len(evaluation)
+
+
+def test_context_prompt_carries_the_date_so_relative_targets_are_learnable(records):
+    """A third of the corpus asks for a calendar event in relative terms ("this Friday")."""
+    with_context = to_training_rows(records, prompt_style="context")
+    bare = to_training_rows(records, prompt_style="user")
+    assert any("Current date and time" in r["prompt"] for r in with_context)
+    assert not any("Current date and time" in r["prompt"] for r in bare)
+    assert len(with_context) == len(bare)
+
+
+def test_unknown_prompt_style_fails_closed(records):
+    with pytest.raises(ConfigValidationError, match="unknown prompt style"):
+        to_training_rows(records, prompt_style="freeform")
+
+
+def test_stringified_arguments_are_accepted_too():
+    """The dataset card documents `arguments` as a JSON string; the data ships objects. Both work."""
+    record = {
+        "metadata": "train",
+        "tools": [{"function": {"name": "show_map", "parameters": {"properties": {"query": {}}}}}],
+        "messages": [
+            {"role": "user", "content": "where is the station"},
+            {
+                "role": "assistant",
+                "tool_calls": [{"function": {"name": "show_map", "arguments": '{"query": "station"}'}}],
+            },
+        ],
+    }
+    (row,) = to_training_rows([record])
+    assert json.loads(row["completion"])["parameters"] == {"query": "station"}
+
+
+def test_non_string_argument_values_are_rendered_not_dropped():
+    record = {
+        "metadata": "train",
+        "tools": [{"function": {"name": "t", "parameters": {"properties": {"n": {}}}}}],
+        "messages": [
+            {"role": "user", "content": "go"},
+            {"role": "assistant", "tool_calls": [{"function": {"name": "t", "arguments": {"n": 5}}}]},
+        ],
+    }
+    (row,) = to_training_rows([record])
+    # Crosses into Kotlin as Map<String, String>; converting here keeps the failure near its cause.
+    assert json.loads(row["completion"])["parameters"] == {"n": "5"}
+
+
+# --- action schema ----------------------------------------------------------
+
+
+def test_action_schema_round_trips_through_the_wire_names(tmp_path, records):
+    specs = extract_allowlist(records)
+    path = write_action_schema(specs, tmp_path / "action_schema.json")
+    payload = json.loads(path.read_text())
+
+    assert {row["actionName"] for row in payload} == {s.action_name for s in specs}
+    for row in payload:
+        # camelCase, and exactly the keys the Kotlin ActionSpec declares.
+        assert set(row) == {
+            "actionName",
+            "parameters",
+            "allowedIntent",
+            "requiredParameters",
+            "validationRules",
+            "privacyClass",
+        }
+
+    email = next(row for row in payload if row["actionName"] == "send_email")
+    assert email["requiredParameters"] == ["subject", "to"]
+
+
+def test_datetime_rule_is_one_the_kotlin_validator_understands(tmp_path, records):
+    """Only `HH:mm` and `/regex/` are supported there, and an unrecognised rule rejects everything."""
+    import re
+
+    specs = {s.action_name: s for s in extract_allowlist(records)}
+    rule = specs["create_calendar_event"].validation_rules["datetime"]
+    assert rule.startswith("/") and rule.endswith("/")
+    assert re.compile(rule[1:-1]).match("2025-06-06T14:00:00")
+
+    # And every emitted datetime actually satisfies it, so training targets pass their own gate.
+    for row in to_training_rows(records):
+        params = json.loads(row["completion"])["parameters"]
+        if "datetime" in params:
+            assert re.compile(rule[1:-1]).fullmatch(params["datetime"]), params["datetime"]
+
+
+def test_schema_round_trips_back_into_action_specs(tmp_path, records):
+    """write_action_schema -> load_allowlist must preserve the required set, or the generator would
+    treat every optional parameter as mandatory and produce rows the corpus itself contradicts."""
+    from mobiletransformers.agent.mobile_actions import generate_examples, load_allowlist
+
+    path = write_action_schema(extract_allowlist(records), tmp_path / "action_schema.json")
+    reloaded = {s.action_name: s for s in load_allowlist(path)}
+    assert reloaded["send_email"].required == {"to", "subject"}
+    assert reloaded["create_contact"].required == {"first_name", "last_name"}
+
+    # And the synthetic generator runs off the imported schema — the per-user layer on the same
+    # boundary as the corpus.
+    rows = generate_examples(list(reloaded.values()), per_action=2, seed=1)
+    assert len(rows) == 2 * len(reloaded)
+    for row in rows:
+        call = json.loads(row["completion"])
+        assert not (reloaded[call["actionName"]].required - set(call["parameters"]))
+
+
+def test_a_schema_without_required_parameters_keeps_the_stricter_default(tmp_path):
+    from mobiletransformers.agent.mobile_actions import load_allowlist
+
+    path = tmp_path / "old_schema.json"
+    path.write_text(json.dumps([{"actionName": "a", "parameters": {"p": "string", "q": "string"}}]))
+    (spec,) = load_allowlist(path)
+    assert spec.required_parameters is None
+    assert spec.required == {"p", "q"}
diff --git a/tests/unit/test_no_src_to_legacy_imports.py b/tests/unit/test_no_src_to_legacy_imports.py
new file mode 100644
index 0000000..c0fb35e
--- /dev/null
+++ b/tests/unit/test_no_src_to_legacy_imports.py
@@ -0,0 +1,163 @@
+"""The wheel-installability gate, and the Migration Map's objective progress meter.
+
+`pyproject.toml` packages only `src/mobiletransformers`, so every import from `src/` into a legacy root
+is a module that exists in a checkout and is **absent from an installed wheel**. Today the full export
+path works from a checkout and fails from a wheel — this test makes that fact countable instead of
+folkloric.
+
+`ALLOWED` shrinks as the migration proceeds and must reach **empty**, at which point `uv build` yields a
+self-contained wheel. Entries may only be REMOVED.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SRC = REPO_ROOT / "src" / "mobiletransformers"
+
+#: Top-level packages that live at the repo root and are NOT shipped in the wheel.
+#:
+#: `config` was added 2026-08-14: the root `config.py` deprecation shim was NOT in this set, so the
+#: gate did not catch `evaluation/mobile/recommendation_eval.py`'s `from config import AZURE_*` — an
+#: installed wheel raised `ModuleNotFoundError: config`. The shim is now deleted, and the name stays
+#: listed so a re-introduced root `config.py` cannot reopen the hole.
+LEGACY_ROOTS = frozenset(
+    {
+        "trainer",
+        "artifact",
+        "inference",
+        "tools",
+        "peft_models",
+        "evaluation",
+        "database",
+        "research",
+        "config",
+    }
+)
+
+#: The subset scanned for lazy dotted-path STRING literals (see `_dotted_string_references`).
+DOTTED_ROOTS = LEGACY_ROOTS - {"config"}
+
+#: `src/`-relative module path -> the legacy roots it may still import. ENTRIES MAY ONLY BE REMOVED.
+#:
+#: All four original arrows lived in the export pipeline's lazily-imported stage builders and were
+#: removed one per step: tools (S1), inference.export_inference_package (S2), trainer (S4),
+#: artifact (S5).
+#: EMPTY as of Migration Map S5 — the package no longer imports any unpackaged legacy root, so
+#: `uv build` yields a wheel from which the full export path runs with no repository checkout.
+#: Adding an entry here is a REGRESSION, not a step.
+ALLOWED: dict[str, set[str]] = {}
+
+
+def _imported_roots(path: Path) -> set[str]:
+    """Top-level legacy packages imported anywhere in `path`, including function-local imports."""
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    found: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                root = alias.name.split(".", 1)[0]
+                if root in LEGACY_ROOTS:
+                    found.add(root)
+        elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+            root = node.module.split(".", 1)[0]
+            if root in LEGACY_ROOTS:
+                found.add(root)
+    return found
+
+
+def _scan() -> dict[str, set[str]]:
+    offenders: dict[str, set[str]] = {}
+    for path in sorted(SRC.rglob("*.py")):
+        roots = _imported_roots(path)
+        if roots:
+            offenders[str(path.relative_to(SRC))] = roots
+    return offenders
+
+
+def _dotted_string_references() -> dict[str, list[str]]:
+    """Legacy roots named in DOTTED-PATH STRING literals (the registries' lazy-import convention).
+
+    `import` statements are only half the story: `config/registry/*.py` resolves classes from strings
+    like `"peft_models.mars.config.MarsConfig"` via `import_from_path`. An AST import walk cannot see
+    those, so a move that forgets one leaves a runtime-only `ModuleNotFoundError` that no static gate
+    catches — exactly what happened to the MARS config path during S3.
+    """
+    import re
+
+    # Non-capturing group: findall must return the FULL dotted path, not just the root.
+    # Scans DOTTED_ROOTS, not LEGACY_ROOTS: `config` is a legacy *import* root but a terrible
+    # dotted-literal root — `"config.yml"` / `"config.json"` are filenames, not module paths.
+    pattern = re.compile(rf'"((?:{"|".join(sorted(DOTTED_ROOTS))})\.[\w.]+)"')
+    offenders: dict[str, list[str]] = {}
+    for path in sorted(SRC.rglob("*.py")):
+        hits = pattern.findall(path.read_text(encoding="utf-8"))
+        if hits:
+            offenders[str(path.relative_to(SRC))] = sorted(set(hits))
+    return offenders
+
+
+#: `src/`-relative module -> dotted paths into a legacy root it may still name. ONLY REMOVALS.
+#: The registries resolve these lazily via `import_from_path`; S4 moves `trainer/utils.py`.
+#: **EMPTY.** The only entry was the architecture registry's lazy `inference.builder` paths, held open
+#: for "the deferred move of inference/builder.py (unimportable under every declared profile)". S6 moved
+#: it: the registry now names `mobiletransformers.inference.builder`, which is inside the wheel. There
+#: is no longer any dotted string in `src/` that resolves into an unpackaged root — the failure mode
+#: this guard exists for (works from a checkout, NameError/ImportError from an installed wheel) is gone.
+ALLOWED_DOTTED: dict[str, set[str]] = {}
+
+
+def test_no_lazy_dotted_paths_into_legacy_roots() -> None:
+    offenders = {
+        module: sorted(set(hits) - ALLOWED_DOTTED.get(module, set()))
+        for module, hits in _dotted_string_references().items()
+        if set(hits) - ALLOWED_DOTTED.get(module, set())
+    }
+    assert not offenders, (
+        "dotted-path string(s) resolving into an unpackaged legacy root — these fail at RUNTIME from "
+        f"an installed wheel and no import guard sees them:\n{offenders}"
+    )
+
+
+def test_dotted_allowlist_shrinks() -> None:
+    actual = _dotted_string_references()
+    for module, allowed in ALLOWED_DOTTED.items():
+        resolved = sorted(allowed - set(actual.get(module, [])))
+        assert not resolved, f"{module} no longer names {resolved} — remove them from ALLOWED_DOTTED"
+
+
+def test_no_new_src_to_legacy_imports() -> None:
+    actual = _scan()
+    unlisted = {
+        module: sorted(roots - ALLOWED.get(module, set()))
+        for module, roots in actual.items()
+        if roots - ALLOWED.get(module, set())
+    }
+    assert not unlisted, (
+        "new import(s) from the package into an UNPACKAGED legacy root — these work from a checkout "
+        f"and fail from an installed wheel:\n{unlisted}"
+    )
+
+
+def test_allowlist_shrinks_and_never_goes_stale() -> None:
+    """A resolved arrow must be removed from ALLOWED, so the meter cannot silently stall."""
+    actual = _scan()
+    for module, allowed in ALLOWED.items():
+        remaining = actual.get(module, set())
+        resolved = sorted(allowed - remaining)
+        assert not resolved, (
+            f"{module} no longer imports {resolved} — remove them from ALLOWED so the "
+            "migration's progress stays honest"
+        )
+
+
+def test_wheel_is_self_contained_once_the_allowlist_empties() -> None:
+    """The migration's finish line, stated as an assertion.
+
+    While ALLOWED is non-empty this records what is left. When it empties, the assertion below becomes
+    the standing guarantee that `mobiletransformers export` runs from a wheel with no checkout.
+    """
+    assert not ALLOWED, "ALLOWED is non-empty — the migration regressed"
+    assert not _scan(), "ALLOWED is empty but src/ still imports a legacy root"
diff --git a/tests/unit/test_package_paths.py b/tests/unit/test_package_paths.py
new file mode 100644
index 0000000..277b6ab
--- /dev/null
+++ b/tests/unit/test_package_paths.py
@@ -0,0 +1,96 @@
+"""The two package layouts resolve from one place, and an undeclared stage fails closed."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.artifacts.package_paths import STAGES, PackagePaths
+from mobiletransformers.exceptions import ManifestError
+
+
+class _Variant:
+    """Stand-in for `SelectedVariant` — the resolver only needs `paths`."""
+
+    def __init__(self, paths: dict[str, str]) -> None:
+        self.paths = paths
+
+
+HUB_PATHS = {
+    "inference": "variants/cpu-int4/inference",
+    "train": "variants/cpu-int4/train",
+    "embedding": "variants/cpu-int4/embedding",
+    "tokenizer": "shared/tokenizer",
+}
+
+
+def test_hub_layout_uses_the_manifests_declared_paths() -> None:
+    paths = PackagePaths.for_hub("/pkg", _Variant(HUB_PATHS))
+
+    assert paths.train == Path("/pkg/variants/cpu-int4/train")
+    assert paths.inference == Path("/pkg/variants/cpu-int4/inference")
+    # The tokenizer is SHARED across variants — it is not under variants/<id>/. Re-deriving the hub
+    # layout as "variants/<id>/<stage>" would get this one wrong, which is why the manifest decides.
+    assert paths.tokenizer == Path("/pkg/shared/tokenizer")
+
+
+def test_hub_layout_honours_a_variant_that_places_a_stage_unusually() -> None:
+    # The manifest is the source of truth, not a convention this module re-implements.
+    odd = dict(HUB_PATHS, train="somewhere/else/train")
+
+    assert PackagePaths.for_hub("/pkg", _Variant(odd)).train == Path("/pkg/somewhere/else/train")
+
+
+def test_cache_layout_is_flat_and_declares_every_stage() -> None:
+    paths = PackagePaths.for_cache("/cache", "org__model")
+
+    assert paths.train == Path("/cache/org__model/train")
+    assert paths.inference == Path("/cache/org__model/inference")
+    assert paths.embedding == Path("/cache/org__model/embedding")
+    # Flat: the tokenizer is a sibling here, NOT under shared/. This is the difference that made the
+    # #35 simulation look for <package>/train/ in a hub package and get "Invalid fd was supplied: -1".
+    assert paths.tokenizer == Path("/cache/org__model/tokenizer")
+    assert all(paths.has(stage) for stage in STAGES)
+
+
+def test_the_two_layouts_disagree_which_is_the_whole_point() -> None:
+    hub = PackagePaths.for_hub("/pkg", _Variant(HUB_PATHS))
+    cache = PackagePaths.for_cache("/pkg", "model")
+
+    assert hub.train != cache.train
+
+
+def test_weight_handoff_sits_inside_inference_in_both_layouts() -> None:
+    hub = PackagePaths.for_hub("/pkg", _Variant(HUB_PATHS))
+    cache = PackagePaths.for_cache("/cache", "model")
+
+    assert hub.weight_handoff == Path("/pkg/variants/cpu-int4/inference/weight_handoff_map.json")
+    assert cache.weight_handoff == Path("/cache/model/inference/weight_handoff_map.json")
+
+
+def test_an_undeclared_stage_fails_closed_naming_what_exists() -> None:
+    paths = PackagePaths.for_hub("/pkg", _Variant({"inference": "variants/v/inference"}))
+
+    assert not paths.has("train")
+    with pytest.raises(ManifestError) as excinfo:
+        _ = paths.train
+    # The message must name the missing stage AND what is available; a bare KeyError sends the reader
+    # hunting through four languages' worth of path joins.
+    assert "train" in str(excinfo.value)
+    assert "inference" in str(excinfo.value)
+
+
+def test_an_unknown_stage_name_is_rejected_rather_than_silently_missing() -> None:
+    paths = PackagePaths.for_cache("/cache", "model")
+
+    with pytest.raises(ManifestError, match="unknown stage"):
+        paths.stage("trian")  # typo, not a legitimately absent stage
+
+
+def test_a_variant_without_paths_fails_closed_telling_you_to_re_export() -> None:
+    class _Old:
+        pass
+
+    with pytest.raises(ManifestError, match="re-export"):
+        PackagePaths.for_hub("/pkg", _Old())
diff --git a/tests/unit/test_parameter_budget.py b/tests/unit/test_parameter_budget.py
new file mode 100644
index 0000000..c6e5acd
--- /dev/null
+++ b/tests/unit/test_parameter_budget.py
@@ -0,0 +1,179 @@
+"""Unit tests for the export-time parameter-budget gate (`artifacts/parameter_budget.py`).
+
+These build synthetic ORT-training-shaped graphs with `onnx` alone, so they run in the core profile —
+the same reason the gate itself counts shapes instead of loading external data.
+
+The gate exists because a byte-count-over-one-dtype slip became a recorded v1 blocker. The dtype-mix
+test below is the direct regression for that: a graph whose parameters are mostly uint8 must pass, and
+would not if anything in this path assumed 4 bytes per parameter.
+"""
+
+from __future__ import annotations
+
+import onnx
+import pytest
+from onnx import TensorProto, helper
+
+from mobiletransformers.artifacts.parameter_budget import (
+    describe_graph_precision,
+    summarize_training_parameters,
+    verify_checkpoint_parameter_budget,
+)
+from mobiletransformers.exceptions import ExportError
+
+#: bytes per element, for sizing the synthetic initializers below.
+_ELEM_SIZE = {TensorProto.FLOAT: 4, TensorProto.UINT8: 1, TensorProto.INT64: 8}
+
+
+def _graph_with_initializers(inits: list[tuple[str, int, tuple[int, ...]]], path) -> str:
+    """A graph holding its weights as initializers — the inference-graph shape."""
+    tensors = []
+    for name, dt, shape in inits:
+        count = 1
+        for d in shape:
+            count *= d
+        tensors.append(
+            helper.make_tensor(name, dt, list(shape), b"\x00" * (count * _ELEM_SIZE[dt]), raw=True)
+        )
+    graph = helper.make_graph(
+        nodes=[helper.make_node("Identity", ["x"], ["y"])],
+        name="inference_model",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, ["b"])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, ["b"])],
+        initializer=tensors,
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)])
+    onnx.save(model, str(path))
+    return str(path)
+
+
+def _training_graph(params: list[tuple[str, int, tuple[int, ...]]], path) -> str:
+    """A graph shaped like an ORT training model: parameters as fully-shaped inputs, data as symbolic."""
+    inputs = [
+        helper.make_tensor_value_info("input_ids", TensorProto.INT64, ["batch_size", "sequence_length"]),
+        helper.make_tensor_value_info("labels", TensorProto.INT64, ["batch_size", "sequence_length"]),
+    ]
+    inputs += [helper.make_tensor_value_info(n, dt, list(shape)) for n, dt, shape in params]
+
+    graph = helper.make_graph(
+        nodes=[helper.make_node("Identity", ["input_ids"], ["loss"])],
+        name="training_model",
+        inputs=inputs,
+        outputs=[helper.make_tensor_value_info("loss", TensorProto.INT64, ["batch_size", "sequence_length"])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)])
+    onnx.save(model, str(path))
+    return str(path)
+
+
+def test_parameters_are_separated_from_data_by_shape_not_name(tmp_path):
+    """Data inputs carry a symbolic dim; parameters are fully concrete. No name matching."""
+    path = _training_graph(
+        [("embed.weight", TensorProto.FLOAT, (100, 8)), ("layer.0.weight", TensorProto.FLOAT, (8, 8))],
+        tmp_path / "training_model.onnx",
+    )
+    summary = summarize_training_parameters(path)
+
+    assert summary.tensor_count == 2
+    assert summary.total == 100 * 8 + 8 * 8
+    assert sorted(summary.data_input_names) == ["input_ids", "labels"]
+
+
+def test_counts_are_per_dtype_so_a_quantized_graph_is_not_undercounted(tmp_path):
+    """The regression for the arithmetic that produced a false 'two thirds missing' blocker.
+
+    A graph whose parameters are overwhelmingly uint8 carries exactly as many *parameters* as its
+    element count says. Anything that reasoned in bytes-over-fp32 would report a third of this.
+    """
+    path = _training_graph(
+        [
+            ("base.weight_quantized", TensorProto.UINT8, (1000, 100)),  # 100_000 uint8
+            ("adapter.lora_A.weight", TensorProto.FLOAT, (100, 8)),  # 800 fp32
+        ],
+        tmp_path / "training_model.onnx",
+    )
+    summary = summarize_training_parameters(path)
+
+    assert summary.total == 100_800
+    assert summary.quantized == 100_000
+    assert summary.float_elements == 800
+    # The whole point: a naive bytes/4 reading of the same graph would claim ~25_200.
+    verify_checkpoint_parameter_budget(path, expected_total=100_800)
+
+
+def test_budget_passes_within_tolerance(tmp_path):
+    """PEFT adds parameters and tied embeddings are shared; small deviation is expected, not fatal."""
+    path = _training_graph(
+        [("w", TensorProto.FLOAT, (1000, 100))], tmp_path / "training_model.onnx"
+    )  # 100_000
+    assert verify_checkpoint_parameter_budget(path, expected_total=102_000).total == 100_000
+
+
+def test_budget_fails_closed_when_the_graph_is_short(tmp_path):
+    """The check the pipeline was missing: a graph carrying a fraction of its model must not ship."""
+    path = _training_graph([("w", TensorProto.FLOAT, (100, 100))], tmp_path / "training_model.onnx")
+
+    with pytest.raises(ExportError) as excinfo:
+        verify_checkpoint_parameter_budget(path, expected_total=135_000_000)
+
+    message = str(excinfo.value)
+    assert "10,000" in message and "135,000,000" in message, "both counts must be named"
+    assert "%" in message
+
+
+def test_all_quantized_graph_fails_because_nothing_is_trainable(tmp_path):
+    """A quantizer that swept the adapters leaves no float parameter to take a gradient on."""
+    path = _training_graph(
+        [("base.weight_quantized", TensorProto.UINT8, (1000, 100))], tmp_path / "training_model.onnx"
+    )
+
+    with pytest.raises(ExportError, match="NONE in float storage"):
+        verify_checkpoint_parameter_budget(path, expected_total=100_000)
+
+
+def test_missing_reference_skips_loudly_rather_than_passing(tmp_path, caplog):
+    """A package exported before the gate existed has no reference; that must be said, not assumed."""
+    path = _training_graph([("w", TensorProto.FLOAT, (10, 10))], tmp_path / "training_model.onnx")
+
+    summary = verify_checkpoint_parameter_budget(path, expected_total=None)
+
+    assert summary.total == 100
+    assert "UNVERIFIED" in caplog.text
+
+
+def test_graph_with_no_parameter_inputs_fails(tmp_path):
+    path = _training_graph([], tmp_path / "training_model.onnx")
+    with pytest.raises(ExportError, match="no fully-shaped parameter inputs"):
+        summarize_training_parameters(path)
+
+
+def test_missing_file_fails_closed(tmp_path):
+    with pytest.raises(ExportError, match="not found"):
+        summarize_training_parameters(tmp_path / "absent.onnx")
+
+
+def test_precision_is_measured_not_taken_from_the_variant_name(tmp_path):
+    """The `cpu-int4` variant shipped an fp32 inference graph; only measurement catches that."""
+    fp32 = _graph_with_initializers([("w", TensorProto.FLOAT, (4, 4))], tmp_path / "fp32.onnx")
+    assert describe_graph_precision(fp32) == "float32"
+
+    quantized = _graph_with_initializers(
+        [("w_quantized", TensorProto.UINT8, (16, 16)), ("w_scale", TensorProto.FLOAT, (16,))],
+        tmp_path / "mixed.onnx",
+    )
+    # uint8 dominates by element count, so it leads.
+    assert describe_graph_precision(quantized) == "mixed(uint8/float32)"
+
+
+def test_shape_constants_do_not_make_a_float_graph_look_mixed(tmp_path):
+    """int64 `Reshape` targets are not weights; counting them reported fp32 graphs as mixed."""
+    path = _graph_with_initializers(
+        [("w", TensorProto.FLOAT, (8, 8)), ("reshape_target", TensorProto.INT64, (2,))],
+        tmp_path / "with_shapes.onnx",
+    )
+    assert describe_graph_precision(path) == "float32"
+
+
+def test_precision_of_a_graph_with_no_weights_is_unknown_not_guessed(tmp_path):
+    path = _graph_with_initializers([], tmp_path / "empty.onnx")
+    assert describe_graph_precision(path) == "unknown"
diff --git a/tests/unit/test_public_api.py b/tests/unit/test_public_api.py
new file mode 100644
index 0000000..554936d
--- /dev/null
+++ b/tests/unit/test_public_api.py
@@ -0,0 +1,28 @@
+"""Public-API guard: `__all__` is non-empty, importable, and matches the checked-in golden.
+
+If you intentionally change the public surface, regenerate the golden:
+    python -c "import mobiletransformers,pathlib; \
+      pathlib.Path('src/mobiletransformers/public_api.txt').write_text(chr(10).join(sorted(mobiletransformers.__all__))+chr(10))"
+"""
+
+from __future__ import annotations
+
+from importlib.resources import files
+
+import mobiletransformers
+
+
+def test_all_is_declared_and_nonempty():
+    assert mobiletransformers.__all__
+
+
+def test_all_names_are_importable():
+    for name in mobiletransformers.__all__:
+        assert hasattr(mobiletransformers, name), f"{name} in __all__ but not importable"
+
+
+def test_all_matches_golden():
+    golden = files("mobiletransformers").joinpath("public_api.txt").read_text().split()
+    assert sorted(mobiletransformers.__all__) == sorted(golden), (
+        "public surface drifted from public_api.txt; regenerate the golden if intentional"
+    )
diff --git a/tests/unit/test_registries.py b/tests/unit/test_registries.py
new file mode 100644
index 0000000..5435ef7
--- /dev/null
+++ b/tests/unit/test_registries.py
@@ -0,0 +1,324 @@
+"""Registries are the single source of truth: resolvers cover every legacy branch, fail closed,
+and no new business code reintroduces a string-literal dispatch."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+import pytest
+
+from mobiletransformers.config.constants import MergerVariant, PEFTMethod
+from mobiletransformers.config.registry import (
+    build_merger_model,
+    get_peft_spec,
+    resolve_architecture,
+    resolve_merger,
+)
+from mobiletransformers.config.registry.architecture import ARCHITECTURE_REGISTRY
+from mobiletransformers.config.registry.peft import (
+    PEFT_TARGET_MODULES_BY_MODEL_TYPE,
+    build_adapter_mapping,
+)
+from mobiletransformers.exceptions import UnsupportedModelError
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+# Every architecture the legacy trainer/builder.py:260-272 dispatch handled.
+LEGACY_TRAINING_ARCHES = [
+    "LlamaForCausalLM",
+    "GemmaForCausalLM",
+    "Gemma2ForCausalLM",
+    "Gemma3ForCausalLM",
+    "Phi3ForCausalLM",
+    "Qwen2ForCausalLM",
+    "OPTForCausalLM",
+    "BertModel",
+]
+
+
+#: Every architecture `inference/builder.py`'s 14-branch ladder dispatched — the #6 remainder.
+#: `ChatGLMForConditionalGeneration` and `ChatGLMModel` were one `or`-ed branch and need two rows,
+#: because the registry is keyed by `architectures[0]`.
+LEGACY_INFERENCE_ARCHES = [
+    "MistralForCausalLM",
+    "PhiForCausalLM",
+    "PhiMoEForCausalLM",
+    "Phi3SmallForCausalLM",
+    "Phi3VForCausalLM",
+    "NemotronForCausalLM",
+    "ChatGLMForConditionalGeneration",
+    "ChatGLMModel",
+]
+
+
+@pytest.mark.parametrize("arch", LEGACY_TRAINING_ARCHES)
+def test_resolve_architecture_covers_legacy_branches(arch):
+    spec = resolve_architecture(SimpleNamespace(architectures=[arch]))
+    assert spec.architecture == arch
+    assert spec.onnx_config_class  # a dotted path is present
+
+
+@pytest.mark.parametrize("arch", LEGACY_INFERENCE_ARCHES)
+def test_resolve_architecture_covers_the_inference_ladder(arch):
+    """The ladder's remaining branches are rows now, so adding an architecture is data, not an `elif`."""
+    spec = resolve_architecture(SimpleNamespace(architectures=[arch]))
+    assert spec.architecture == arch
+    # Either a direct inference class or a variant table — every ladder branch built *something*.
+    assert spec.inference_model_class or spec.variant_values
+
+
+def test_inference_only_architectures_fail_closed_on_training_export():
+    """PhiMoE/Phi3Small/Phi3V/ChatGLM have no Optimum OnnxConfig — say so rather than import-error later.
+
+    Checked against optimum-onnx 0.1.0's `model_configs`: those four classes do not exist. Binding a
+    plausible-looking name would have failed at export time with an AttributeError instead.
+    """
+    for arch in ("PhiMoEForCausalLM", "Phi3SmallForCausalLM", "Phi3VForCausalLM", "ChatGLMModel"):
+        spec = resolve_architecture(SimpleNamespace(architectures=[arch]))
+        assert spec.onnx_config_class is None
+        with pytest.raises(UnsupportedModelError, match="inference-only"):
+            spec.load_onnx_config_class()
+
+
+def test_ladder_side_effects_are_data_not_lost():
+    """Three branches mutated the request before constructing. A row naming only a class loses that."""
+    moe = resolve_architecture(SimpleNamespace(architectures=["PhiMoEForCausalLM"]))
+    assert moe.option_overrides == {"execution_provider": "cuda", "precision": "int4"}
+    assert moe.warnings  # the operator-facing reason, no longer a bare print()
+
+    phi3v = resolve_architecture(SimpleNamespace(architectures=["Phi3VForCausalLM"]))
+    assert phi3v.extra_option_overrides == {"exclude_embeds": True}
+
+    for arch in ("ChatGLMForConditionalGeneration", "ChatGLMModel"):
+        chatglm = resolve_architecture(SimpleNamespace(architectures=[arch]))
+        assert chatglm.config_overrides == {"hidden_act": "swiglu"}
+
+
+def test_variant_keyed_architectures_resolve_per_variant():
+    """Phi3Small splits 8K/128K on max_position_embeddings, exactly as the ladder's two branches did."""
+    spec = resolve_architecture(SimpleNamespace(architectures=["Phi3SmallForCausalLM"]))
+    assert spec.variant_key == "max_position_embeddings"
+    assert set(spec.variant_values) == {8192, 131072}
+    with pytest.raises(UnsupportedModelError, match="no inference variant"):
+        spec.load_inference_model_class(4096)
+
+
+def test_gemma_generations_bind_their_own_onnx_configs():
+    """Gemma2/Gemma3 are distinct architectures; the generic GemmaOnnxConfig describes neither.
+
+    **Corrected 2026-08-09.** This asserted `Gemma3ForCausalLM -> Gemma3OnnxConfig`, which is wrong
+    and made the test complicit in the defect: Gemma-3 ships as two model types, and optimum maps
+    `gemma3` (multimodal, `Gemma3ForConditionalGeneration`) to `Gemma3OnnxConfig` but `gemma3_text`
+    (text-only, `Gemma3ForCausalLM` — what `google/gemma-3-270m` is) to `Gemma3TextOnnxConfig`.
+    `Gemma3OnnxConfig.__init__` reads `config.text_config`, which a text-only config does not have,
+    so the binding could not even construct. It went unnoticed because the dotted paths resolve
+    lazily and nothing had exercised the row.
+
+    The generalizing guard is `tests/export/test_registry_matches_optimum.py`, which checks EVERY row
+    against optimum's own TasksManager mapping instead of restating expectations by hand here.
+    """
+    for arch, expected in (
+        ("Gemma2ForCausalLM", "Gemma2OnnxConfig"),
+        ("Gemma3ForCausalLM", "Gemma3TextOnnxConfig"),
+    ):
+        spec = resolve_architecture(SimpleNamespace(architectures=[arch]))
+        assert spec.onnx_config_class.endswith(expected)
+
+
+def test_resolve_architecture_unknown_fails_closed():
+    with pytest.raises(UnsupportedModelError):
+        resolve_architecture(SimpleNamespace(architectures=["TotallyMadeUpForCausalLM"]))
+    with pytest.raises(UnsupportedModelError):
+        resolve_architecture(SimpleNamespace(architectures=[]))
+
+
+@pytest.mark.parametrize("method", list(PEFTMethod))
+def test_get_peft_spec_covers_all_methods(method):
+    spec = get_peft_spec(method)
+    assert spec.method == method
+
+
+@pytest.mark.parametrize(
+    "method,quant_in,expected",
+    [
+        (PEFTMethod.LORA, False, MergerVariant.LORA),
+        (PEFTMethod.LORA, True, MergerVariant.LORA_Q),
+        (PEFTMethod.LORA_XS, False, MergerVariant.LORA),
+        (PEFTMethod.LORA_XS, True, MergerVariant.LORA_Q),
+        (PEFTMethod.MARS, False, MergerVariant.MARS_Q),
+        (PEFTMethod.MARS, True, MergerVariant.MARS_Q),
+    ],
+)
+def test_resolve_merger_variant_and_filename(method, quant_in, expected):
+    spec = resolve_merger(method, quant_in=quant_in, quant_out=True)
+    assert spec.variant == expected
+    assert "_2" not in spec.output_filename  # descriptive names, no legacy _2 duplication
+    assert spec.output_filename.endswith(".onnx")
+
+
+@pytest.mark.parametrize("method", [PEFTMethod.ALL, PEFTMethod.NOLORA])
+def test_resolve_merger_no_merger_methods_fail_closed(method):
+    with pytest.raises(UnsupportedModelError):
+        resolve_merger(method, quant_in=True, quant_out=True)
+
+
+def test_build_merger_model_emits_valid_graph(tmp_path):
+    """build_merger_model is wired (#9); byte-equivalence to the legacy factories lives in
+    tests/unit/test_merger_builder.py. Here we just confirm it emits a checkable graph."""
+    import onnx
+
+    spec = resolve_merger(PEFTMethod.LORA, quant_in=True, quant_out=True)
+    out = tmp_path / "out.onnx"
+    build_merger_model(spec, out)
+    onnx.checker.check_model(str(out))
+
+
+def test_architecture_registry_nonempty_and_consistent():
+    for name, spec in ARCHITECTURE_REGISTRY.items():
+        assert spec.architecture == name
+
+
+def test_no_string_literal_dispatch_in_src():
+    """New package code must dispatch through registries, never `x == "lora"` / `architectures[0] ==`.
+
+    Shares ONE definition of "banned pattern" and one comment-aware matcher with
+    ``tests/unit/test_guards.py``, which applies the same rules to the legacy roots and the C++ tree.
+    Keeping them in step matters during the migration: as a legacy module moves under ``src/`` its
+    dispatch debt moves from the guards' ``DISPATCH_ALLOWLIST`` to *this* test, which has no
+    allow-list — so a module must be clean before it is allowed to move.
+    """
+    from tests.unit.test_guards import DISPATCH_PATTERNS, _grep
+
+    src = REPO_ROOT / "src" / "mobiletransformers"
+    hits = _grep(DISPATCH_PATTERNS, [src], ("*.py",))
+    assert not hits, (
+        "string-literal dispatch found in src/ — resolve it through config/registry/ "
+        "(a module carrying dispatch debt must be cleaned BEFORE it migrates):\n" + "\n".join(hits)
+    )
+
+
+# --- #6 A3: build_adapter_mapping + the deduplicated PEFT target table -----------------------------
+def test_build_adapter_mapping_returns_empty_for_methods_without_adapters():
+    for method in (PEFTMethod.ALL, PEFTMethod.NOLORA):
+        assert build_adapter_mapping(method, object()) == {}
+
+
+def test_build_adapter_mapping_dispatches_per_method():
+    """The registry resolves WHICH builder runs; callers never branch on the method string."""
+    calls: list[tuple[str, dict]] = []
+
+    def fake(model, **kwargs):
+        calls.append((model, kwargs))
+        return {"layer": {"adapter_A": "a"}}
+
+    for method in (PEFTMethod.LORA, PEFTMethod.LORA_XS, PEFTMethod.MARS):
+        spec = get_peft_spec(method)
+        assert spec.mapping_builder is not None, f"{method} claims builds_mapping but has no builder"
+        with mock.patch("mobiletransformers.config.registry.peft.import_from_path", return_value=fake):
+            assert build_adapter_mapping(method, "model-obj") == {"layer": {"adapter_A": "a"}}
+    assert [c[0] for c in calls] == ["model-obj"] * 3
+
+
+def test_peft_target_modules_table_has_one_source():
+    """#6: the MARS and ablation tables were byte-identical copies under two names."""
+    from mobiletransformers.peft.ablation.utils import (
+        TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING,
+    )
+    from mobiletransformers.peft.mars.utils import TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING
+
+    assert TRANSFORMERS_MODELS_TO_MARS_TARGET_MODULES_MAPPING is PEFT_TARGET_MODULES_BY_MODEL_TYPE
+    assert TRANSFORMERS_MODELS_TO_ABLATION_TARGET_MODULES_MAPPING is PEFT_TARGET_MODULES_BY_MODEL_TYPE
+
+
+def test_peft_target_table_is_wider_than_the_architecture_registry():
+    """Guards the reason these two tables are NOT merged: different key spaces, different coverage.
+
+    This asserted `len(peft) > len(registry)`, which was only ever a proxy for "wider coverage" and
+    stopped being true the moment the registry legitimately absorbed the inference ladder's 7 rows.
+    Size is not the property worth protecting; disjoint key spaces and encoder/seq2seq reach are.
+    """
+    # Different key spaces: model_type vs architectures[0]. Merging them would silently mis-key both.
+    assert "t5" in PEFT_TARGET_MODULES_BY_MODEL_TYPE  # model_type keys...
+    assert "LlamaForCausalLM" not in PEFT_TARGET_MODULES_BY_MODEL_TYPE  # ...not architecture keys
+    assert not (set(PEFT_TARGET_MODULES_BY_MODEL_TYPE) & set(ARCHITECTURE_REGISTRY))
+
+    # Different coverage: PEFT wraps encoders and seq2seq models the export registry does not build.
+    assert {"t5", "bart"} <= set(PEFT_TARGET_MODULES_BY_MODEL_TYPE)
+
+
+# --- projection-role map (#33 B1) ------------------------------------------------------------
+#
+# MARS locates its shared adapters by projection ROLE; the module NAMES are per-architecture data.
+# Before this existed, `peft/mars/model.py` hardcoded the Llama naming in five places, so on an
+# encoder every lookup missed, `projection_type` stayed None and MARS silently degraded to unshared
+# adapters. These tests pin the data half; the transfer itself is proven against a real model in
+# `tests/integration/test_mars_encoder_transfer.py`.
+
+
+@pytest.mark.parametrize(
+    ("arch", "expected"),
+    [
+        ("LlamaForCausalLM", {"q": "q_proj", "k": "k_proj", "v": "v_proj"}),
+        ("Qwen2ForCausalLM", {"q": "q_proj", "k": "k_proj", "v": "v_proj"}),
+        ("BertForSequenceClassification", {"q": "query", "k": "key", "v": "value"}),
+        ("RobertaForSequenceClassification", {"q": "query", "k": "key", "v": "value"}),
+        ("BertModel", {"q": "query", "k": "key", "v": "value"}),
+        ("DistilBertForSequenceClassification", {"q": "q_lin", "k": "k_lin", "v": "v_lin"}),
+    ],
+)
+def test_projection_names_are_per_architecture_data(arch, expected):
+    spec = ARCHITECTURE_REGISTRY[arch]
+    for role, name in expected.items():
+        assert spec.module_name_for_role(role) == name
+        assert spec.role_for_module(name) == role
+
+
+def test_every_target_module_resolves_to_a_role_or_is_deliberately_unmapped():
+    """A target module with no role gets a standalone adapter — that must be a decision, not a typo.
+
+    Every row's `target_modules` are the LoRA-convention Wq/Wv pair (or the fused/older equivalents),
+    so each one either maps to a role or is a documented fused/unsupported projection.
+    """
+    fused_or_unmapped = {
+        "qkv_proj",  # Phi3: one fused projection, not separable into q/k/v
+        "query_key_value",  # Phi3Small / ChatGLM: same, fused
+        "dense",  # Phi3Small / ChatGLM output projection
+        "out_proj",  # OPT output projection
+        "fc1",
+        "fc2",  # OPT MLP, not the gate/up shape MARS's shared MLP adapter describes
+    }
+    for arch, spec in ARCHITECTURE_REGISTRY.items():
+        for target in spec.target_modules:
+            role = spec.role_for_module(target)
+            assert role is not None or target in fused_or_unmapped, (
+                f"{arch}: target module {target!r} maps to no projection role and is not a known "
+                "fused/unsupported projection — MARS would silently give it a standalone adapter"
+            )
+
+
+def test_role_lookup_matches_the_leaf_exactly_not_as_a_substring():
+    """`attention_probs` must not read as `attention`; `q_proj_extra` must not read as `q_proj`."""
+    spec = ARCHITECTURE_REGISTRY["LlamaForCausalLM"]
+    assert spec.role_for_module("model.layers.0.self_attn.q_proj") == "q"
+    assert spec.role_for_module("q_proj_extra") is None
+    assert spec.role_for_module("query") is None  # decoder row must not answer to encoder naming
+
+
+def test_encoder_rows_do_not_claim_unverified_mlp_or_output_projections():
+    """BERT's MLP is `intermediate`/`output` — shapes MARS's shared MLP adapter does not describe.
+
+    Declaring a name here would claim a transfer nobody has verified, so the encoder rows map q/k/v
+    only, and `any_mlp` is therefore False for them by construction.
+    """
+    for arch in (
+        "BertForSequenceClassification",
+        "RobertaForSequenceClassification",
+        "DistilBertForSequenceClassification",
+        "BertModel",
+    ):
+        spec = ARCHITECTURE_REGISTRY[arch]
+        assert set(spec.projection_names) == {"q", "k", "v"}
+        assert spec.module_name_for_role("gate") is None
+        assert spec.module_name_for_role("up") is None
diff --git a/tests/unit/test_release_plumbing.py b/tests/unit/test_release_plumbing.py
new file mode 100644
index 0000000..1e6bbdc
--- /dev/null
+++ b/tests/unit/test_release_plumbing.py
@@ -0,0 +1,94 @@
+"""#28/#30/#32: release plumbing that should be checkable without a release.
+
+`make help` completeness and `clean-generated` non-destructiveness are #28 DoD items that were never
+written; the publication coordinates are #30's contract.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+MAKEFILE = REPO_ROOT / "Makefile"
+SDK_BUILD = REPO_ROOT / "android/MobileTransformers/MobileTransformers/build.gradle.kts"
+
+
+def _targets() -> set[str]:
+    """Rule targets declared in the Makefile (excluding pattern rules and variables)."""
+    return {
+        m.group(1)
+        for m in re.finditer(r"^([a-zA-Z][\w-]*):", MAKEFILE.read_text(encoding="utf-8"), re.MULTILINE)
+    }
+
+
+def _documented() -> set[str]:
+    return {
+        m.group(1)
+        for m in re.finditer(
+            r"^([a-zA-Z][\w-]*):.*?##\s+\S", MAKEFILE.read_text(encoding="utf-8"), re.MULTILINE
+        )
+    }
+
+
+def test_every_make_target_is_self_documented() -> None:
+    """`make help` greps for `## ` docstrings; an undocumented target is invisible to users."""
+    undocumented = sorted(_targets() - _documented())
+    assert not undocumented, f"targets missing a `## ` doc comment: {undocumented}"
+
+
+def test_phony_declares_every_target() -> None:
+    text = MAKEFILE.read_text(encoding="utf-8")
+    phony_block = text.split(".PHONY:", 1)[1].split("\n\n", 1)[0]
+    declared = set(phony_block.replace("\\", " ").split())
+    missing = sorted(_targets() - declared - {"help"})
+    assert not missing, f"targets missing from .PHONY: {missing}"
+
+
+def test_clean_generated_is_not_destructive() -> None:
+    """`clean-generated` must only remove BUILD output — never sources, tests or vendored deps."""
+    text = MAKEFILE.read_text(encoding="utf-8")
+    recipe = text.split("clean-generated:", 1)[1].split("\n\n", 1)[0]
+    # `agent_docs/` was dropped from this tuple on 2026-08-17 when the directory was untracked: the
+    # test asserted `clean-generated` would not delete something git no longer knows about, which is
+    # a check that can never fail. Deleted rather than left scanning the void.
+    forbidden = ("src/", "tests/", "android/", "docs/", "jniLibs", "third_party")
+    for token in forbidden:
+        assert f"rm -rf {token}" not in recipe, f"clean-generated would delete {token}"
+        assert f"rm -r {token}" not in recipe, f"clean-generated would delete {token}"
+    assert "build/" in recipe, "clean-generated should remove build/"
+
+
+@pytest.mark.skipif(not SDK_BUILD.is_file(), reason="Android tree not present")
+def test_publication_coordinates_are_the_agreed_ones() -> None:
+    text = SDK_BUILD.read_text(encoding="utf-8")
+    assert "`maven-publish`" in text, "the SDK module does not apply maven-publish"
+    assert 'artifactId = "mobiletransformers-android"' in text
+    assert "withSourcesJar()" in text, "#30 requires a sources jar"
+
+
+@pytest.mark.skipif(not SDK_BUILD.is_file(), reason="Android tree not present")
+def test_pom_license_matches_the_repository_license() -> None:
+    """A consumer resolving the POM relies on it; it must not advertise a licence we do not use."""
+    pom = SDK_BUILD.read_text(encoding="utf-8")
+    license_md = (REPO_ROOT / "LICENSE.md").read_text(encoding="utf-8")
+    if "Attribution-NonCommercial" in license_md:
+        assert "NonCommercial" in pom, "LICENSE.md is CC-BY-NC but the POM claims otherwise"
+    elif "Apache License" in license_md:
+        assert "Apache-2.0" in pom or "Apache License" in pom
+
+
+def test_third_party_notices_exist_and_cover_the_vendored_natives() -> None:
+    notices = (REPO_ROOT / "THIRD_PARTY_NOTICES.md").read_text(encoding="utf-8")
+    for component in ("ONNX Runtime", "tokenizers", "ObjectBox", "nlohmann/json"):
+        assert component in notices, f"THIRD_PARTY_NOTICES.md does not mention {component}"
+
+
+def test_changelog_records_the_required_non_goals() -> None:
+    """#32 requires the non-goals to be explicit, so they are not re-litigated per release."""
+    changelog = (REPO_ROOT / "CHANGELOG.md").read_text(encoding="utf-8")
+    non_goals = changelog.split("### Non-goals", 1)[1]
+    for phrase in ("GPU/NPU", "Multimodal"):
+        assert phrase in non_goals, f"CHANGELOG non-goals omit {phrase}"
diff --git a/tests/unit/test_settings_precedence.py b/tests/unit/test_settings_precedence.py
new file mode 100644
index 0000000..b2bf513
--- /dev/null
+++ b/tests/unit/test_settings_precedence.py
@@ -0,0 +1,106 @@
+"""Config-layering tests: precedence (CLI > env > YAML > default), settings caching, and shims."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from mobiletransformers.config import resolve
+from mobiletransformers.config import settings as settings_module
+from mobiletransformers.config.settings import Settings, get_settings
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+# --- precedence: CLI > env > YAML > default ---------------------------------------
+def test_resolve_cli_wins():
+    assert resolve("cli", "env", "yaml", "default") == "cli"
+
+
+def test_resolve_env_when_no_cli():
+    assert resolve(None, "env", "yaml", "default") == "env"
+
+
+def test_resolve_yaml_when_no_cli_env():
+    assert resolve(None, None, "yaml", "default") == "yaml"
+
+
+def test_resolve_default_when_nothing_else():
+    assert resolve(None, None, None, "default") == "default"
+
+
+def test_resolve_all_none():
+    assert resolve(None, None, None, None) is None
+
+
+# --- settings: env-driven, cached -------------------------------------------------
+def test_get_settings_reads_env(monkeypatch):
+    get_settings.cache_clear()
+    monkeypatch.setenv("HF_TOKEN", "tok-123")
+    monkeypatch.setenv("HF_CACHE", "/tmp/hf")
+    monkeypatch.setenv("GEMINI_API_KEY", "gem-xyz")
+    settings = get_settings()
+    assert isinstance(settings, Settings)
+    assert settings.hf_token == "tok-123"
+    assert str(settings.hf_cache) == "/tmp/hf"
+    assert settings.gemini_api_key == "gem-xyz"
+    assert settings.require_hf_token() == "tok-123"
+    get_settings.cache_clear()
+
+
+def test_get_settings_is_cached(monkeypatch):
+    get_settings.cache_clear()
+    monkeypatch.setenv("HF_TOKEN", "first")
+    first = get_settings()
+    monkeypatch.setenv("HF_TOKEN", "second")  # ignored: lru_cache returns the same object
+    second = get_settings()
+    assert first is second
+    assert second.hf_token == "first"
+    get_settings.cache_clear()
+
+
+@pytest.fixture(autouse=True)
+def _no_dotenv(monkeypatch):
+    """Neutralize a real `.env` for every test in this module.
+
+    `get_settings()` calls `load_dotenv()`, which writes `.env` into `os.environ` — so a
+    `monkeypatch.delenv("HF_TOKEN")` is silently undone, and these tests measured the developer's
+    machine rather than the precedence rules they are named after. Since `.env` is the DOCUMENTED
+    place to put `HF_TOKEN` (`config/settings.py` says so in its own error message), the suite went
+    red for anyone who followed the documentation.
+
+    Patched at the settings module rather than deleting the file, so nothing touches the developer's
+    real secrets.
+    """
+    monkeypatch.setattr(settings_module, "load_dotenv", lambda *a, **k: False)
+    get_settings.cache_clear()
+    yield
+    get_settings.cache_clear()
+
+
+def test_require_hf_token_raises_when_missing(monkeypatch):
+    get_settings.cache_clear()
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+    with pytest.raises(RuntimeError, match="HF_TOKEN is not set"):
+        get_settings().require_hf_token()
+    get_settings.cache_clear()
+
+
+# --- legacy import compatibility (deprecation shims) ------------------------------
+# Both shims are GONE. `tools/parser_config.py` went with the `tools/` root in S9;
+# the root `config.py` was deleted 2026-08-14 once its last two importers were repointed
+# (`evaluation/mobile/recommendation_eval.py` -> `get_settings()`, which also fixed a
+# ModuleNotFoundError from an installed wheel, and `research/offline_train_eval.py` ->
+# `mobiletransformers.config.constants`). The constants they re-exported are covered by the
+# symbol golden; the secrets are covered by the precedence tests above.
+def test_no_root_config_shim_remains():
+    """The root `config.py` must stay deleted — it shadowed the package name and was not in the wheel."""
+    assert not (REPO_ROOT / "config.py").exists()
+
+
+def test_experiment_constants_resolve_from_the_package():
+    from mobiletransformers.config.constants import BATCH_SIZE, TASK_EPOCHS
+
+    assert TASK_EPOCHS["boolq"] == 2
+    assert BATCH_SIZE == 32
diff --git a/tests/unit/test_symbol_golden.py b/tests/unit/test_symbol_golden.py
new file mode 100644
index 0000000..c1f691a
--- /dev/null
+++ b/tests/unit/test_symbol_golden.py
@@ -0,0 +1,320 @@
+"""Migration net: every legacy module's public symbols survive its move into the package.
+
+The Migration Map moves ~17.5k lines of essentially untested code. These modules cannot be imported in
+the core environment (torch / onnxruntime / optimum), and `inference/builder.py` is unimportable under
+*every* declared profile — so the net is static. That is the right shape anyway: the failure mode being
+guarded is "a symbol silently disappeared during a `git mv` + split", which AST comparison catches
+exactly.
+
+**To move a module:** move it, then add one line to `MODULE_LOCATIONS`. If the symbols still match, the
+move was symbol-preserving. If they do not, the diff names precisely what was dropped.
+
+Regenerate the golden only to add a module or record a deliberate, reviewed change:
+`python tests/fixtures/gen_legacy_symbol_golden.py`.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tests.fixtures.symbol_tools import public_symbols
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+_PKG = "src/mobiletransformers"
+GOLDEN = json.loads(
+    (REPO_ROOT / "tests" / "fixtures" / "legacy_symbol_golden.json").read_text(encoding="utf-8")
+)
+
+#: Logical module name -> its CURRENT repo-relative path. Add an entry when a module moves; the key
+#: stays the original name so the golden keeps working as the index.
+#:
+#: A module whose old path still holds a deprecation SHIM needs no entry: the shim re-exports the same
+#: `__all__`, so the golden matches at the original path either way. Entries here are for modules
+#: whose old path is gone, or that were SPLIT across several new modules (recorded as the split's
+#: primary home — the shim is what proves the whole surface survived).
+MODULE_LOCATIONS: dict[str, str] = {
+    # S5 — TFLite export needs tensorflow/keras/keras_nlp, which are in NO dependency profile, so it
+    # cannot ship in the package. Moved to the research tree rather than migrated.
+    "artifact.tflite_builder": "research/tflite/tflite_builder.py",
+    # S1 — split by concern; tools/utils.py remains as a shim re-exporting all ten names.
+    #   move_onnx_model/move_files_excluding/delete_directory -> utils/paths.py
+    #   create_chat_input/render_template                     -> utils/templating.py
+    #   load_and_save_dataset/trim_dataset/save_as_jsonl/preload_dataset -> training/data.py
+    #   MemoryLoggerCallback                                  -> training/callbacks.py
+    # S7 — the whole database/ root moved to rag/; the old paths keep import shims, but the golden
+    # should verify the REAL module, so it is pointed at the new home rather than at the re-export.
+    "database.builder": "src/mobiletransformers/rag/builder.py",
+    "database.query": "src/mobiletransformers/rag/query.py",
+    "database.vector_entity": "src/mobiletransformers/rag/vector_entity.py",
+    "database.json2entity": "src/mobiletransformers/rag/json2entity.py",
+    # S8 — the reusable evaluators moved into the package; the old paths keep import shims, but the
+    # golden should verify the REAL module, so it follows them to their new home.
+    "evaluation.eval_adapter_models": "src/mobiletransformers/evaluation/eval_adapter_models.py",
+    "evaluation.eval_adapter_onnx_model": "src/mobiletransformers/evaluation/eval_adapter_onnx_model.py",
+    "evaluation.mobile_evaluator": "src/mobiletransformers/evaluation/mobile_evaluator.py",
+    "evaluation.mobile.base_mobile_eval": "src/mobiletransformers/evaluation/mobile/base_mobile_eval.py",
+    "evaluation.mobile.mobile_eval": "src/mobiletransformers/evaluation/mobile/mobile_eval.py",
+    "evaluation.mobile.recommendation_eval": (
+        "src/mobiletransformers/evaluation/mobile/recommendation_eval.py"
+    ),
+    "evaluation.openehr.openehr_eval": "src/mobiletransformers/evaluation/openehr/openehr_eval.py",
+    "evaluation.openehr.openehr_eval_plots": (
+        "src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py"
+    ),
+    # S8 — hardcoded-path experiment scripts have NO importable API (zero classes/defs, work done in
+    # top-level statements), so they went to research/ rather than into an installable wheel — the same
+    # call S5 made for artifact/tflite_builder.py. See research/evaluation/README.md.
+    "evaluation.benchmark.arc_eval": "research/evaluation/benchmark/arc_eval.py",
+    "evaluation.benchmark.boolq_eval": "research/evaluation/benchmark/boolq_eval.py",
+    "evaluation.benchmark.hellaswag_eval": "research/evaluation/benchmark/hellaswag_eval.py",
+    "evaluation.benchmark.logiqa_eval": "research/evaluation/benchmark/logiqa_eval.py",
+    "evaluation.benchmark.winogrande_eval": "research/evaluation/benchmark/winogrande_eval.py",
+    "evaluation.test.test_eval_onnx": "research/evaluation/scripts/test_eval_onnx.py",
+    "evaluation.test.test_gen": "research/evaluation/scripts/test_gen.py",
+    "evaluation.test.test_gen_viz": "research/evaluation/scripts/test_gen_viz.py",
+    # S6b — inference/validator.py -> artifacts/validation.py
+    "inference.validator": "src/mobiletransformers/artifacts/validation.py",
+    "trainer.validator": "src/mobiletransformers/training/validators.py",
+    "trainer.merge_validator": "src/mobiletransformers/training/merge_validators.py",
+    "inference.builder": "src/mobiletransformers/inference/builder.py",
+    # S9 — the deprecation shims are GONE, so every remaining golden module needs its real home
+    # recorded here. Until S9 these resolved by falling back to the shim still sitting at the old
+    # path; that fallback no longer exists.
+    "inference.generator_genai": "research/genai/generator_genai.py",
+    "artifact.merger": "src/mobiletransformers/config/registry/merger.py",
+    "artifact.onnx_builder": "src/mobiletransformers/artifacts/builder.py",
+    "inference.export_inference_package": "src/mobiletransformers/export/inference_package.py",
+    "inference.generator": "src/mobiletransformers/inference/generator.py",
+    "peft_models.ablation.config": "src/mobiletransformers/peft/ablation/config.py",
+    "peft_models.ablation.layer": "src/mobiletransformers/peft/ablation/layer.py",
+    "peft_models.ablation.model": "src/mobiletransformers/peft/ablation/model.py",
+    "peft_models.ablation.utils": "src/mobiletransformers/peft/ablation/utils.py",
+    "peft_models.lora_xs.initialization_utils": "src/mobiletransformers/peft/lora_xs/initialization_utils.py",
+    "peft_models.lora_xs.latent_utils": "src/mobiletransformers/peft/lora_xs/latent_utils.py",
+    "peft_models.lora_xs.merger": "src/mobiletransformers/peft/lora_xs/merger.py",
+    "peft_models.lora_xs.svd_utils": "src/mobiletransformers/peft/lora_xs/svd_utils.py",
+    "peft_models.mars.config": "src/mobiletransformers/peft/mars/config.py",
+    "peft_models.mars.layer": "src/mobiletransformers/peft/mars/layer.py",
+    "peft_models.mars.model": "src/mobiletransformers/peft/mars/model.py",
+    "peft_models.mars.study": "src/mobiletransformers/peft/mars/study.py",
+    "peft_models.mars.utils": "src/mobiletransformers/peft/mars/utils.py",
+    "tools.parser_config": "src/mobiletransformers/config/constants.py",
+    "tools.tokenizer_export": "src/mobiletransformers/export/tokenizer_export.py",
+    "trainer.builder": "src/mobiletransformers/export/training_export.py",
+    "trainer.embedding_builder": "src/mobiletransformers/export/embedding_export.py",
+}
+
+#: Modules that now live under the package, keyed by their new path. Used by the placeholder check in
+#: `test_import_weight.py` so migrated code is recognised as migrated rather than as a stray file.
+MIGRATED_PATHS: set[str] = {
+    "src/mobiletransformers/utils/paths.py",
+    "src/mobiletransformers/utils/templating.py",
+    "src/mobiletransformers/training/data.py",
+    "src/mobiletransformers/training/callbacks.py",
+    "src/mobiletransformers/inference/generator.py",
+    "src/mobiletransformers/export/tokenizer_export.py",
+    # S2
+    "src/mobiletransformers/export/inference_package.py",
+    # S4
+    "src/mobiletransformers/training/preprocessing.py",
+    "src/mobiletransformers/peft/mapping.py",
+    "src/mobiletransformers/export/embedding_export.py",
+    "src/mobiletransformers/export/training_export.py",
+    # S5
+    "src/mobiletransformers/artifacts/builder.py",
+    # S8 — evaluation/ -> evaluation/ (library evaluators only)
+    "src/mobiletransformers/evaluation/eval_adapter_models.py",
+    "src/mobiletransformers/evaluation/eval_adapter_onnx_model.py",
+    "src/mobiletransformers/evaluation/mobile_evaluator.py",
+    "src/mobiletransformers/evaluation/mobile/base_mobile_eval.py",
+    "src/mobiletransformers/evaluation/mobile/mobile_eval.py",
+    "src/mobiletransformers/evaluation/mobile/recommendation_eval.py",
+    "src/mobiletransformers/evaluation/openehr/openehr_eval.py",
+    "src/mobiletransformers/evaluation/openehr/openehr_eval_plots.py",
+    # S6b — inference/validator.py -> artifacts/validation.py
+    "src/mobiletransformers/artifacts/validation.py",
+    # S8 side-effect — `load_mars_adapters` extracted from research/utils.py, because its only caller
+    # is now a PACKAGED module and `research/` is not part of the distribution.
+    "src/mobiletransformers/peft/adapters.py",
+    # S6 — the last and largest legacy module
+    "src/mobiletransformers/inference/builder.py",
+    # S6b — trainer validators
+    "src/mobiletransformers/training/validators.py",
+    "src/mobiletransformers/training/merge_validators.py",
+    # S6b side-effect — the benchmark dataset registry extracted from research/offline_train_eval.py,
+    # same reason as peft/adapters.py above.
+    "src/mobiletransformers/training/benchmark_datasets.py",
+    # S7 — database/ -> rag/
+    "src/mobiletransformers/rag/builder.py",
+    "src/mobiletransformers/rag/query.py",
+    "src/mobiletransformers/rag/vector_entity.py",
+    "src/mobiletransformers/rag/json2entity.py",
+    # S3 — peft_models/{mars,lora_xs,ablation} + create_orthogonal_matrices vendored from research/.
+    *(
+        f"src/mobiletransformers/peft/{sub}/{name}.py"
+        for sub, names in {
+            "mars": ("config", "layer", "model", "study", "utils", "matrices"),
+            "lora_xs": ("initialization_utils", "latent_utils", "merger", "svd_utils", "__init__"),
+            "ablation": ("config", "layer", "model", "utils"),
+        }.items()
+        for name in names
+    ),
+}
+
+
+#: Modules that were SPLIT BY CONCERN rather than moved, so no single path holds them. `MODULE_LOCATIONS`
+#: maps one module to one file and cannot express this; before S9 these resolved via the shim that stayed
+#: behind re-exporting all the parts. With the shims deleted the golden has to check the union.
+MODULE_SPLITS: dict[str, tuple[str, ...]] = {
+    # S1
+    "tools.utils": (
+        f"{_PKG}/utils/paths.py",
+        f"{_PKG}/utils/templating.py",
+        f"{_PKG}/training/data.py",
+        f"{_PKG}/training/callbacks.py",
+    ),
+    # S4
+    "trainer.utils": (
+        f"{_PKG}/training/preprocessing.py",
+        f"{_PKG}/peft/mapping.py",
+    ),
+}
+
+#: Legacy PACKAGE `__init__.py` files. The golden records ZERO public symbols for each, so deleting them
+#: in S9 loses nothing — asserted below rather than assumed.
+REMOVED_EMPTY_PACKAGES = frozenset(
+    {"artifact", "inference", "peft_models", "peft_models.lora_xs", "tools", "trainer"}
+)
+
+
+def current_path(dotted: str) -> Path:
+    relocated = MODULE_LOCATIONS.get(dotted)
+    if relocated:
+        return REPO_ROOT / relocated
+    candidate = REPO_ROOT / (dotted.replace(".", "/") + ".py")
+    if candidate.is_file():
+        return candidate
+    return REPO_ROOT / dotted.replace(".", "/") / "__init__.py"
+
+
+@pytest.mark.parametrize("dotted", sorted(GOLDEN), ids=lambda d: d)
+def test_public_symbols_survive_relocation(dotted: str) -> None:
+    expected = set(GOLDEN[dotted])
+
+    if dotted in REMOVED_EMPTY_PACKAGES:
+        # A legacy package `__init__.py` deleted in S9. Only safe because it defined nothing.
+        assert not expected, (
+            f"{dotted} is listed as an empty legacy package but the golden records {sorted(expected)} — "
+            "it carried symbols, so it cannot simply be deleted"
+        )
+        return
+
+    if dotted in MODULE_SPLITS:
+        paths = [REPO_ROOT / rel for rel in MODULE_SPLITS[dotted]]
+        missing_files = [str(p.relative_to(REPO_ROOT)) for p in paths if not p.is_file()]
+        assert not missing_files, f"{dotted} split into missing file(s): {missing_files}"
+        actual: set[str] = set()
+        for part in paths:
+            actual |= set(public_symbols(part))
+        dropped = sorted(expected - actual)
+        assert not dropped, f"{dotted} was split across {MODULE_SPLITS[dotted]} and the union lost: {dropped}"
+        return
+
+    path = current_path(dotted)
+    assert path.is_file(), (
+        f"{dotted} is at neither its original location nor a MODULE_LOCATIONS entry — "
+        "if it moved, record the new path there"
+    )
+
+    actual = set(public_symbols(path))
+    dropped = sorted(expected - actual)
+    assert not dropped, f"{dotted} ({path.relative_to(REPO_ROOT)}) lost public symbol(s): {dropped}"
+
+
+def test_golden_covers_every_legacy_module() -> None:
+    """The golden is FROZEN and must stay populated.
+
+    This used to call `collect()` and assert nothing was missing from the golden. Once S9 deleted the
+    seven legacy roots, `collect()` walked nothing and returned `{}`, so the assertion held for the
+    empty set — the test passed while checking nothing (found 2026-08-14, same class of rot as the two
+    empty-allow-list guards). There is no longer a source to collect from, so the meaningful invariant
+    is the opposite one: the recorded evidence must not be emptied out or truncated.
+    """
+    assert GOLDEN, "the symbol golden is empty — it is the migration's evidence and must not be reset"
+    assert len(GOLDEN) >= 40, f"the golden shrank to {len(GOLDEN)} modules; entries are never removed"
+    assert all(isinstance(v, list) for v in GOLDEN.values())
+
+
+#: Modules deliberately relocated OUTSIDE the package, with the reason. Anything else must land in
+#: `src/mobiletransformers/`.
+RELOCATED_OUT_OF_PACKAGE = {
+    "artifact.tflite_builder": "needs tensorflow/keras/keras_nlp — in no dependency profile",
+    # S8 — these have NO importable API: zero classes, zero functions, all work in top-level statements
+    # (so importing one runs a benchmark), against hardcoded `experiment_results/...` paths. An
+    # installable wheel must not ship modules that execute an experiment on import. They stay in the
+    # repo as the record of how published numbers were produced. See research/evaluation/README.md.
+    **{
+        f"evaluation.benchmark.{name}_eval": "top-level experiment script, hardcoded paths — not a library"
+        for name in ("arc", "boolq", "hellaswag", "logiqa", "winogrande")
+    },
+    **{
+        f"evaluation.test.{name}": "top-level experiment script, hardcoded paths — not a test either"
+        for name in ("test_eval_onnx", "test_gen", "test_gen_viz")
+    },
+    # S9 — a desktop prototype with no importers, kept as the reference the plans cite.
+    "inference.generator_genai": "desktop GenAI prototype, hardcoded path — reference, not library",
+}
+
+
+def test_relocations_point_at_the_package() -> None:
+    """A relocation must land under `src/mobiletransformers/` unless it is a recorded exception."""
+    for dotted, location in MODULE_LOCATIONS.items():
+        if dotted in RELOCATED_OUT_OF_PACKAGE:
+            assert not location.startswith("src/"), (
+                f"{dotted} is recorded as out-of-package but points into src/"
+            )
+            continue
+        assert location.startswith("src/mobiletransformers/"), (
+            f"{dotted} relocated to {location}, which is outside the package"
+        )
+
+
+# --- decorators ------------------------------------------------------------------------------------
+DECORATOR_GOLDEN = json.loads(
+    (REPO_ROOT / "tests" / "fixtures" / "legacy_decorator_golden.json").read_text(encoding="utf-8")
+)
+
+
+def _decorators_at(path: Path) -> dict[str, list[str]]:
+    from tests.fixtures.symbol_tools import decorated_definitions
+
+    return decorated_definitions(path) if path.is_file() else {}
+
+
+@pytest.mark.parametrize("dotted", sorted(DECORATOR_GOLDEN), ids=lambda d: d)
+def test_decorators_survive_relocation(dotted: str) -> None:
+    """A dropped DECORATOR changes behaviour while every symbol name survives.
+
+    Caught for real during S4: slicing `trainer/utils.py` by line started at
+    `class DataCollatorForSupervisedDataset` and left `@dataclass` behind, silently removing the
+    generated `__init__`. The symbol golden saw nothing wrong.
+    """
+    expected = DECORATOR_GOLDEN[dotted]
+
+    # A definition may still be at its original path, or have moved into any migrated module. Search
+    # both, rather than hand-maintaining a second relocation map that could itself go stale.
+    found: dict[str, list[str]] = dict(_decorators_at(current_path(dotted)))
+    for migrated in sorted(MIGRATED_PATHS):
+        for symbol, decorators in _decorators_at(REPO_ROOT / migrated).items():
+            found.setdefault(symbol, decorators)
+
+    for symbol, decorators in expected.items():
+        assert symbol in found, (
+            f"{dotted}.{symbol} carried {decorators} but is no longer a decorated top-level "
+            "definition anywhere — a decorator was dropped during a move"
+        )
+        lost = sorted(set(decorators) - set(found[symbol]))
+        assert not lost, f"{dotted}.{symbol} lost decorator(s): {lost}"
diff --git a/tests/unit/test_task_registry.py b/tests/unit/test_task_registry.py
new file mode 100644
index 0000000..7d453ba
--- /dev/null
+++ b/tests/unit/test_task_registry.py
@@ -0,0 +1,191 @@
+"""Unit tests for the task registry (`config/registry/task.py`, #6 pattern, consumed by #33).
+
+The registry replaced three task-shaped branches in `export/training_export.py`. Two were style; the
+third — `LoraConfig(..., task_type="CAUSAL_LM")` at both LoRA call sites — was a latent defect for any
+non-decoder model, which is why these tests assert the *encoder* row's values explicitly rather than
+just that lookups work.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.config.constants import TaskType
+from mobiletransformers.config.registry.task import TASK_REGISTRY, get_task_spec
+from mobiletransformers.exceptions import UnsupportedModelError
+
+
+def test_every_task_type_has_a_row():
+    """A TaskType with no row would fall through to a branch somewhere — that is the thing being removed."""
+    assert set(TASK_REGISTRY) == set(TaskType)
+
+
+def test_rows_are_self_consistent():
+    for task, spec in TASK_REGISTRY.items():
+        assert spec.task is task, f"{task} row declares task={spec.task}"
+
+
+def test_decoder_uses_causal_lm_and_a_kv_cache():
+    spec = get_task_spec(TaskType.TEXT_GENERATION)
+    assert spec.auto_model_class == "transformers.AutoModelForCausalLM"
+    assert spec.uses_kv_cache is True
+    assert spec.peft_task_type == "CAUSAL_LM"
+
+
+def test_encoder_uses_feature_extraction_and_no_kv_cache():
+    """The regression for the hardcoded `CAUSAL_LM`: an encoder must not be wrapped as a decoder."""
+    spec = get_task_spec(TaskType.FEATURE_EXTRACTION)
+    assert spec.auto_model_class == "transformers.AutoModel"
+    assert spec.uses_kv_cache is False
+    assert spec.peft_task_type == "FEATURE_EXTRACTION"
+
+
+def test_kv_cache_kwargs_are_absent_for_encoders_not_merely_false():
+    """A BertOnnxConfig does not accept `use_past` at all — passing `use_past=False` still raises."""
+    assert get_task_spec(TaskType.FEATURE_EXTRACTION).onnx_config_kwargs(training_mode=False) == {}
+    assert get_task_spec(TaskType.FEATURE_EXTRACTION).onnx_config_kwargs(training_mode=True) == {}
+
+
+def test_training_graphs_never_use_the_cache():
+    """The backward pass needs the full sequence; only the inference export asks for past-KV."""
+    decoder = get_task_spec(TaskType.TEXT_GENERATION)
+    assert decoder.onnx_config_kwargs(training_mode=True) == {
+        "use_past": False,
+        "use_past_in_inputs": False,
+    }
+    assert decoder.onnx_config_kwargs(training_mode=False) == {
+        "use_past": True,
+        "use_past_in_inputs": True,
+    }
+
+
+@pytest.mark.parametrize(
+    "wire",
+    ["text-generation", "text-generation-with-past", TaskType.TEXT_GENERATION],
+)
+def test_wire_strings_resolve_including_the_with_past_variant(wire):
+    """`-with-past` selects graph shape, not task identity — TasksManager owns that suffix."""
+    assert get_task_spec(wire).task is TaskType.TEXT_GENERATION
+
+
+def test_unknown_task_fails_closed_naming_the_alternatives():
+    with pytest.raises(UnsupportedModelError) as excinfo:
+        get_task_spec("image-classification")
+    message = str(excinfo.value)
+    assert "image-classification" in message
+    assert "feature-extraction" in message and "text-generation" in message
+
+
+# --- #33: sequence classification as a training objective ------------------------------------
+
+
+def test_sequence_classification_supervises_one_label_per_sequence():
+    """The axis that separates this objective from every decoder task."""
+    spec = get_task_spec(TaskType.SEQUENCE_CLASSIFICATION)
+
+    assert spec.label_shape == ("batch_size",)
+    assert spec.is_token_level is False
+    assert get_task_spec(TaskType.TEXT_GENERATION).is_token_level is True
+
+
+def test_sequence_classification_loads_a_head_and_wraps_it_as_seq_cls():
+    spec = get_task_spec(TaskType.SEQUENCE_CLASSIFICATION)
+    assert spec.auto_model_class == "transformers.AutoModelForSequenceClassification"
+    assert spec.peft_task_type == "SEQ_CLS"
+    assert spec.model_init_kwargs == {"num_labels": 2}
+    assert spec.uses_kv_cache is False
+
+
+def test_feature_extraction_is_declared_untrainable():
+    """`AutoModel` has no head and no loss, so a training graph is impossible — say so up front.
+
+    Without this the export dies deep inside torch with
+    `BertModel.forward() got an unexpected keyword argument 'labels'`.
+    """
+    assert get_task_spec(TaskType.FEATURE_EXTRACTION).trainable is False
+    assert get_task_spec(TaskType.TEXT_GENERATION).trainable is True
+    assert get_task_spec(TaskType.SEQUENCE_CLASSIFICATION).trainable is True
+
+
+def test_classification_keeps_its_head_out_of_quantization():
+    """ORT registers no gradient for DynamicQuantizeLinear.
+
+    Anything on the gradient path between the loss and the adapters must stay unquantized. A decoder
+    only routes through the LM head; BERT-family classification also routes through `pooler` and
+    `classifier`, and quantizing those fails `generate_artifacts` outright.
+    """
+    excluded = get_task_spec(TaskType.SEQUENCE_CLASSIFICATION).quantization_exclude_layers
+    assert "pooler" in excluded and "classifier" in excluded
+    assert get_task_spec(TaskType.TEXT_GENERATION).quantization_exclude_layers == ("embed_head",)
+
+
+def test_each_trainable_task_declares_a_wrapper_and_a_label_shape():
+    """A new objective is a row; this is the invariant a row has to satisfy to be usable."""
+    for task, spec in TASK_REGISTRY.items():
+        if not spec.trainable:
+            continue
+        assert spec.trainer_wrapper_class, f"{task} declares no trainer wrapper"
+        assert spec.label_shape, f"{task} is trainable but supervises no labels"
+
+
+# --- #33: package shape is declared per task, not decoder-assumed -------------------------------
+
+
+def test_only_a_trainable_task_claims_a_train_stage() -> None:
+    """`plan_export` used to claim `train` for every model, including tasks that cannot produce one.
+
+    `feature-extraction` has no head and therefore no loss, so a training graph is impossible; the
+    package advertised a stage that could never be built.
+    """
+    assert get_task_spec(TaskType.TEXT_GENERATION).stages == ("inference", "train")
+    assert get_task_spec(TaskType.SEQUENCE_CLASSIFICATION).stages == ("inference", "train")
+    assert get_task_spec(TaskType.FEATURE_EXTRACTION).stages == ("inference",)
+
+
+def test_only_cached_tasks_emit_a_genai_decoder_block_or_kv_metadata() -> None:
+    """Both side-cars describe a KV cache. An encoder has none, and claiming one is worse than silence.
+
+    `_stamp_runtime_metadata` writes head_dim/num_kv_heads/num_layers, which the Native engine sizes
+    its cache from; `_emit_genai_config` writes a `model.decoder` block naming `past_key_values.N`
+    inputs. Both ran unconditionally, so an encoder package advertised a cache it does not have.
+    """
+    decoder = get_task_spec(TaskType.TEXT_GENERATION)
+    assert decoder.emits_genai_config and decoder.stamps_kv_metadata
+
+    for task in (TaskType.FEATURE_EXTRACTION, TaskType.SEQUENCE_CLASSIFICATION):
+        spec = get_task_spec(task)
+        assert not spec.emits_genai_config, f"{task} must not claim a GenAI decoder block"
+        assert not spec.stamps_kv_metadata, f"{task} must not stamp KV-cache geometry"
+
+
+def test_the_parity_gate_is_task_data_and_its_absence_is_explicit() -> None:
+    """The causal checker shifts logits[:, :-1] vs input_ids[:, 1:] and needs rank-3 logits.
+
+    A per-sequence objective emits [batch, labels], so running it there raises rather than measures.
+    `None` records "this gate does not apply" — distinct from "the package is broken".
+    """
+    assert get_task_spec(TaskType.TEXT_GENERATION).parity_check is not None
+    assert get_task_spec(TaskType.SEQUENCE_CLASSIFICATION).parity_check is None
+    assert get_task_spec(TaskType.FEATURE_EXTRACTION).parity_check is None
+
+
+def test_kv_cache_facts_agree_within_each_row() -> None:
+    """A task that emits a decoder block or cache geometry must actually have a cache.
+
+    Declared as three fields rather than derived from one because they answer different questions (how
+    the ONNX config is CONSTRUCTED vs what the packager WRITES). This pins that they stay consistent,
+    so the split cannot silently rot into a contradiction.
+    """
+    for task, spec in TASK_REGISTRY.items():
+        if spec.emits_genai_config or spec.stamps_kv_metadata:
+            assert spec.uses_kv_cache, f"{task} claims cache side-cars without a KV cache"
+
+
+def test_every_declared_parity_check_and_stage_is_resolvable() -> None:
+    """Dotted paths are lazy, so a typo stays invisible until an export runs. Resolve them here."""
+    from mobiletransformers.config.registry.architecture import import_from_path
+
+    for task, spec in TASK_REGISTRY.items():
+        if spec.parity_check is not None:
+            assert callable(import_from_path(spec.parity_check)), f"{task}: parity_check not callable"
+        assert spec.stages[0] == "inference", f"{task}: every package ships an inference graph"
diff --git a/tests/unit/test_tensor_codec.py b/tests/unit/test_tensor_codec.py
new file mode 100644
index 0000000..9cf60e1
--- /dev/null
+++ b/tests/unit/test_tensor_codec.py
@@ -0,0 +1,232 @@
+"""Unit tests for TrainableTensorCodec + HandoffEntry/HandoffMap round-trip determinism (#8)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from mobiletransformers.artifacts.handoff_map import (
+    HandoffEntry,
+    HandoffMap,
+    ObservedInit,
+    TrainableTensorCodec,
+)
+from mobiletransformers.config.constants import PEFTMethod
+from mobiletransformers.config.registry.architecture import resolve_architecture
+from mobiletransformers.config.registry.peft import get_peft_spec
+from mobiletransformers.exceptions import HandoffError
+
+
+class _FakeConfig:
+    architectures = ["LlamaForCausalLM"]
+
+
+def _entry() -> HandoffEntry:
+    name = "model.layers.0.attn.q_proj.MatMul.weight"
+    return HandoffEntry(
+        training_base_layer_name="backbone.model.layers.0.self_attn.q_proj.base_layer",
+        dtype="float16",
+        shape=(4096, 4096),
+        checkpoint_names={"weight": "backbone.model.layers.0.self_attn.q_proj.base_layer.weight"},
+        merged_tensor_names={"weight": name},
+        inference_initializer_names={"weight": name},
+        external_data_location={"weight": name + ".bin"},
+    )
+
+
+def test_entry_round_trip_preserves_fields() -> None:
+    entry = _entry()
+    again = HandoffEntry.from_dict(entry.to_dict())
+    assert again == entry
+    assert again.shape == (4096, 4096)
+    assert again.dtype == "float16"
+
+
+def test_map_json_is_byte_deterministic_across_runs_and_entry_order() -> None:
+    a = _entry()
+    b = HandoffEntry(
+        training_base_layer_name="backbone.model.layers.1.self_attn.k_proj.base_layer",
+        dtype="float16",
+        shape=(4096, 1024),
+        merged_tensor_names={"weight": "model.layers.1.attn.k_proj.MatMul.weight"},
+        inference_initializer_names={"weight": "model.layers.1.attn.k_proj.MatMul.weight"},
+        external_data_location={"weight": "model.layers.1.attn.k_proj.MatMul.weight.bin"},
+    )
+    json1 = HandoffMap(entries=[a, b]).to_json()
+    json2 = HandoffMap(entries=[b, a]).to_json()  # different input order -> identical output
+    assert json1 == json2
+    # and it survives a load round-trip
+    reparsed = HandoffMap.from_dict(json.loads(json1))
+    assert reparsed.to_json() == json1
+
+
+def test_canonical_inference_name_applies_registry_rewrite() -> None:
+    arch = resolve_architecture(_FakeConfig())  # LlamaForCausalLM, attention_module_name="self_attn"
+    got = TrainableTensorCodec.canonical_inference_name(
+        "backbone.model.layers.0.self_attn.q_proj.base_layer", arch
+    )
+    assert got == "model.layers.0.attn.q_proj.MatMul"
+
+
+def test_from_peft_mapping_builds_entry_from_observed_names() -> None:
+    arch = resolve_architecture(_FakeConfig())
+    peft = get_peft_spec(PEFTMethod.LORA)
+    peft_mapping = {
+        "backbone.model.layers.0.self_attn.q_proj": {
+            "adapter_A": "backbone.model.layers.0.self_attn.q_proj.lora_A.default",
+            "adapter_B": "backbone.model.layers.0.self_attn.q_proj.lora_B.default",
+        }
+    }
+    observed = [ObservedInit("model.layers.0.attn.q_proj.MatMul.weight", "float16", (4096, 4096), "weight")]
+    entries = TrainableTensorCodec.from_peft_mapping(
+        peft_mapping, requires_grad=[], observed_inference_inits=observed, peft_spec=peft, arch_spec=arch
+    )
+    assert len(entries) == 1
+    e = entries[0]
+    assert e.inference_initializer_names["weight"] == "model.layers.0.attn.q_proj.MatMul.weight"
+    # external_initializer invariant holds by construction
+    assert e.merged_tensor_names == e.inference_initializer_names
+    assert e.checkpoint_names["adapter_A"].endswith("lora_A.default")
+    HandoffMap(entries=entries).validate()  # must pass
+
+
+def test_from_peft_mapping_raises_on_naming_drift() -> None:
+    arch = resolve_architecture(_FakeConfig())
+    peft = get_peft_spec(PEFTMethod.LORA)
+    peft_mapping = {"backbone.model.layers.0.self_attn.q_proj": {"adapter_A": "x", "adapter_B": "y"}}
+    # observed init for a DIFFERENT layer -> no match for the canonical seed -> drift error
+    observed = [ObservedInit("model.layers.9.attn.k_proj.MatMul.weight", "float16", (1, 1), "weight")]
+    with pytest.raises(HandoffError):
+        TrainableTensorCodec.from_peft_mapping(
+            peft_mapping, requires_grad=[], observed_inference_inits=observed, peft_spec=peft, arch_spec=arch
+        )
+
+
+def test_from_peft_mapping_quantized_names_come_from_observed() -> None:
+    arch = resolve_architecture(_FakeConfig())
+    peft = get_peft_spec(PEFTMethod.MARS)
+    seed = "model.layers.0.attn.q_proj.MatMul"
+    peft_mapping = {"backbone.model.layers.0.self_attn.q_proj": {"shared_A": "a", "adapter_B": "b"}}
+    observed = [
+        ObservedInit(f"{seed}.qweight", "int4", (4096, 2048), "weight_quantized"),
+        ObservedInit(f"{seed}.scales", "float16", (4096, 32), "scale"),
+        ObservedInit(f"{seed}.qzeros", "uint8", (4096, 32), "zero_point"),
+    ]
+    entries = TrainableTensorCodec.from_peft_mapping(
+        peft_mapping, requires_grad=[], observed_inference_inits=observed, peft_spec=peft, arch_spec=arch
+    )
+    q = entries[0].quantization
+    assert q is not None
+    assert q["scaleName"] == f"{seed}.scales"  # from observed, NOT base_layer_name
+    assert q["weightQuantizedName"] == f"{seed}.qweight"
+    HandoffMap(entries=entries).validate()
+
+
+def test_from_peft_mapping_derives_one_orientation_for_the_whole_package() -> None:
+    """The WIRING, not the pure function: a real export must reach the right orientation.
+
+    `derive_transpose_policy` has its own unit tests, but a correct function that nothing calls is
+    what caused the defect this guards — `ObservedInit.transposed` was a field with a sensible
+    meaning that no producer ever set. This drives `from_peft_mapping`, the single call site the
+    export actually uses, and asserts the value that lands on the entries.
+
+    Shapes mirror SmolLM2-135M with GQA, the mix that makes the package decidable:
+      * `q_proj` is SQUARE (576x576) and cannot decide its own orientation;
+      * `v_proj` is (576x192) on disk while `B @ A` is (192x576), so it is stored transposed.
+
+    Both must come out `already_transposed_for_inference` — the square one inheriting the answer
+    from the layer that could prove it. If the square layer were left to decide alone it would say
+    `no_transpose`, which is how a package ends up describing one export two different ways.
+    """
+    from mobiletransformers.artifacts.handoff_map import ALREADY_TRANSPOSED
+
+    arch = resolve_architecture(_FakeConfig())
+    peft = get_peft_spec(PEFTMethod.LORA)
+
+    def mapping(layer: str) -> dict[str, str]:
+        # The PEFT module path spelling, as the real export emits it (see any shipped
+        # weight_handoff_map.json `checkpointNames`) — NOT the training-graph initializer spelling.
+        base = f"base_model.model.model.layers.0.self_attn.{layer}"
+        return {"adapter_A": f"{base}.lora_A.lora", "adapter_B": f"{base}.lora_B.lora"}
+
+    peft_mapping = {
+        "backbone.model.layers.0.self_attn.q_proj": mapping("q_proj"),
+        "backbone.model.layers.0.self_attn.v_proj": mapping("v_proj"),
+    }
+    observed = [
+        ObservedInit("model.layers.0.attn.q_proj.MatMul.weight", "float32", (576, 576), "weight"),
+        ObservedInit("model.layers.0.attn.v_proj.MatMul.weight", "float32", (576, 192), "weight"),
+    ]
+    # Keyed by the TRAINING GRAPH initializer name, which is a different spelling again.
+    specs = {
+        "backbone.model.layers.0.self_attn.q_proj.lora_A.lora.weight": {
+            "dtype": "float32",
+            "shape": [8, 576],
+        },
+        "backbone.model.layers.0.self_attn.q_proj.lora_B.lora.weight": {
+            "dtype": "float32",
+            "shape": [576, 8],
+        },
+        "backbone.model.layers.0.self_attn.v_proj.lora_A.lora.weight": {
+            "dtype": "float32",
+            "shape": [8, 576],
+        },
+        "backbone.model.layers.0.self_attn.v_proj.lora_B.lora.weight": {
+            "dtype": "float32",
+            "shape": [192, 8],
+        },
+    }
+
+    entries = TrainableTensorCodec.from_peft_mapping(
+        peft_mapping,
+        requires_grad=[],
+        observed_inference_inits=observed,
+        peft_spec=peft,
+        arch_spec=arch,
+        trainable_tensor_specs=specs,
+    )
+
+    assert len(entries) == 2
+    assert {e.transpose_policy for e in entries} == {ALREADY_TRANSPOSED}, (
+        "the export did not resolve one orientation for the package: "
+        f"{ {e.training_base_layer_name: e.transpose_policy for e in entries} }"
+    )
+    HandoffMap(entries=entries).validate()
+
+
+def test_from_peft_mapping_refuses_a_map_that_describes_no_adapter_factors() -> None:
+    """Total adapter-spec drift must fail closed, not degrade to `no_transpose`.
+
+    Each adapter role is looked up by a DERIVED training-graph initializer name. A single miss is
+    tolerated (the role is left undescribed). But if specs were supplied and nothing matched at all,
+    every entry loses its `adapterShapes`, orientation becomes unobservable, and the package quietly
+    declares `no_transpose` — reproducing the 2026-08-14 defect through a name drift instead of an
+    unassigned field. This test uses the spelling my own first draft got wrong, which is how the
+    hazard was found.
+    """
+    arch = resolve_architecture(_FakeConfig())
+    peft = get_peft_spec(PEFTMethod.LORA)
+    base = "base_model.model.model.layers.0.self_attn.v_proj"
+    peft_mapping = {
+        "backbone.model.layers.0.self_attn.v_proj": {
+            "adapter_A": f"{base}.lora_A.lora",
+            "adapter_B": f"{base}.lora_B.lora",
+        }
+    }
+    observed = [ObservedInit("model.layers.0.attn.v_proj.MatMul.weight", "float32", (576, 192), "weight")]
+    # Real-looking specs under a spelling `to_checkpoint_name` does not produce.
+    drifted = {
+        f"{base}.lora_A.lora.weight": {"dtype": "float32", "shape": [8, 576]},
+        f"{base}.lora_B.lora.weight": {"dtype": "float32", "shape": [192, 8]},
+    }
+
+    with pytest.raises(HandoffError, match="none matched any adapter role"):
+        TrainableTensorCodec.from_peft_mapping(
+            peft_mapping,
+            requires_grad=[],
+            observed_inference_inits=observed,
+            peft_spec=peft,
+            arch_spec=arch,
+            trainable_tensor_specs=drifted,
+        )
diff --git a/tests/unit/test_train_inference_parity.py b/tests/unit/test_train_inference_parity.py
new file mode 100644
index 0000000..be5eed9
--- /dev/null
+++ b/tests/unit/test_train_inference_parity.py
@@ -0,0 +1,110 @@
+"""Unit tests for the train-vs-inference parity check (`artifacts/train_inference_parity.py`).
+
+Only the pure leg — the loss computation and the skip behaviour — runs here. Running either graph needs
+`onnxruntime` (and `onnxruntime.training` for the training half), which live in profiles that conflict
+with the core one; the wired end-to-end run is the `make device-package TRAIN=1` leg.
+
+The causal-shift tests matter more than they look: a double shift is exactly what made the old
+host-side `onnx_checktrain` loss incomparable to the device's, and it is invisible unless asserted.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pytest
+
+from mobiletransformers.artifacts.train_inference_parity import (
+    MAX_LOSS_DELTA_NATS,
+    ParityResult,
+    causal_cross_entropy,
+    verify_train_inference_parity,
+)
+
+
+def test_perfect_prediction_gives_zero_loss():
+    """A graph that assigns all mass to the true next token scores 0 nats."""
+    vocab = 8
+    input_ids = np.array([[1, 2, 3, 4]], dtype=np.int64)
+    logits = np.full((1, 4, vocab), -1e4, dtype=np.float32)
+    # Position i must predict token i+1.
+    for pos, target in enumerate(input_ids[0, 1:]):
+        logits[0, pos, target] = 1e4
+
+    assert causal_cross_entropy(logits, input_ids) == pytest.approx(0.0, abs=1e-6)
+
+
+def test_uniform_logits_give_the_uniform_floor():
+    """Uniform prediction is `ln(vocab_size)` — the reference the device test's message cites."""
+    vocab = 50
+    input_ids = np.array([[1, 2, 3, 4, 5]], dtype=np.int64)
+    logits = np.zeros((1, 5, vocab), dtype=np.float32)
+
+    assert causal_cross_entropy(logits, input_ids) == pytest.approx(math.log(vocab), abs=1e-6)
+
+
+def test_the_shift_is_causal_and_applied_once():
+    """Predicting token i from position i (no shift) must NOT score zero.
+
+    A double shift is the defect this pins: the loss is defined over `logits[:, :-1]` against
+    `input_ids[:, 1:]`, so logits aligned to the *current* token are wrong by exactly one position and
+    must be penalised.
+    """
+    vocab = 8
+    input_ids = np.array([[1, 2, 3, 4]], dtype=np.int64)
+
+    aligned_to_current = np.full((1, 4, vocab), -1e4, dtype=np.float32)
+    for pos, target in enumerate(input_ids[0]):
+        aligned_to_current[0, pos, target] = 1e4
+
+    assert causal_cross_entropy(aligned_to_current, input_ids) > 100.0
+
+
+def test_loss_is_stable_at_extreme_magnitudes():
+    """Observed fp values reached 1e8 on a broken graph; the log-sum-exp must not overflow to nan."""
+    vocab = 16
+    input_ids = np.array([[1, 2, 3]], dtype=np.int64)
+    logits = np.full((1, 3, vocab), 1.5e8, dtype=np.float32)
+
+    loss = causal_cross_entropy(logits, input_ids)
+    assert math.isfinite(loss)
+    assert loss == pytest.approx(math.log(vocab), abs=1e-6)
+
+
+def test_rejects_non_sequence_logits():
+    with pytest.raises(ValueError, match=r"\[batch, seq, vocab\]"):
+        causal_cross_entropy(np.zeros((4, 8), dtype=np.float32), np.zeros((4, 8), dtype=np.int64))
+
+
+def test_parity_result_delta_is_absolute():
+    """Either half may be the higher one; the bound is on the magnitude of the disagreement."""
+    assert ParityResult(inference_loss=3.0, training_loss=3.4).delta == pytest.approx(0.4)
+    assert ParityResult(inference_loss=3.4, training_loss=3.0).delta == pytest.approx(0.4)
+
+
+def test_quantization_sized_gap_is_inside_the_bound_and_a_broken_graph_is_not():
+    """The bound must admit the measured quantization gap and exclude a weights-lost graph.
+
+    0.39 nats is the measured SmolLM2-135M fp32-vs-uint8 gap; a graph that had lost its pretrained
+    weights sits at the uniform floor (10.80 for this tokenizer), nats away from a ~3 nat reference.
+    """
+    assert ParityResult(inference_loss=13.861, training_loss=14.254).delta < MAX_LOSS_DELTA_NATS
+    assert ParityResult(inference_loss=3.0, training_loss=10.80).delta > MAX_LOSS_DELTA_NATS
+
+
+def test_skips_loudly_when_the_training_runtime_is_absent(tmp_path, caplog, monkeypatch):
+    """In the core profile the check cannot run — it must say so, never silently pass."""
+    import builtins
+
+    real_import = builtins.__import__
+
+    def _no_ort_training(name, *args, **kwargs):
+        if name.startswith("onnxruntime"):
+            raise ImportError("no onnxruntime in the core profile")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _no_ort_training)
+
+    assert verify_train_inference_parity(tmp_path / "model.onnx", tmp_path / "train") is None
+    assert "SKIPPED" in caplog.text
diff --git a/tests/unit/test_trainable_gate.py b/tests/unit/test_trainable_gate.py
new file mode 100644
index 0000000..e73dd9c
--- /dev/null
+++ b/tests/unit/test_trainable_gate.py
@@ -0,0 +1,97 @@
+"""The requested-vs-realized trainable-tensor gate.
+
+Runs in the core env: the decision lives in `artifacts/trainable_gate.py` precisely so it does not
+need the `ort-training-local` profile to be tested (`artifacts/builder.py` imports
+`onnxruntime.training` at module scope).
+
+The fixtures below are the REAL names from the exports that exposed this — a BERT encoder and a Llama
+decoder under MARS — so the test fails for the same reason the export did.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mobiletransformers.artifacts.trainable_gate import (
+    assert_every_requested_tensor_is_trainable,
+    is_quant_companion,
+)
+from mobiletransformers.exceptions import ExportError
+
+# One MARS-adapted BERT layer: the per-module up-projection plus the block's shared pair.
+_UP = "backbone.bert.encoder.layer.0.attention.self.query.up_project.mars.weight"
+_SHARED_DOWN = "backbone.bert.encoder.layer.0.attention.self.query.shared_qkv.mars_down_qkv.weight"
+_SHARED_MIX = "backbone.bert.encoder.layer.0.attention.self.query.shared_qkv.mars.weight"
+
+
+def test_quant_companion_suffixes():
+    assert is_quant_companion(f"{_SHARED_MIX}_quantized")
+    assert is_quant_companion(f"{_SHARED_MIX}_scale")
+    assert is_quant_companion(f"{_SHARED_MIX}_zero_point")
+    assert not is_quant_companion(_SHARED_MIX)
+
+
+def test_passes_when_every_requested_tensor_survives():
+    requested = [_UP, _SHARED_DOWN, _SHARED_MIX]
+    assert_every_requested_tensor_is_trainable(requested, list(requested), frozen=[])
+
+
+def test_catches_the_defect_it_was_written_for():
+    """MARS's shared adapter quantized away, the per-module factor kept — the exact shipped state.
+
+    Before the quantizer learned to exclude declared-trainable tensors, this is what every quantized
+    MARS export produced: half the requested set demoted to frozen, no error, training still running,
+    loss still falling. 12 realized of 24 requested on an encoder; 4 of 8 on a decoder.
+    """
+    requested = [_UP, _SHARED_DOWN, _SHARED_MIX]
+    realized = [_UP]
+    frozen = [
+        f"{_SHARED_DOWN}_quantized",
+        f"{_SHARED_DOWN}_scale",
+        f"{_SHARED_DOWN}_zero_point",
+        f"{_SHARED_MIX}_quantized",
+        f"{_SHARED_MIX}_scale",
+        f"{_SHARED_MIX}_zero_point",
+    ]
+
+    with pytest.raises(ExportError) as excinfo:
+        assert_every_requested_tensor_is_trainable(requested, realized, frozen)
+
+    message = str(excinfo.value)
+    assert "2 of 3" in message
+    # It must say WHY, not just that a count differs — the whole failure mode is that quantized
+    # means frozen, and nothing else in the pipeline says so.
+    assert "QUANTIZED" in message
+    assert "shared_qkv" in message, "the error must name a lost tensor"
+
+
+def test_distinguishes_quantized_away_from_absent():
+    """Two different causes need two different fixes, so the message must separate them."""
+    requested = [_UP, _SHARED_MIX]
+    with pytest.raises(ExportError) as excinfo:
+        assert_every_requested_tensor_is_trainable(
+            requested, realized=[], frozen=[f"{_SHARED_MIX}_quantized"]
+        )
+    message = str(excinfo.value)
+    assert "QUANTIZED" in message
+    assert "absent from the graph entirely" in message
+
+
+def test_compares_sets_not_counts():
+    """A count can coincide while the wrong tensors are frozen — that must still fail."""
+    requested = [_UP, _SHARED_DOWN]
+    # Same number realized as requested, but it is the same tensor twice and _SHARED_DOWN is gone.
+    realized = [_UP, f"{_UP}_duplicate_suffix"]
+    with pytest.raises(ExportError, match="1 of 2"):
+        assert_every_requested_tensor_is_trainable(requested, realized, frozen=[f"{_SHARED_DOWN}_quantized"])
+
+
+def test_substring_matching_matches_the_selection_rule():
+    """`gen_artifacts` selects by substring, so the gate must judge by the same rule or disagree.
+
+    A requested parameter `…lora_B.lora.weight` is realized as the graph initializer of that name;
+    judging by equality would report a false loss for any name the graph decorates.
+    """
+    requested = ["backbone.model.layers.0.self_attn.q_proj.lora_B.lora.weight"]
+    realized = ["prefix/backbone.model.layers.0.self_attn.q_proj.lora_B.lora.weight"]
+    assert_every_requested_tensor_is_trainable(requested, realized, frozen=[])
diff --git a/tests/unit/test_version_sites.py b/tests/unit/test_version_sites.py
new file mode 100644
index 0000000..58473f2
--- /dev/null
+++ b/tests/unit/test_version_sites.py
@@ -0,0 +1,144 @@
+"""#32: the version appears in several places and they must never disagree.
+
+`pyproject.toml` is the single write-site. Everything else either derives from it at runtime or is a
+declaration that this test pins to it. Previously `__version__` was hardcoded (a second write-site) and
+`CITATION.cff` advertised a `1.0.0 / 2025-10-18` release that did not exist — against a `0.1.0` package
+with zero git tags.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+GRADLE_PROPERTIES = REPO_ROOT / "android/MobileTransformers/gradle.properties"
+CONSUMER_PROPERTIES = REPO_ROOT / "examples/consumer-app/gradle.properties"
+CITATION = REPO_ROOT / "CITATION.cff"
+
+_SEMVER = re.compile(r"^\d+\.\d+\.\d+([-+].+)?$")
+
+
+def declared_version() -> str:
+    """The one authoritative version: ``pyproject.toml``'s ``[project] version``.
+
+    Parsed with a regex rather than ``tomllib`` because the core gate runs on Python 3.10, where
+    ``tomllib`` does not exist — and this test must not need a dependency to check a version.
+    """
+    text = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    project = text.split("[project]", 1)[1]
+    match = re.search(r'^version\s*=\s*"([^"]+)"', project, re.MULTILINE)
+    assert match, "pyproject.toml [project] declares no version"
+    return match.group(1)
+
+
+def _properties(path: Path) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if line and not line.startswith("#") and "=" in line:
+            key, _, value = line.partition("=")
+            values[key.strip()] = value.strip()
+    return values
+
+
+def test_declared_version_is_semver() -> None:
+    assert _SEMVER.match(declared_version()), declared_version()
+
+
+def test_runtime_version_derives_from_the_package_metadata() -> None:
+    """`__version__` must be read, not restated — a literal here is a second write-site."""
+    import mobiletransformers
+
+    assert mobiletransformers.__version__ == declared_version()
+
+    source = (REPO_ROOT / "src/mobiletransformers/__init__.py").read_text(encoding="utf-8")
+    assert 'version("mobiletransformers")' in source, "__version__ should come from importlib.metadata"
+    assert f'__version__ = "{declared_version()}"' not in source, "__version__ is hardcoded again"
+
+
+@pytest.mark.skipif(not GRADLE_PROPERTIES.is_file(), reason="Android tree not present")
+def test_gradle_version_matches() -> None:
+    props = _properties(GRADLE_PROPERTIES)
+    assert "version" in props, f"{GRADLE_PROPERTIES.name} declares no `version`"
+    assert props["version"] == declared_version()
+
+
+@pytest.mark.skipif(not CONSUMER_PROPERTIES.is_file(), reason="consumer example not present")
+def test_the_consumer_example_resolves_a_version_that_exists() -> None:
+    """`examples/consumer-app` is the proof that the published AAR is consumable from outside this
+    repo — so it has to ask for the version this repo actually publishes.
+
+    It was pinned at `0.1.0` against a `0.2.0` project, one minor behind, under a comment in that
+    same file promising it was kept in step. The guard stopped one directory short of the file that
+    drifted, which is the whole reason this exists: a version site nobody checks is a version site
+    that rots, and this one rots in the example a newcomer is most likely to copy.
+    """
+    props = _properties(CONSUMER_PROPERTIES)
+    assert "mobiletransformersVersion" in props, (
+        f"{CONSUMER_PROPERTIES} declares no `mobiletransformersVersion`"
+    )
+    assert props["mobiletransformersVersion"] == declared_version(), (
+        "the consumer example resolves an SDK version this repository does not publish"
+    )
+
+
+@pytest.mark.skipif(not GRADLE_PROPERTIES.is_file(), reason="Android tree not present")
+def test_gradle_group_is_the_publication_coordinate() -> None:
+    """`00_code_plans/04` said `com.martinkorelic`; `05_code_plans/03` (the publication plan) wins."""
+    assert _properties(GRADLE_PROPERTIES).get("group") == "com.martinkorelic.mobiletransformers"
+
+
+def test_citation_version_matches() -> None:
+    text = CITATION.read_text(encoding="utf-8")
+    match = re.search(r"^version:\s*(\S+)\s*$", text, re.MULTILINE)
+    assert match, "CITATION.cff declares no version"
+    assert match.group(1) == declared_version()
+
+
+def test_citation_release_date_is_not_in_the_future() -> None:
+    """A citation must not advertise a release that has not happened."""
+    from datetime import date
+
+    text = CITATION.read_text(encoding="utf-8")
+    match = re.search(r"^date-released:\s*(\d{4})-(\d{2})-(\d{2})\s*$", text, re.MULTILINE)
+    assert match, "CITATION.cff declares no date-released"
+    released = date(*(int(g) for g in match.groups()))
+    assert released <= date.today(), f"date-released {released} is in the future"
+
+
+def test_manifest_version_site_is_derived_not_hardcoded() -> None:
+    """The 5th version site: the manifest's `mobiletransformersVersion`.
+
+    `export/pipeline.py` derives it from `importlib.metadata`, so a real export is always correct.
+    The FIXTURES were the rot risk: three of them hardcoded "0.1.0", so a version bump would have left
+    the committed package, its generator and the pipeline test disagreeing with `pyproject.toml`
+    while every other version test stayed green.
+    """
+    import json
+
+    expected = declared_version()
+    fixture = REPO_ROOT / "tests/fixtures/tiny_package/mobiletransformers_manifest.json"
+    manifest = json.loads(fixture.read_text(encoding="utf-8"))
+    assert manifest["mobiletransformersVersion"] == expected, (
+        f"{fixture.relative_to(REPO_ROOT)} says {manifest['mobiletransformersVersion']!r}, "
+        f"pyproject says {expected!r} — regenerate it with tests/fixtures/make_tiny_package.py"
+    )
+
+    for path in (
+        REPO_ROOT / "tests/fixtures/make_tiny_package.py",
+        REPO_ROOT / "tests/export/test_pipeline.py",
+    ):
+        text = path.read_text(encoding="utf-8")
+        if "mobiletransformersVersion" not in text:
+            continue
+        for line in text.splitlines():
+            if "mobiletransformersVersion" in line and '"' in line.split(":", 1)[-1]:
+                literal = re.search(r'"mobiletransformersVersion":\s*"([^"]+)"', line)
+                if literal:
+                    assert literal.group(1) == expected, (
+                        f"{path.relative_to(REPO_ROOT)} hardcodes "
+                        f"{literal.group(1)!r}; pyproject says {expected!r}"
+                    )
diff --git a/third_party/android/manifest.json b/third_party/android/manifest.json
new file mode 100644
index 0000000..379fa2c
--- /dev/null
+++ b/third_party/android/manifest.json
@@ -0,0 +1,151 @@
+{
+  "schemaVersion": "1.0",
+  "minReaderVersion": "1.0",
+  "version": "0.2.0",
+  "_comment": [
+    "The Android native dependencies a `git clone` does NOT bring, and the only thing standing",
+    "between a fresh checkout and a buildable Android SDK.",
+    "",
+    "Every path below is gitignored: together they are ~180 MB of prebuilt binaries and vendored",
+    "headers that cannot live in git. Before this file existed their absence was undiscoverable —",
+    "`android_build_aar.sh` failed pointing at a docs page that never mentioned jniLibs at all.",
+    "",
+    "`scripts/fetch_native_deps.sh` is the consumer: it downloads `bundles[].filename` from",
+    "`baseUrl`, verifies the archive sha256, unpacks it under `unpackRoot`, and then verifies every",
+    "`artifacts[]` sha256 individually. Both checks matter — the archive hash proves the download,",
+    "the per-file hashes prove the unpack, and a half-populated jniLibs is the failure mode that",
+    "produces a linker error naming nothing.",
+    "",
+    "`make doctor` reports which of these are missing without downloading anything."
+  ],
+
+  "unpackRoot": "android/MobileTransformers/MobileTransformers/src/main",
+
+  "baseUrl": "https://huggingface.co/datasets/mobiletransformers/build-artifacts/resolve/main",
+  "_baseUrl_comment": [
+    "A PUBLIC Hugging Face dataset repo, and public is load-bearing: this fetch happens before the",
+    "first build on a machine that has nothing, so it must work with no token and no CLI. An",
+    "anonymous `resolve/main/<file>` request answers 302-to-CDN then 200, which `curl -fL` follows.",
+    "",
+    "Not a Storage Bucket: buckets are the more natural home for a pile of build outputs, but their",
+    "documented access paths are the `hf` CLI, the Python API and an S3 endpoint — a dependency the",
+    "bootstrap step cannot take. Not a GitHub Release: those were unreachable while the repository",
+    "was private, and this had to work before it went public.",
+    "",
+    "Producer: `scripts/publish_build_artifacts.py` (`make publish-artifacts`).",
+    "Override at call time with URL=<base> for a mirror or a local file:// path."
+  ],
+
+  "bundles": [
+    {
+      "name": "natives",
+      "filename": "mobiletransformers-natives-0.2.0-arm64-v8a.tar.zst",
+      "sha256": "e4b00892d719fabe6dfcc7b52d5886e404997ed89e45337caf28bf0e47450fa1",
+      "size": 65787553,
+      "required": true,
+      "contains": ["jniLibs/arm64-v8a/", "aarLibs/", "cpp/includes/"],
+      "note": "Everything needed to build and run the Android SDK. Stripped to the same bytes AGP would strip to at packaging, so this costs clone size, never APK size."
+    },
+    {
+      "name": "debug-symbols",
+      "filename": "mobiletransformers-natives-0.2.0-arm64-v8a-debug-symbols.tar.zst",
+      "sha256": "2383869b5015b0c3d3db83b7572542cf175598889f6d83f5d46eca84d0cd23d6",
+      "size": 272913723,
+      "required": false,
+      "contains": ["jniLibs/arm64-v8a/"],
+      "note": "The UNSTRIPPED originals, for symbolicating a native crash. Not needed to build. These cannot be regenerated without a full ORT source build, so this archive is the only copy — see docs/ARCHITECTURE.md."
+    }
+  ],
+
+  "artifacts": [
+    {
+      "path": "jniLibs/arm64-v8a/libonnxruntime.so",
+      "size": 59872456,
+      "sha256": "49dfafa414ecf9aa8d02f063787890ea76669cfa0874e7d63540b17948dcfdcb",
+      "provenance": "ONNX Runtime *training* 1.23.0, source-built (see third_party/onnxruntime/manifest.json for the commit). Version string verified in the binary.",
+      "role": "Linked by libmobiletransformers.so. Keeps the SONAME libonnxruntime.so; the GenAI engine gets libort_gen.so instead so the two ORTs never collide."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libort_gen.so",
+      "size": 27985664,
+      "sha256": "70c0a5b67d70ce9907263dcb0436610abb9ef0ad9a81551e6907388c34d6db16",
+      "provenance": "Stock ONNX Runtime 1.27.0 Android AAR from Maven Central, with its SONAME raw-patched to libort_gen.so. Version string verified in the binary. Reproduce with spikes/genai_external_swap/setup_ort_separation.sh.",
+      "role": "The ORT that GenAI dlopens. The distinct SONAME is essential — with both named libonnxruntime.so the linker dedups them and GenAI silently gets the training build (observed: SIGABRT)."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libonnxruntime-genai.so",
+      "size": 5628272,
+      "sha256": "7d28291ab238b9c977db490175da94461c49e98ed24755f10b27e3cf325ed043",
+      "provenance": "Extracted from aarLibs/onnxruntime-genai.aar, stripped, and raw-patched so its dlopen target reads libort_gen.so instead of libonnxruntime.so.",
+      "role": "The GenAI inference engine."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libonnxruntime-genai-jni.so",
+      "size": 42408,
+      "sha256": "0e10a928fd7180762534076d7e93e5fcebccb357c65260e4fa7de3831458f205",
+      "provenance": "Extracted from aarLibs/onnxruntime-genai.aar and stripped.",
+      "role": "JNI shim for the GenAI Java classes."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libonnxruntime4j_jni.so",
+      "size": 92136,
+      "sha256": "d2c713da7bc909e8d21eab34e9d236c63f27a67d0d60c4bf8b2b0f305e26830f",
+      "provenance": "ONNX Runtime Java JNI shim, paired with the training build above.",
+      "role": "Only needed by the ORT Java API surface."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libtokenizers_c.a",
+      "size": 26146738,
+      "sha256": "f2b59da928ecdc9046c5b3232fb1eb3d581807619fc74cfd42a669484472243d",
+      "provenance": "tokenizers-cpp built for android arm64-v8a. Upstream commit not recorded at bundling time.",
+      "role": "Static link input for libmobiletransformers.so — the on-device tokenizer."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libtokenizers_cpp.a",
+      "size": 188806,
+      "sha256": "8a31d6907c23c12d02038c946c606c3d1d2c836b2f4b97772ef6f5a437203ece",
+      "provenance": "tokenizers-cpp built for android arm64-v8a. Upstream commit not recorded at bundling time.",
+      "role": "Static link input for libmobiletransformers.so — the C++ wrapper over libtokenizers_c.a."
+    },
+    {
+      "path": "jniLibs/arm64-v8a/libprotobuf-lite.a",
+      "size": 1398194,
+      "sha256": "1458c40fbaf4ea02ca525b4dad8fa88ccd58454eca5caa6329434762b059bd8a",
+      "provenance": "protobuf-lite built for android arm64-v8a. Upstream version not recorded at bundling time.",
+      "role": "Retained as a link input; the ONNX proto reader that needed it was dropped with weight_serializer.cpp."
+    },
+    {
+      "path": "aarLibs/onnxruntime-genai.aar",
+      "size": 40046770,
+      "sha256": "c2e9b967a1ecdf766246fbee8572c6637df01183cc263f9b954c01a9ec591f69",
+      "provenance": "onnxruntime-genai Android AAR, the 0.14 line per spikes/genai_external_swap/README.md. The AAR declares no version internally, so this pairing is documented rather than read off the artifact.",
+      "role": "NOT a Gradle dependency. It is the source the two genai .so files are extracted from, and it supplies the x86_64 libraries. The shipping binaries come from jniLibs."
+    }
+  ],
+
+  "directories": [
+    {
+      "path": "cpp/includes/google",
+      "approxSize": 12582912,
+      "provenance": "protobuf sources/headers, vendored. Upstream version not recorded at bundling time.",
+      "role": "CMake include path. Verified as a set by the bundle sha256 rather than per-file — there are ~1150 files."
+    },
+    {
+      "path": "cpp/includes/protobuf",
+      "approxSize": 12582912,
+      "provenance": "protobuf sources/headers, vendored. Upstream version not recorded at bundling time.",
+      "role": "CMake include path."
+    }
+  ],
+
+  "abis": ["arm64-v8a"],
+  "_abis_comment": [
+    "arm64-v8a only, deliberately. jniLibs/x86_64 never had libonnxruntime.so or the tokenizer",
+    "archives — absent here and upstream — so libmobiletransformers.so has never existed for x86_64.",
+    "It was dropped from abiFilters rather than advertising an ABI that dies at System.loadLibrary.",
+    "Restoring it means building ORT-training and tokenizers-cpp for x86_64 first."
+  ],
+
+  "bundledOn": "2026-08-16",
+  "bundledFrom": "built from the sources and commits recorded per-artifact in `provenance` above; see third_party/onnxruntime/BUILD.md for the ONNX Runtime build"
+}
diff --git a/third_party/onnxruntime/BUILD.md b/third_party/onnxruntime/BUILD.md
new file mode 100644
index 0000000..23f7a43
--- /dev/null
+++ b/third_party/onnxruntime/BUILD.md
@@ -0,0 +1,54 @@
+# ONNX Runtime Training — build provenance
+
+This repo depends on a **source-built** `onnxruntime-training==1.23.0+cpu` Python wheel. Public PyPI
+`onnxruntime-training` stalls around 1.19.2, so the 1.23.0 training APIs this project uses
+(`onnxruntime.training.artifacts.generate_artifacts`, `onnxruntime.training.api.{CheckpointState,
+Module, Optimizer}`) are only available from a local build.
+
+The authoritative machine-readable provenance is [`manifest.json`](./manifest.json). This document is
+the human-readable companion. **Nothing here is run automatically** — the wheel already exists (see
+below); rebuild only when the ORT SHA or torch ABI must change.
+
+## Current artifact (already built)
+
+- **Wheel:** `onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl`
+  (SHA256 `87e6f3c661b0a4c6bcaa347c3abcb9ebe05943e2b44cae04701fca89bd14c65d`)
+- **Python:** 3.12.11 — the wheel is **cp312-only**; install it only under Python 3.12.
+- **Paired torch ABI:** `torch==2.7.1` (observed build `2.7.1+cu126`). A mismatched torch crashes at
+  import — keep this pin in lockstep with the `ort-training-local` group in `pyproject.toml`.
+- **ORT source:** commit `9b25b6a838d83850300afeff37bcd18723f865e3`
+  (`git describe` → `v1.19.0-1714-g9b25b6a838`), built 2025-07-08.
+- The published wheel was built from the commit above and lives in
+  `third_party/wheels/` (git-ignored), referenced via `[tool.uv.sources]`. Fetch it with
+  `TRAINING=1 scripts/fetch_native_deps.sh` rather than rebuilding.
+
+## Verify the existing wheel is alive (Python 3.12)
+
+```bash
+uv sync --python 3.12 --group ort-training-local
+uv run --python 3.12 python -c "import onnxruntime, torch; \
+  from onnxruntime.training import artifacts; \
+  from onnxruntime.training.api import CheckpointState, Module, Optimizer; \
+  print(onnxruntime.__version__, torch.__version__)"
+# expected: 1.23.0+cpu 2.7.1+...
+```
+
+## Rebuilding from source (reference — only if the pin must change)
+
+Handled by [`../../scripts/build_ort_training_wheel.sh`](../../scripts/build_ort_training_wheel.sh).
+Outline:
+
+1. `git clone https://github.com/microsoft/onnxruntime && git checkout <manifest.ort_git_sha>`.
+2. Build with `--enable_training_apis --build_wheel --config Release` under Python 3.12 in a venv
+   whose `torch` matches `manifest.torch_version`.
+3. Copy the emitted wheel into `third_party/wheels/`, recompute its SHA256, and update
+   `manifest.json` (`wheel.sha256`, `ort_git_sha`, `python_version`, `torch_version`).
+
+> A full ORT source build needs tens of GB of scratch space and many minutes. This machine's disk is
+> near-full, so the build is intentionally **not** run here — the prebuilt wheel is reused as-is.
+
+The Android training `.so`/AAR build (`build_ort_training_android.sh`) is not reproduced here —
+the shipped Android binaries were built separately and are described by
+[`third_party/android/manifest.json`](../android/manifest.json). This file's `ndk_version`, `abis`
+and `android.*` fields are therefore left null: they would otherwise claim provenance for a build
+these steps do not perform.
diff --git a/third_party/onnxruntime/manifest.json b/third_party/onnxruntime/manifest.json
new file mode 100644
index 0000000..ec32c2a
--- /dev/null
+++ b/third_party/onnxruntime/manifest.json
@@ -0,0 +1,36 @@
+{
+  "schemaVersion": "1.0",
+  "minReaderVersion": "1.0",
+  "ort_git_sha": "9b25b6a838d83850300afeff37bcd18723f865e3",
+  "ort_git_describe": "v1.19.0-1714-g9b25b6a838",
+  "ort_tag": "v1.23.0",
+  "version": "1.23.0+cpu",
+  "build_flags": ["--enable_training_apis", "--build_wheel", "--config", "Release"],
+  "python_version": "3.12.11",
+  "torch_version": "2.7.1",
+  "torch_build_observed": "2.7.1+cu126",
+  "cmake_version": "3.28.1",
+  "ndk_version": null,
+  "android_api_level": null,
+  "abis": [],
+  "built_on": "2025-07-08",
+  "notes": "Wheel source-built against Python 3.12.11; see BUILD.md for the commit and steps. Verified alive: `import onnxruntime; from onnxruntime.training import artifacts; from onnxruntime.training.api import CheckpointState, Module, Optimizer`, then generate_artifacts on tests/fixtures/tiny_trainable.onnx produced training/eval/optimizer models + checkpoint and a one-step train yielded a finite loss -> ORT 1.23.0+cpu | torch 2.7.1. cp312-only wheel; sync the ort-training-local group under Python 3.12. RUNTIME ABI CONSTRAINTS (pinned in the ort-training-local group): numpy<2 (the C-extension is built against the numpy 1.26 ABI; numpy 2.x -> 'import numpy failed'); onnx<1.19 (ORT 1.23 runtime supports max ONNX IR version 11, onnx>=1.19 emits IR 13). Android (NDK/ABI/AAR) fields are unpopulated -- the shipped Android binaries were built separately and are described by third_party/android/manifest.json, so claiming provenance for them here would be false.",
+  "wheel": {
+    "filename": "onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl",
+    "python_tag": "cp312",
+    "platform_tag": "linux_x86_64",
+    "sha256": "87e6f3c661b0a4c6bcaa347c3abcb9ebe05943e2b44cae04701fca89bd14c65d"
+  },
+  "paired_stack": {
+    "onnx": "1.18.0",
+    "optimum": "1.23.3",
+    "onnxscript": "0.3.1",
+    "peft": "0.13.2",
+    "transformers": "4.46.2",
+    "numpy": "1.26.4"
+  },
+  "android": {
+    "aar_sha256": null,
+    "so_sha256": {}
+  }
+}
diff --git a/third_party/wheels/README.md b/third_party/wheels/README.md
new file mode 100644
index 0000000..5c7d998
--- /dev/null
+++ b/third_party/wheels/README.md
@@ -0,0 +1,20 @@
+# third_party/wheels/
+
+Holds local, **git-ignored** Python wheels that are not available on public PyPI — currently the
+source-built ONNX Runtime Training wheel.
+
+- `onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl` — referenced by
+  `[tool.uv.sources] onnxruntime-training` in the root `pyproject.toml`. Provenance and SHA256 live in
+  [`../onnxruntime/manifest.json`](../onnxruntime/manifest.json); build steps in
+  [`../onnxruntime/BUILD.md`](../onnxruntime/BUILD.md).
+
+`*.whl` here is ignored by git (see root `.gitignore`). To obtain the wheel:
+
+- **Fetch the published build** (what you almost certainly want) —
+  `TRAINING=1 scripts/fetch_native_deps.sh`. It downloads the wheel and verifies its sha256 against
+  [`../onnxruntime/manifest.json`](../onnxruntime/manifest.json) before installing it here.
+- **Rebuild from source:** run `scripts/build_ort_training_wheel.sh` (see `BUILD.md`). Hours, and
+  only necessary if you are changing ONNX Runtime itself.
+
+The `ort-training-local` uv group is **cp312-only** — sync it under Python 3.12:
+`uv sync --python 3.12 --group ort-training-local`.
diff --git a/tools/parser_config.py b/tools/parser_config.py
deleted file mode 100644
index 73722ce..0000000
--- a/tools/parser_config.py
+++ /dev/null
@@ -1,23 +0,0 @@
-"""
-File that stores all the section names of the config.yml file.
-"""
-
-ARTIFACT_CONFIG = "ARTIFACT_BUILDER"
-ARTIFACT_VALIDATOR_CONFIG = "ARTIFACT_VALIDATOR"
-TRAIN_CONFIG = "TRAIN_BUILDER"
-INFERENCE_CONFIG = "INFERENCE_BUILDER"
-INFERENCE_ARTIFACT_CONFIG = "inference_config"
-TEST_GENERATION_CONFIG = "test_generation_config"
-
-# Boolq: google/boolq
-# HellaSWAG: Rowan/hellaswag
-# ARC: allenai/ai2_arc
-# LogiQA: data/logiqa_train
-
-# If "data" is prefix, the data is loaded from local "data/"" directory
-TASK_NAME_TO_DATASET = {
-    "logiqa": "data/logiqa_train",
-    "hellaswag": "Rowan/hellaswag",
-    "arc": "allenai/ai2_arc",
-    "boolq": "google/boolq"
-}
\ No newline at end of file
diff --git a/tools/tokenizer_export.py b/tools/tokenizer_export.py
deleted file mode 100644
index f509fbc..0000000
--- a/tools/tokenizer_export.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import json
-from pathlib import Path
-from transformers import AutoTokenizer, AutoConfig, GenerationConfig
-
-def export_tokenizer_config(model_name_or_path, output_dir="build", hf_token=None, trust_remote_code=True):
-    """
-    Export tokenizer and config files from HuggingFace model.
-    
-    Args:
-        model_name_or_path (str): HuggingFace model name or local path
-        output_dir (str): Output directory (default: "build")
-        hf_token (str): HuggingFace token for private models
-        trust_remote_code (bool): Whether to trust remote code
-    
-    Returns:
-        dict: The generated config dictionary
-    """
-    
-    # Create output directories
-    tokenizer_dir = Path(output_dir) / "tokenizer"
-    tokenizer_dir.mkdir(parents=True, exist_ok=True)
-    
-    try:
-        # Load tokenizer and config
-        print(f"Loading tokenizer from {model_name_or_path}...")
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name_or_path, 
-            token=hf_token, 
-            trust_remote_code=trust_remote_code
-        )
-        
-        try:
-            config = GenerationConfig.from_pretrained(model_name_or_path, token=hf_token, trust_remote_code=True)
-        except:
-            config = AutoConfig.from_pretrained(model_name_or_path, token=hf_token, trust_remote_code=True)
-        
-        # Save tokenizer files to build/tokenizer directory
-        print(f"Saving tokenizer files to {tokenizer_dir}...")
-        tokenizer.save_pretrained(tokenizer_dir)
-        
-        # Get model type
-        model_type = config.model_type if hasattr(config, 'model_type') else 'unknown'
-
-        # Create the config structure
-        ortmobile_config = {
-            "model": {
-                "bos_token_id": getattr(config, 'bos_token_id', tokenizer.bos_token_id or 1),
-                "context_length": getattr(config, 'max_position_embeddings', 
-                                        getattr(config, 'max_sequence_length', 2048)),
-                "num_attention_heads": getattr(config, 'num_attention_heads', 12),
-                "num_hidden_layers": getattr(config, 'num_hidden_layers', 12),
-                "num_key_value_heads": getattr(config, 'num_key_value_heads', 
-                                             getattr(config, 'num_attention_heads', 12)),
-                "eos_token_id": config.eos_token_id,
-                "pad_token_id": config.pad_token_id if hasattr(config, "pad_token_id") and config.pad_token_id is not None else config.eos_token_id[0] if isinstance(config.eos_token_id, list) else config.eos_token_id,
-                "type": model_type,
-                "vocab_size": getattr(config, 'vocab_size', len(tokenizer.get_vocab()))
-            }
-        }
-        
-        # Save the main config file
-        config_path = Path(output_dir) / "tokenizer" / "ortmobile_tokenizer_config.json"
-        print(f"Saving main config to {config_path}...")
-        with open(config_path, 'w', encoding='utf-8') as f:
-            json.dump(ortmobile_config, f, indent=4, ensure_ascii=False)
-        
-        print("Export completed successfully!")
-        print(f"Files saved:")
-        print(f"  - Main config: {config_path}")
-        print(f"  - Tokenizer files: {tokenizer_dir}")
-        
-        # List tokenizer files that were saved
-        tokenizer_files = list(tokenizer_dir.glob("*.json"))
-        for file in tokenizer_files:
-            print(f"    - {file.name}")
-        
-        return ortmobile_config
-        
-    except Exception as e:
-        print(f"Error exporting tokenizer: {str(e)}")
-        raise
-
-def export_tokenizer_config_advanced(model_name_or_path, output_dir="build", hf_token=None, 
-                                   trust_remote_code=True, extra_config_overrides=None):
-    """
-    Advanced version with additional configuration options.
-    
-    Args:
-        model_name_or_path (str): HuggingFace model name or local path
-        output_dir (str): Output directory
-        hf_token (str): HuggingFace token
-        trust_remote_code (bool): Whether to trust remote code
-        extra_config_overrides (dict): Additional config values to override
-    
-    Returns:
-        dict: The generated config dictionary
-    """
-    
-    config = export_tokenizer_config(model_name_or_path, output_dir, hf_token, trust_remote_code)
-    
-    # Apply any overrides
-    if extra_config_overrides:
-        for key, value in extra_config_overrides.items():
-            if key in config["model"]:
-                config["model"][key] = value
-                print(f"Override applied: {key} = {value}")
-        
-        # Save updated config
-        config_path = Path(output_dir) / "ortmobile_tokenizer_config.json"
-        with open(config_path, 'w', encoding='utf-8') as f:
-            json.dump(config, f, indent=4, ensure_ascii=False)
-    
-    return config
\ No newline at end of file
diff --git a/tools/utils.py b/tools/utils.py
deleted file mode 100644
index b3b933a..0000000
--- a/tools/utils.py
+++ /dev/null
@@ -1,294 +0,0 @@
-"""
-Utility functions for the framework.
-"""
-
-import json
-import os
-import shutil
-from jinja2 import Template
-import psutil
-import torch
-from transformers import TrainerCallback
-from transformers.trainer_callback import TrainerControl, TrainerState
-from transformers.training_args import TrainingArguments
-from datasets import load_dataset, Dataset, DatasetDict
-
-def load_and_save_dataset(dataset_name, save_path=None, train_file="train_dataset", split=None, save_format="jsonl", max_dataset_length=None):
-    """
-    Load a dataset from Hugging Face Hub and save it locally.
-    
-    Args:
-        dataset_name (str): Name of the dataset on Hugging Face Hub
-        save_path (str, optional): Local path to save the dataset. 
-                                 If None, saves to './datasets/{dataset_name}'
-        config_name (str, optional): Configuration name for datasets with multiple configs
-        split (str, optional): Specific split to load ('train', 'test', 'validation', etc.)
-        **kwargs: Additional arguments to pass to load_dataset()
-    
-    Returns:
-        datasets.Dataset or datasets.DatasetDict: The loaded dataset
-    """
-    try:
-        # Load the dataset
-        dataset = preload_dataset(dataset_name, split)
-
-        if type(dataset) == DatasetDict:
-            dataset = dataset[split]
-        
-        # Set default save path if not provided
-        if save_path is None:
-            save_path = f"./datasets/{dataset_name.replace('/', '_')}"
-        
-        # Trim dataset if max_dataset_length is specified
-        if max_dataset_length is not None:
-            dataset = trim_dataset(dataset, max_dataset_length)
-
-        # Save the dataset based on format
-        if save_format.lower() == "jsonl":
-            save_as_jsonl(dataset, save_path, train_file)
-        else:
-            # Default HuggingFace format
-            print(f"Saving dataset to: {save_path}")
-            dataset.save_to_disk(save_path)
-            print(f"Dataset successfully saved to {save_path}")
-        return dataset
-        
-    except Exception as e:
-        print(f"Error loading or saving dataset: {str(e)}")
-        return None
-
-def trim_dataset(dataset, max_length):
-    """
-    Trim dataset to maximum number of examples.
-    
-    Args:
-        dataset: Dataset or DatasetDict to trim
-        max_length (int): Maximum number of examples to keep
-    
-    Returns:
-        Trimmed dataset
-    """
-    from datasets import DatasetDict, Dataset
-    
-    if isinstance(dataset, DatasetDict):
-        # Handle DatasetDict (multiple splits)
-        trimmed_dict = {}
-        for split_name, split_dataset in dataset.items():
-            original_length = len(split_dataset)
-            if original_length > max_length:
-                trimmed_dict[split_name] = split_dataset.select(range(max_length))
-                print(f"Trimmed {split_name} split from {original_length} to {max_length} examples")
-            else:
-                trimmed_dict[split_name] = split_dataset
-                print(f"Kept {split_name} split unchanged ({original_length} examples)")
-        return DatasetDict(trimmed_dict)
-    
-    elif isinstance(dataset, Dataset):
-        # Handle single Dataset
-        original_length = len(dataset)
-        if original_length > max_length:
-            trimmed_dataset = dataset.select(range(max_length))
-            print(f"Trimmed dataset from {original_length} to {max_length} examples")
-            return trimmed_dataset
-        else:
-            print(f"Dataset unchanged ({original_length} examples)")
-            return dataset
-    
-    return dataset
-
-def save_as_jsonl(dataset, save_path, dataset_name):
-    """
-    Save dataset as JSONL (JSON Lines) format.
-    
-    Args:
-        dataset: The dataset to save
-        save_path (str): Directory path to save the files
-        dataset_name (str): Name of the dataset for file naming
-    """
-    
-    if isinstance(dataset, DatasetDict):
-        # Handle DatasetDict (multiple splits)
-        for split_name, split_dataset in dataset.items():
-
-            print(f"Saving {split_name} split to: {save_path}_{split_name}.jsonl")
-            
-            with open(f"{save_path}_{split_name}.jsonl", 'w', encoding='utf-8') as f:
-                for example in split_dataset:
-                    f.write(json.dumps(example, ensure_ascii=False) + '\n')
-    
-    elif isinstance(dataset, Dataset):
-        # Handle single Dataset
-        file_path = os.path.join(save_path, f"{dataset_name}.jsonl")
-        
-        print(f"Saving dataset to: {file_path}")
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            for example in dataset:
-                f.write(json.dumps(example, ensure_ascii=False) + '\n')
-    
-    print(f"Dataset successfully saved as JSONL format to {save_path}")
-
-def preload_dataset(dataset_id, dataset_name=None, split=None):
-
-    dataset_ids = dataset_id.split("/")
-    
-    # Take local data
-    if len(dataset_ids) >= 2 and dataset_ids[-2] == "data":
-
-        filepath = dataset_id
-        data = None
-
-        if os.path.exists(f'./{dataset_id}.json'):
-            filepath = f'./{dataset_id}.json'
-
-            with open(filepath, 'r', encoding="utf-8") as f:
-                data = json.load(f)
-
-        elif os.path.exists(f'./{dataset_id}.jsonl'):
-            filepath = f'./{dataset_id}.jsonl'
-
-            with open(filepath, "r", encoding="utf-8") as f:
-                data = [json.loads(line) for line in f]
-
-        # Convert to Hugging Face Dataset
-        dataset = Dataset.from_list(data)
-        empty_test = dataset.select([])
-
-        # Create a DatasetDict with the "train" split
-        dataset_dict = DatasetDict({'train': dataset, 'test': empty_test})
-
-        return dataset_dict
-    ds = load_dataset(dataset_id, dataset_name, split=split)
-
-    empty_test = ds["train"].select([])
-
-    ds['test'] = empty_test
-    return ds
-
-def create_chat_input(query_prompt, config, add_generation_prompt=True):
-    
-    # Extract key parts of the config
-    chat_template = config["chat_template"]
-    eos_token = config["eos_token"]
-    
-    # Construct messages for template rendering
-    # Simulating a simple conversation setup here with roles: system, user, assistant
-    messages = [
-        {"role": "user", "content": query_prompt}
-    ]
-
-    # Define a rendering context for the chat template
-    rendering_context = {
-        "messages": messages,
-        "add_generation_prompt": add_generation_prompt,
-        "eos_token": eos_token
-    }
-
-    # Render the chat template using the rendering context
-    chat_input = render_template(chat_template, rendering_context)
-    return chat_input
-
-def render_template(template_str, context):
-    """Render the chat template string with Jinja-style template logic"""
-    
-    template = Template(template_str)
-    return template.render(context)
-
-def move_onnx_model(model_path, destination_dir, delete=False):
-    """
-    Move or copy ONNX model and its data file to a new destination directory.
-    
-    Args:
-        model_path (str): Path to the .onnx model file
-        destination_dir (str): Destination directory path
-        delete (bool): If True, move files (delete from source). If False, copy files.
-    
-    Returns:
-        str: Path to the .onnx file in the new location
-    """
-    # Create destination directory if it doesn't exist
-    os.makedirs(destination_dir, exist_ok=True)
-    
-    # Get the model filename
-    model_filename = os.path.basename(model_path)
-    destination_model_path = os.path.join(destination_dir, model_filename)
-    
-    # Move or copy the .onnx file
-    if os.path.exists(model_path):
-        if delete:
-            shutil.move(model_path, destination_model_path)
-            print(f"✓ Moved {model_filename} to {destination_dir}")
-        else:
-            shutil.copy2(model_path, destination_model_path)
-            print(f"✓ Copied {model_filename} to {destination_dir}")
-    else:
-        raise FileNotFoundError(f"Model file not found: {model_path}")
-    
-    # Check for and move/copy .onnx.data file
-    data_path = model_path + ".data"
-    if os.path.exists(data_path):
-        data_filename = os.path.basename(data_path)
-        destination_data_path = os.path.join(destination_dir, data_filename)
-        if delete:
-            shutil.move(data_path, destination_data_path)
-            print(f"✓ Moved {data_filename} to {destination_dir}")
-        else:
-            shutil.copy2(data_path, destination_data_path)
-            print(f"✓ Copied {data_filename} to {destination_dir}")
-    
-    return destination_model_path
-
-def move_files_excluding(source_dir, target_dir, exclude_files):
-    os.makedirs(target_dir, exist_ok=True)
-
-    for filename in os.listdir(source_dir):
-        source_file = os.path.join(source_dir, filename)
-        target_file = os.path.join(target_dir, filename)
-
-        if os.path.isfile(source_file) and not any(ef in filename for ef in exclude_files):
-            shutil.move(source_file, target_file)
-
-def delete_directory(directory_path):
-    if os.path.exists(directory_path) and os.path.isdir(directory_path):
-        try:
-            shutil.rmtree(directory_path)
-        except Exception as e:
-            print(f"Error: {e}")
-    else:
-        print(f"Directory '{directory_path}' does not exist.")
-
-class MemoryLoggerCallback(TrainerCallback):
-    def __init__(self):
-        super().__init__()
-        self.pre_backward_memory = {}
-
-    def on_log(self, args, state, control, logs=None, **kwargs):
-        if torch.cuda.is_available():
-            # Log GPU memory usage
-            allocated = torch.cuda.memory_allocated() / 1024**2  # Convert to MB
-            reserved = torch.cuda.memory_reserved() / 1024**2  # Convert to MB
-            logs["gpu_memory_allocated_MB"] = allocated
-            logs["gpu_memory_reserved_MB"] = reserved
-
-            # Log memory usage before backward pass
-            if self.pre_backward_memory:
-                logs["gpu_memory_allocated_MB_pre_bp"] = self.pre_backward_memory["gpu_memory_allocated_MB_pre_bp"]
-        else:
-            # Log CPU memory usage using psutil
-            mem = psutil.virtual_memory()
-            logs["cpu_memory_used_MB"] = mem.used / 1024**2  # Convert to MB
-            # Log memory usage before backward pass
-            if self.pre_backward_memory:
-                logs["cpu_memory_used_MB_pre_bp"] = self.pre_backward_memory["cpu_memory_used_MB_pre_bp"]
-    
-    def on_optimizer_step(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
-        if torch.cuda.is_available():
-            # Log GPU memory usage
-            allocated = torch.cuda.memory_allocated() / 1024**2  # Convert to MB
-            #reserved = torch.cuda.memory_reserved() / 1024**2  # Convert to MB
-            self.pre_backward_memory["gpu_memory_allocated_MB_pre_bp"] = allocated
-            #self.pre_backward_memory["gpu_memory_reserved_MB_pre_bs"] = reserved
-        else:
-            # Log CPU memory usage using psutil
-            mem = psutil.virtual_memory()
-            self.pre_backward_memory["cpu_memory_used_MB_pre_bp"] = mem.used / 1024**2  # Convert to MB
\ No newline at end of file
diff --git a/trainer/builder.py b/trainer/builder.py
deleted file mode 100644
index ec48c1b..0000000
--- a/trainer/builder.py
+++ /dev/null
@@ -1,661 +0,0 @@
-"""
-Script that fetches the Huggingface LLM model and converts it into a ONNX graph compatible for artifact training generation.
-"""
-
-import argparse, yaml
-import json, gc, os
-import textwrap
-from typing import Dict, List
-import torch
-from pathlib import Path
-import onnx
-import numpy as np
-from onnx import helper, TensorProto, numpy_helper
-from optimum.exporters.onnx import OnnxConfigWithLoss, export
-from optimum.exporters.onnx.model_configs import LlamaOnnxConfig, GemmaOnnxConfig, Phi3OnnxConfig, BertOnnxConfig, Qwen2OnnxConfig, OPTOnnxConfig
-
-from transformers import AutoModelForCausalLM, AutoConfig, AutoModel
-from peft import PeftModel, LoraConfig, get_peft_model
-from peft.peft_model import PEFT_TYPE_TO_MODEL_MAPPING
-from peft import PeftType
-from peft_models.mars.config import MarsConfig
-from peft_models.mars.model import MarsModel
-
-from trainer.utils import create_mars_adapter_mapping, create_lora_mapping
-from trainer.embedding_builder import add_pooling_to_onnx_model
-
-def add_peft_type(name, value):
-    """Dynamically add a new value to the PeftType enum."""
-    setattr(PeftType, name, value)
-    PeftType._value2member_map_[value] = name
-
-# Add custom PEFT type dynamically
-add_peft_type("MARS", "MARS")
-PEFT_TYPE_TO_MODEL_MAPPING[PeftType("MARS")] = MarsModel
-
-from onnxruntime.quantization import quantize_dynamic, QuantType
-
-from peft_models.lora_xs.initialization_utils import find_and_initialize
-
-# All operators supported for training should be in https://onnx.ai/onnx/operators/index.html
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-from tools.parser_config import TRAIN_CONFIG
-
-def get_layers_with_grad(model):
-    """
-    Collects layers with required grad and frozen parameter layers.
-    """
-    layers_with_grad = []
-    layers_with_no_grad = []
-    for name, param in model.named_parameters():
-
-        if param.requires_grad:
-            layers_with_grad.append(name)
-        else:
-            layers_with_no_grad.append(name)
-    return layers_with_grad, layers_with_no_grad
-
-def ensure_training_mode_input(graph):
-    """
-    Add training mode boolean input to the graph for conditional flow.
-    """
-
-    training_mode_exists = any(input.name == "training_mode" for input in graph.input)
-    if not training_mode_exists:
-        # Add 'training_mode' input to the graph as a boolean tensor
-        training_mode_input = helper.make_tensor_value_info("training_mode", TensorProto.BOOL, [1])
-        graph.input.append(training_mode_input)
-
-class OnnxInferenceWrapper(torch.nn.Module):
-    def __init__(self, model) -> None:
-        super().__init__()
-        self.backbone = model
-        self.config = model.config
-        self.training = False
-        self.backbone.use_cache=True
-    
-    def forward(self, input_ids, attention_mask, position_ids, past_key_values):
-        return self.backbone(input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, past_key_values=past_key_values, use_cache=True)
-
-class OnnxTrainerWrapper(torch.nn.Module):
-    def __init__(self, model) -> None:
-        super().__init__()
-        self.backbone = model
-        self.config = model.config
-        self.training = True
-    
-    def forward(self, input_ids, attention_mask, position_ids, labels):
-        return self.backbone(input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, labels=labels)
-
-def compare_weights(model_path1, model_path2):
-    """
-    Compares weights of two models based on their initializers.
-    """
-
-    onnx_model   = onnx.load(model_path1)
-    INTIALIZERS  = onnx_model.graph.initializer
-    onnx_weights_1 = {}
-
-    for initializer in INTIALIZERS:
-        W = numpy_helper.to_array(initializer)
-        onnx_weights_1[initializer.name] = W
-
-    del onnx_model
-    onnx_model   = onnx.load(model_path2)
-    INTIALIZERS  = onnx_model.graph.initializer
-    onnx_weights_2 = {}
-
-    for initializer in INTIALIZERS:
-        W = numpy_helper.to_array(initializer)
-        onnx_weights_2[initializer.name] = W
-
-        if initializer.name not in onnx_weights_1 or initializer.name not in onnx_weights_2:
-            print(f"MISMATCH IN INITIALIZERS - missing {initializer.name}")
-            continue
-
-        are_equal = np.array_equal(onnx_weights_1[initializer.name], onnx_weights_2[initializer.name])
-
-        if not are_equal:
-            #print(are_equal)
-            print("Not equal")
-            print(initializer.name)
-            #print(onnx_weights_1[initializer.name])
-            #print(onnx_weights_2[initializer.name])
-            #print(onnx_weights_1[initializer.name].shape)
-            #print(onnx_weights_2[initializer.name].shape)
-    
-    onnx.save(onnx_model, "model.onnx", location="model.onnx_data", save_as_external_data=True)
-
-
-def trim_initializers(model_path1):
-    """
-    Removes all the layers of initializers that start with:
-    - ONNX basic nodes with "/"
-    - ONNX nodes with "onnx::"
-    """
-
-    onnx_model   = onnx.load(model_path1)
-    INTIALIZERS  = onnx_model.graph.initializer
-    onnx_weights_1 = {}
-
-    for initializer in INTIALIZERS:
-        W = numpy_helper.to_array(initializer)
-        
-        onnx_weights_1[initializer.name] = W
-
-        if initializer.name.startswith("/") or initializer.name.startswith("onnx::"):
-            print("Removed:")
-            print(initializer.name)
-            onnx_model.graph.initializer.remove(initializer)
-        else:
-            print("Not removed:")
-            print(initializer.name)
-    
-    onnx.save(onnx_model, "model.onnx", location="model.onnx_data", save_as_external_data=True)
-
-def inspect_weights(model_path, only_trainable=False):
-    """
-    Inspects the weights of the model provided.
-    """
-
-    onnx_model   = onnx.load(model_path)
-    INTIALIZERS  = onnx_model.graph.initializer
-
-    for param in INTIALIZERS:
-        print(f"Layer name: {param.name}")
-
-def apply_metadata(model_path, model_id):
-    """
-    Load ONNX model, apply metadata to both model and graph, and resave it (replacing original files).
-    
-    Args:
-        model_path (Path): Path to the .onnx model file
-        model_id (str): Model ID to add as metadata
-    
-    Returns:
-        Path: Path to the updated model file
-    """
-    # Load the model
-    model = onnx.load(str(model_path))
-    
-    # Remove existing model_id metadata from model if it exists
-    to_remove = []
-    for i, prop in enumerate(model.metadata_props):
-        if prop.key == "model_id":
-            to_remove.append(i)
-    
-    # Remove in reverse order to maintain indices
-    for i in reversed(to_remove):
-        del model.metadata_props[i]
-    
-    # Add metadata to model level
-    model_metadata_entry = onnx.StringStringEntryProto()
-    model_metadata_entry.key = "model_id"
-    model_metadata_entry.value = str(model_id)
-    model.metadata_props.append(model_metadata_entry)
-    
-    # Remove existing model_id metadata from graph if it exists
-    graph_to_remove = []
-    for i, prop in enumerate(model.graph.metadata_props):
-        if prop.key == "model_id":
-            graph_to_remove.append(i)
-    
-    # Remove in reverse order to maintain indices
-    for i in reversed(graph_to_remove):
-        del model.graph.metadata_props[i]
-    
-    # Add metadata to graph level
-    graph_metadata_entry = onnx.StringStringEntryProto()
-    graph_metadata_entry.key = "model_id"
-    graph_metadata_entry.value = str(model_id)
-    model.graph.metadata_props.append(graph_metadata_entry)
-
-    return model
-
-def preprocess_model(model : torch.nn.Module, epsilon_high=1e-8, epsilon_low=1e-10):
-    """
-    Add a really small epsilon to the model parameters if they are all zeroes.
-    This is to prevent the ONNX from not saving the extra weights, as they need to be included as initializers. 
-    """
-    for _, param in model.named_parameters():
-        if torch.all(param.data == 0):
-            random_values = torch.rand_like(param.data)
-            random_values = (epsilon_high - epsilon_low) * random_values + epsilon_low
-            param.data += random_values
-    
-    return model
-
-def optimum_hf_export(model_id,
-                      model_output="onnx_models",
-                      training_mode = False,
-                      train_method = "lora",
-                      lora_target=["q_proj", "k_proj"],
-                      lora_rank=4,
-                      lora_alpha=4,
-                      quantize=True,
-                      weight_type=QuantType.QInt8,
-                      peft_config={},
-                      specific_peft_config={},
-                      postprocess=False,
-                      exclude_extra_layers = ["embed_head"],
-                      exclude_specific=False,
-                      exclude_specific_layers=[],
-                      opset=20,
-                      task_type="text-generation",
-                      add_pooling=False):
-    """
-    Exports the model from Huggingface to an ONNX model representation.
-    """
-
-    if task_type == "text-generation":
-        model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, token=os.environ["HF_TOKEN"])
-    else:
-        model = AutoModel.from_pretrained(model_id, trust_remote_code=True, token=os.environ["HF_TOKEN"])
-    config = AutoConfig.from_pretrained(model_id, token=os.environ["HF_TOKEN"])
-
-    # TODO: Add support for other architectures
-    if config.architectures[0] == "LlamaForCausalLM":
-        ocl = LlamaOnnxConfig(config, task=task_type, use_past=not training_mode, use_past_in_inputs=not training_mode)
-    elif config.architectures[0] == "GemmaForCausalLM" or config.architectures[0] == "Gemma2ForCausalLM" or config.architectures[0] == "Gemma3ForCausalLM":
-        ocl = GemmaOnnxConfig(config, task=task_type, use_past=not training_mode, use_past_in_inputs=not training_mode)
-    elif config.architectures[0] == "Phi3ForCausalLM":
-        ocl = Phi3OnnxConfig(config, task=task_type, use_past=not training_mode, use_past_in_inputs=not training_mode)
-    elif config.architectures[0] == "Qwen2ForCausalLM":
-        ocl = Qwen2OnnxConfig(config, task=task_type, use_past=not training_mode, use_past_in_inputs=not training_mode)
-    elif config.architectures[0] == "OPTForCausalLM":
-        ocl = OPTOnnxConfig(config, task=task_type, use_past=not training_mode, use_past_in_inputs=not training_mode)
-    elif config.architectures[0] == "BertModel":
-        ocl = BertOnnxConfig(config, task=task_type)
-
-    lora_config = None
-    lora_model = None
-
-    if training_mode:
-        ocl = OnnxConfigWithLoss(ocl)
-
-    onnx_path = Path(f"{model_output}/model.onnx")
-
-    if training_mode and train_method == "lora":
-        # Apply LoRA to the model
-        lora_config = LoraConfig(
-            r=lora_rank,
-            target_modules=lora_target,
-            task_type="CAUSAL_LM",
-            **peft_config
-        )
-        lora_model = PeftModel(model, lora_config, adapter_name="lora")
-    elif training_mode and train_method == "lora-xs":
-        # TODO: Add specific PEFT config
-        lora_config = LoraConfig(
-            r=lora_rank,
-            target_modules=lora_target,
-            task_type="CAUSAL_LM",
-            **peft_config
-        )
-        lora_model = get_peft_model(model, lora_config)
-        adapter_name = "default"
-        peft_config_dict = {}
-        reconstruct_dict = {
-            'reconstruction_type': "svd",
-            'reconstr_mode': "separated",
-            'half_init_dec': False,
-            'replacement_module_random_init': False,
-            'r_squared': True,
-            'svd': {
-                'rank': lora_rank,
-                'n_iter': 10,
-                'random_state': 42
-            }
-        }
-        peft_config_dict[adapter_name] = lora_config
-        find_and_initialize(model, peft_config_dict, adapter_name, "svd", reconstruct_dict, None)
-    elif training_mode and train_method == "mars":
-        mars_config = MarsConfig(
-            peft_type="MARS",
-            r=lora_rank,
-            alpha=lora_alpha,
-            onnx_export=True, # always needs to be True for export
-            target_modules=lora_target,  # Target specific model layers
-            task_type=None,
-            **specific_peft_config
-        )
-
-        lora_model = get_peft_model(model, mars_config, adapter_name="mars")
-    elif training_mode and train_method == "all":
-        # Make only linear layers trainable
-        for name, module in model.named_modules():
-            if isinstance(module, (torch.nn.Linear)):
-                for param in module.parameters():
-                    param.requires_grad = True
-            else:
-                for param in module.parameters():
-                    param.requires_grad = False
-        lora_model = model
-    elif not training_mode or train_method == "nolora":
-        lora_model = model
-
-    mapping = {}
-    if training_mode:
-        if train_method == "mars":
-            mapping = create_mars_adapter_mapping(lora_model, mars_config.enabled_qkv, mars_config.enabled_mlp)
-        elif train_method == "lora":
-            mapping = create_lora_mapping(lora_model)
-
-    if training_mode:
-        if train_method != "all":
-            my_model = OnnxTrainerWrapper(lora_model.base_model.model)
-        else:
-            my_model = OnnxTrainerWrapper(lora_model)
-        my_model.train()
-    elif task_type == "text-generation":
-        my_model = OnnxInferenceWrapper(lora_model)
-        my_model.eval()
-    else:
-        # Infer from the model
-        my_model = lora_model
-        my_model.eval()
-
-    # Preprocessing methods
-    if training_mode:
-        my_model = preprocess_model(my_model)
-    
-    # Trainable count
-    trainable_count = count_trainable_parameters(my_model)
-
-    export(my_model, ocl, onnx_path, opset, do_constant_folding=not training_mode)
-
-    # Apply some metadata to model
-    onnx_model = apply_metadata(onnx_path, model_id)
-
-    # Add pooling operations to the embedding model and save
-    if task_type == "feature-extraction" and add_pooling:
-        add_pooling_to_onnx_model(onnx_model, model_id, f"{model_output}/embedding_model.onnx")
-
-    # Save gradient layer names
-    if training_mode:
-        # Get layers with gradients in the LoRA model
-        grad_layers, no_grad_layers = get_layers_with_grad(my_model)
-        with open(f"{model_output}/training_config.json", "w+", encoding="utf-8") as f:
-            json.dump({
-                "requires_grad": grad_layers,
-                "frozen_params": no_grad_layers,
-                "peft_mapping": mapping,
-                "trainable_parameter_count": trainable_count,
-                "rank": lora_rank,
-                "alpha": lora_alpha,
-                "peft_target": lora_target
-            }, f, ensure_ascii=False)
-    
-    del my_model
-    my_model = None
-    gc.collect()
-
-    # Apply dynamic quantization to non-trainable layers
-    if quantize:
-        lora_target = [] if not training_mode else lora_target
-        onnx_dynamic_quantization(onnx_model,
-                                  onnx_path.absolute().as_posix(),
-                                  f"{model_output}/quant_model.onnx",
-                                  #exclude_weights=lora_target,
-                                  weight_type=weight_type,
-                                  exclude_extra_layers=exclude_extra_layers,
-                                  exclude_specific=exclude_specific,
-                                  exclude_specific_layers=exclude_specific_layers)
-        
-        # Add pooling operations to the quantized embedding model and save
-        if task_type == "feature-extraction" and add_pooling:
-            add_pooling_to_onnx_model(f"{model_output}/quant_model.onnx", model_id, f"{model_output}/embedding_quant_model.onnx")
-
-def onnx_dynamic_quantization(onnx_model,
-                              onnx_model_path,
-                              onnx_model_quant_output,
-                              weight_type=QuantType.QInt16,
-                              exclude_weights=[],
-                              exclude_extra_layers=[],
-                              exclude_specific=False,
-                              exclude_specific_layers=[]):
-
-    nodes_to_not_quantize = []
-
-    # Exclude trainable nodes
-    for param in onnx_model.graph.node:
-
-        if not exclude_specific:
-            if any((allowed_layer in param.name) for allowed_layer in exclude_weights):
-                nodes_to_not_quantize.append(param.name)
-        else:
-            if any((allowed_layer in param.name) for allowed_layer in exclude_specific_layers):
-                nodes_to_not_quantize.append(param.name)
-
-        if any(allowed_layer in param.name for allowed_layer in exclude_extra_layers):
-            nodes_to_not_quantize.append(param.name)
-        for input_weight in param.input:
-            if any(allowed_layer in input_weight for allowed_layer in exclude_extra_layers):
-                nodes_to_not_quantize.append(param.name)
-                break
-
-    # Does not work
-    #quant_pre_process(onnx_model_path, f"pre_{onnx_model_quant_output}", save_as_external_data=True, all_tensors_to_one_file=True, external_data_location=f"pre_{onnx_model_quant_output}")
-
-    del onnx_model
-    gc.collect()
-
-    quantize_dynamic(
-        extra_options={
-                'ActivationSymmetric': False,         # True for inference speed. False may keep more accuracy.
-                'WeightSymmetric': False,                 # True for inference speed. False may keep more accuracy.
-                'EnableSubgraph': False,                   # True for more quant.
-                'ForceQuantizeNoInputCheck': True,       # True for more quant.
-                'MatMulConstBOnly': True                 # False for more quant. Sometime, the inference speed may get worse. Keep this True in case of training graph.
-        },
-        nodes_to_exclude=nodes_to_not_quantize,
-        model_input=onnx_model_path,
-        model_output=onnx_model_quant_output,
-        per_channel=True,
-        use_external_data_format=True,
-        weight_type=weight_type,
-        reduce_range=False
-    )
-
-def count_trainable_parameters(model) -> int:
-    """Count trainable parameters."""
-    return sum(p.numel() for p in model.parameters() if p.requires_grad)
-
-def check_extra_options(kv_pairs):
-    if "exclude_extra_layers" in kv_pairs:
-        op_types_to_quantize = ()
-        for op_type in kv_pairs["exclude_extra_layers"].split("/"):
-            op_types_to_quantize += (op_type, )
-        kv_pairs["exclude_extra_layers"] = op_types_to_quantize
-    if "exclude_specific_layers" in kv_pairs:
-        op_types_to_quantize = ()
-        for op_type in kv_pairs["exclude_specific_layers"].split("/"):
-            op_types_to_quantize += (op_type, )
-        kv_pairs["exclude_specific_layers"] = op_types_to_quantize
-
-def parse_argument_list(targt):
-    return targt.split('/')
-
-def parse_extra_options(extra_options: List[str]) -> Dict[str, str]:
-    """
-    Parse additional options in KEY=VALUE format into a dictionary.
-    """
-    options_dict = {}
-    for option in extra_options:
-        if "=" in option:
-            key, value = option.split("=", 1)
-            options_dict[key] = value
-        else:
-            raise ValueError(f"Invalid format for extra option '{option}'. Use KEY=VALUE format.")
-        
-    print(f"Extra options: {options_dict}")
-    check_extra_options(options_dict)
-    return options_dict
-
-def load_config_from_file(config_file: str):
-    """Load configurations from a YAML file into a dictionary."""
-    with open(config_file, 'r') as file:
-        config = yaml.safe_load(file)
-    return config[TRAIN_CONFIG]
-
-def parse_arguments():
-    parser = argparse.ArgumentParser(description="Exporting the HF model into a ONNX graph compatible for on-device training.", formatter_class=argparse.RawTextHelpFormatter)
-
-    parser.add_argument(
-        "--model_id",
-        type=str,
-        help="Identifier for the model to be converted."
-    )
-    parser.add_argument( 
-        "--output",
-        type=str,
-        help="Path to the model output location."
-    )
-    parser.add_argument(
-        "--training_mode",
-        type=lambda x: x.lower() == 'true',
-        default=True,
-        help="Whether the model is in training mode. Default is True."
-    )
-    parser.add_argument(
-        "--train_method",
-        type=str,
-        choices=["lora", "lora-xs", "mars", "nolora"],
-        default="lora",
-        help="The training method to use, such as LoRA. Default is 'lora'."
-    )
-    parser.add_argument(
-        "--lora_target",
-        type=parse_argument_list,
-        default=["q_proj", "k_proj"],
-        help="Target layers for LoRA, provided as a list. Default is ['q_proj', 'k_proj']."
-    )
-    parser.add_argument(
-        "--lora_rank",
-        type=int,
-        default=16,
-        help="Rank for the given LoRA method. Default is 16."
-    )
-    parser.add_argument(
-        "--lora_alpha",
-        type=int,
-        default=32,
-        help="Alpha for the PEFT method."
-    )
-    parser.add_argument(
-        "--quantize",
-        type=bool,
-        default=True,
-        help="Whether to apply quantization. Default is True."
-    )
-    parser.add_argument(
-        "--weight_type",
-        type=lambda x: QuantType[x],
-        choices=list(QuantType),
-        default=QuantType.QUInt8,
-        help="The quantization weight type, e.g., QUInt8. Default is QuantType.QUInt8. Recommended QInt8 so it stays in the same quantization domain as inference model."
-    )
-    parser.add_argument(
-        "--task_type",
-        type=str,
-        choices=["text-generation", "feature-extraction"],
-        default="text-generation",
-        help="Task type to build the model for."
-    )
-    parser.add_argument(
-        "--config_file",
-        type=str,
-        help="Path to configuration file to load additional options. This config file will overwrite all other arguments."
-    )
-    parser.add_argument(
-        "--extra_options",
-        type=str,
-        nargs="*",
-        metavar="KEY=VALUE",
-        default=[],
-        help=textwrap.dedent("""\
-         Key value pairs for various options. Currently supports:
-            postprocess = False : Whether to try to do operator fusion after creating the graph. The applied fused operators should be supported by training.
-            opset = 20 : Opset version for model operators.
-            exclude_extra_layers = layer1/layer2... : Extra layers to further exclude from the quantization. Keywords should be separated by "/".
-            """
-            )
-    )
-
-    args = parser.parse_args()
-
-    user_extra_options = {}
-    default_extra_options = {
-        "postprocess" : False,
-        "add_pooling": True,
-        "opset" : 20,
-        "exclude_extra_layers": [],
-        "exclude_specific": False,
-        "exclude_specific_layers": []
-    }
-    
-    config_dict = None
-
-    if args.config_file:
-        config_dict = load_config_from_file(args.config_file)
-
-        setattr(args, "peft_config", config_dict["peft_config"])
-        setattr(args, config_dict["train_method"], config_dict[config_dict["train_method"]])
-        
-        # Override any command-line argument with values from the config file
-        for key, value in config_dict.items():
-            
-            # Convert to the correct type
-            if hasattr(args, key):
-                setattr(args, key, value)
-        # Override any command-line argument with values from the config file
-        for key, value in config_dict["extra_options"].items():
-            default_extra_options[key] = value
-        setattr(args, "weight_type", QuantType[config_dict["weight_type"]])
-    else:
-        user_extra_options = parse_extra_options(args.extra_options)
-    args.extra_options = {**default_extra_options, **user_extra_options}
-
-    return args
-
-if __name__ == "__main__":
-
-    args = parse_arguments()
-
-    method = getattr(args, "train_method", "lora")
-    peft_config = getattr(args, "peft_config", None)
-    specific_peft_config = getattr(args, method, None)
-
-    print(f"{TRAIN_CONFIG} arguments:")
-    for arg, value in vars(args).items():
-        print(f"{arg}: {value}")
-    
-    if peft_config:
-        print("PEFT arguments:")
-        for arg, value in peft_config.items():
-            print(f"{arg}: {value}")
-
-    if specific_peft_config:
-        print("Extra specific PEFT arguments:")
-        for arg, value in specific_peft_config.items():
-            print(f"{arg}: {value}")
-
-    optimum_hf_export(
-        model_id=args.model_id,
-        model_output=args.output,
-        train_method=args.train_method,
-        training_mode=args.training_mode,
-        lora_target=args.lora_target,
-        lora_rank=args.lora_rank,
-        lora_alpha=args.lora_alpha,
-        quantize=args.quantize,
-        weight_type=args.weight_type,
-        task_type=args.task_type,
-        peft_config=peft_config,
-        specific_peft_config=specific_peft_config,
-        **args.extra_options
-    )
\ No newline at end of file
diff --git a/trainer/utils.py b/trainer/utils.py
deleted file mode 100644
index 8651d56..0000000
--- a/trainer/utils.py
+++ /dev/null
@@ -1,704 +0,0 @@
-from dataclasses import dataclass
-import inspect
-from typing import Dict, List
-from deepeval.benchmarks.hellaswag.template import HellaSwagTemplate
-from deepeval.benchmarks.bool_q.template import BoolQTemplate
-from deepeval.benchmarks.arc.template import ARCTemplate
-from deepeval.benchmarks.logi_qa.template import LogiQATemplate
-from deepeval.benchmarks.winogrande.template import WinograndeTemplate
-import numpy as np
-import torch
-from transformers import PreTrainedTokenizer
-from peft.tuners.lora import LoraLayer
-
-@dataclass
-class DataCollatorForSupervisedDataset:
-    """Dynamically pads input sequences for supervised fine-tuning."""
-
-    tokenizer: PreTrainedTokenizer
-
-    def __call__(self, instances: List[Dict], return_tensors="pt") -> Dict[str, torch.Tensor]:
-
-        input_ids, labels = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels"))
-
-        # Convert to tensors
-        input_ids = [torch.tensor(x, dtype=torch.long) for x in input_ids]
-        labels = [torch.tensor(x, dtype=torch.long) for x in labels]
-
-        pad_token_id = self.tokenizer.pad_token_id or self.tokenizer.eos_token_id  # Default to EOS if PAD is missing
-
-        # Pad sequences dynamically
-        input_ids = torch.nn.utils.rnn.pad_sequence(input_ids, batch_first=True, padding_value=pad_token_id)
-        labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=-100)
-
-        # Construct attention mask dynamically: 1 for non-pad tokens, 0 for pad tokens
-        attention_mask = input_ids.ne(pad_token_id).long()
-
-        # Convert to requested tensor format
-        if return_tensors == "np":
-            return {
-                "input_ids": input_ids.numpy(),
-                "labels": labels.numpy(),
-                "attention_mask": attention_mask.numpy()
-            }
-        elif return_tensors == "pt":
-            return {
-                "input_ids": input_ids,
-                "labels": labels,
-                "attention_mask": attention_mask
-            }
-        else:
-            raise ValueError(f"return_tensors must be 'pt' or 'np', got {return_tensors}")
-        
-    def numpy_call(self, instances: List[Dict]) -> Dict[str, np.ndarray]:
-        """Convenience method that returns NumPy arrays."""
-        return self.__call__(instances, return_tensors="np")
-    
-    def pytorch_call(self, instances: List[Dict]) -> Dict[str, torch.Tensor]:
-        """Convenience method that returns PyTorch tensors."""
-        return self.__call__(instances, return_tensors="pt")
-
-
-def process_sample_minirecommendation(samples, tokenizer, batched=True):
-    
-    def format_question(data_point):
-        """Format the recommendation prompt"""
-        user_query = data_point["prompt"]
-        category = data_point["category"]
-        
-        # Build the formatted question
-        formatted = f"Recommend best actions based on this user query: {user_query}"
-        
-        return formatted
-    
-    def format_answer(data_point):
-        """Format the recommendation answer"""
-        return data_point["recommendation"]
-
-    def generate_prompt(data_point):
-        question = format_question(data_point) + "\n\nAnswer: "
-        answer = format_answer(data_point)
-        
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["prompt"])):
-            sample = {
-                "type": samples["type"][i],
-                "category": samples["category"][i],
-                "prompt": samples["prompt"][i],
-                "recommendation": samples["recommendation"][i]
-            }
-
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tk = generate_prompt(samples)
-
-    return tk
-
-def process_sample_minipersonalqa(samples, tokenizer, batched=True):
-    
-    def format_question(data_point):
-        """Format the question with multiple choice options"""
-        question_text = data_point["question"]
-        choices = data_point["choices"]
-        
-        # Build the formatted question
-        formatted = f"Question: {question_text}\n\n"
-        for choice_key, choice_value in choices.items():
-            formatted += f"{choice_key}: {choice_value}\n"
-            
-        return formatted
-    
-    def format_answer(data_point):
-        """Format just the answer"""
-        return data_point["correct_answer"]
-
-    def generate_prompt(data_point):
-        question = format_question(data_point) + "\n\nAnswer: "
-        answer = format_answer(data_point)
-        
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["question"])):
-            sample = {
-                "type": samples["type"][i],
-                "category": samples["category"][i],
-                "question": samples["question"][i],
-                "choices": samples["choices"][i],
-                "correct_answer": samples["correct_answer"][i]
-            }
-
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tk = generate_prompt(samples)
-
-    return tk
-
-def process_sample_winogrande_deepeval(samples, tokenizer, batched=True):
-
-    def generate_prompt(data_point):
-
-        question = WinograndeTemplate.format_question(data_point, include_answer=False) + "\n\n "
-        answer = WinograndeTemplate.format_answer(data_point)
-        
-        if tokenizer.chat_template is not None:
-            messages = [
-                {"role": "user", "content": question}, 
-                {"role": "assistant", "content": " {}\n\n".format(WinograndeTemplate.format_answer(data_point))}
-            ]
-            return tokenizer.apply_chat_template(messages, tokenize=False)
-
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["sentence"])):
-            sample = {
-                "sentence": samples["sentence"][i],
-                "option1": samples["option1"][i],
-                "option2": samples["option2"][i],
-                "answer": samples["answer"][i]
-            }
-
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tk = generate_prompt(samples)
-
-    return tk
-
-def process_sample_logiqa_deepeval(samples, tokenizer, batched=True):
-
-    def generate_prompt(data_point):
-
-        question = LogiQATemplate.format_question(data_point) + "\n\n "
-        answer = LogiQATemplate.format_output(data_point)
-
-        if tokenizer.chat_template is not None:
-            messages = [
-                {"role": "user", "content": question}, 
-                {"role": "assistant", "content": " {}\n\n".format(answer)}
-            ]
-            return tokenizer.apply_chat_template(messages, tokenize=False)
-
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["question"])):
-            sample = {
-                "question": samples["question"][i],
-                "text": samples["text"][i],
-                "options": samples["options"][i],
-                "answer": samples["answer"][i]
-            }
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tp = generate_prompt(samples)
-        tk = {
-            "input_ids": tp[0],
-            "labels": tp[1]
-        }
-
-    return tk
-
-def process_sample_arc_deepeval(samples, tokenizer, batched=True):
-
-    def generate_prompt(data_point):
-
-        question = ARCTemplate.format_question(data_point, include_answer=False) + "\n\n "
-        answer = ARCTemplate.format_answer(data_point)
-
-        if tokenizer.chat_template is not None:
-            messages = [
-                {"role": "user", "content": question}, 
-                {"role": "assistant", "content": " {}\n\n".format(ARCTemplate.format_answer(data_point))}
-            ]
-            return tokenizer.apply_chat_template(messages, tokenize=False)
-
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["question"])):
-            sample = {
-                "question": samples["question"][i],
-                "choices": samples["choices"][i],
-                "answerKey": samples["answerKey"][i]
-            }
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tk = generate_prompt(samples)
-
-    return tk
-
-def process_sample_boolq_deepeval(samples, tokenizer, batched=True):
-
-    def generate_prompt(data_point):
-
-        question = BoolQTemplate.format_question(data_point) + "\n\n "
-        answer = BoolQTemplate.format_answer(data_point)
-        
-        if tokenizer.chat_template is not None:
-            messages = [
-                {"role": "user", "content": question}, 
-                {"role": "assistant", "content": " {}\n\n".format(answer)}
-            ]
-            return tokenizer.apply_chat_template(messages, tokenize=False)
-
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        # Concatenate the token sequences
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["question"])):
-            sample = {
-                "question": samples["question"][i],
-                "passage": samples["passage"][i],
-                "answer": samples["answer"][i]
-            }
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tk = generate_prompt(samples)
-
-    return tk
-
-def process_sample_hellaswag_deepeval(samples, tokenizer, batched=True):
-
-    def generate_prompt(data_point):
-
-        base_prompt = f'The following are multiple choice sentence completion problems about {data_point["activity_label"]}.\n\n'
-        choices = ["A", "B", "C", "D"]
-    
-        if tokenizer.chat_template is not None:
-            
-            gen_output = HellaSwagTemplate.format_question(
-                data_point,
-                include_answer=False
-            )
-            messages = [
-                {"role": "user", "content": base_prompt + gen_output}, 
-                {"role": "assistant", "content": " {}\n\n".format(choices[int(data_point["label"])])}
-            ]
-            return tokenizer.apply_chat_template(messages, tokenize=False)
-        
-        question = base_prompt + HellaSwagTemplate.format_question(
-            data_point,
-            include_answer=False
-        ) + "\n\n "
-
-        question_tokens = tokenizer(question, return_tensors="pt", padding=False)["input_ids"][0]
-
-        answer = "{}".format(choices[int(data_point["label"])])
-        answer_tokens = tokenizer(answer, return_tensors="pt", padding=False, add_special_tokens=False)["input_ids"][0]
-
-        input_ids = torch.cat([question_tokens, answer_tokens], dim=0)
-        labels = input_ids.clone()
-        labels[:len(question_tokens)] = -100
-
-        return (
-            input_ids.squeeze(0),
-            labels.squeeze(0)
-        )
-    
-    if batched:
-        batch = {
-            "input_ids": [],
-            "labels": []
-        }
-        for i in range(len(samples["ctx"])):
-            sample = {
-                "ctx": samples["ctx"][i],
-                "endings": samples["endings"][i],
-                "label": samples["label"][i],
-                "activity_label": samples["activity_label"][i]
-            }
-            input_ids, labels = generate_prompt(sample)
-            batch["input_ids"].append(input_ids)
-            batch["labels"].append(labels)
-        
-        return batch
-    else:
-        tp = generate_prompt(samples)
-        tk = {
-            "input_ids": tp[0],
-            "labels": tp[1]
-        }
-
-    return tk
-
-def process_sample_dolly(sample, tokenizer):
-
-    chat = [
-        {"role": "user", "content": sample['instruction']},
-        {"role": "assistant", "content": sample['response']}
-    ]
-
-    # TODO: This is wrong formatting
-    if sample['context']:
-        chat.insert(0, {"role": "system", "content": sample['context']})
-
-    # Tokenize the prompt text
-    text = tokenizer.apply_chat_template(chat, return_dict=True, tokenize=True, return_tensors="pt", padding=True, add_generation_prompt=False)
-    return {
-        "input_ids": text["input_ids"][0],
-        "attention_mask": text["attention_mask"][0]
-    }
-
-def process_sample_alpaca(sample, tokenizer):
-
-    def prompt_no_input(row):
-        return ("Below is an instruction that describes a task. "
-                "Write a response that appropriately completes the request.\n\n"
-                "### Instruction:\n{instruction}\n\n### Response:\n{output}").format_map(row)
-
-
-    def prompt_input(row):
-        return ("Below is an instruction that describes a task, paired with an input that provides further context. "
-                "Write a response that appropriately completes the request.\n\n"
-                "### Instruction:\n{instruction}\n\n### Input:\n{input}\n\n### Response:\n{output}").format_map(row)
- 
-    chat = ""
-
-    if len(sample['input']) == 0:
-        chat = prompt_no_input(sample)
-    else:
-        chat = prompt_input(sample)
-
-    # Tokenize the prompt text
-    text = tokenizer(chat, return_tensors="pt", padding=True)
-    return text
-
-
-def process_sample_hellaswag(samples, tokenizer, batched=True):
-    def generate_prompt(data_point):
-
-        endings = "\n".join([ f'{i+1}. {e}' for i, e in enumerate(data_point["endings"])])
-
-        return inspect.cleandoc(f"""
-        Context: {data_point['ctx']}
-
-        Options:
-        {endings}
-
-        Which option best completes the context?
-        Answer: {data_point['label'] + 1}
-        """).strip()
-    
-    if batched:
-        text = [
-            generate_prompt({
-                "ctx": samples["ctx"][i],
-                "endings": samples["endings"][i],
-                "label": samples["label"][i]
-            })
-            for i in range(len(list(samples.values())[0]))
-        ]
-    else:
-        text = generate_prompt(samples)
-    
-    tk = tokenizer(text, return_tensors="pt", padding=True)
-    return tk
-
-def taskname_to_deepeval_preprocess_function(preprocess_id):
-
-    if preprocess_id == "hellaswag":
-        return process_sample_hellaswag_deepeval
-    elif preprocess_id == "boolq":
-        return process_sample_boolq_deepeval
-    elif preprocess_id == "arc_e" or preprocess_id == "arc_c":
-        return process_sample_arc_deepeval
-    elif preprocess_id == "logiqa":
-        return process_sample_logiqa_deepeval
-    elif preprocess_id == "winogrande":
-        return process_sample_winogrande_deepeval
-    elif preprocess_id == "mini_personalqa":
-        return process_sample_minipersonalqa
-    elif preprocess_id == 'mini_recommendation':
-        print("USING RECOMMENDATRION")
-        return process_sample_minirecommendation
-
-    return None
-
-def create_mars_adapter_mapping(model, shared_qkv=['q', 'k', 'v'], shared_mlp_enabled=True):
-    """
-    Create a JSON mapping of base layers to their corresponding adapters.
-    Handles shared modules by their object identity and deduplicates them.
-
-    NOTE: There could be problems with mapping with this function, depending on model architectures and position of the layers.
-    
-    Args:
-        model: PyTorch model with PEFT adapters
-        
-    Returns:
-        dict: Mapping of base layer names to their adapter configurations
-    """
-    mapping = {}
-    
-    # Track unique modules by their object id to handle shared modules
-    module_id_to_name = {}
-    
-    def register_unique_module(module, full_name):
-        """Register a module and return the canonical name for shared modules"""
-        module_id = id(module)
-        if module_id in module_id_to_name:
-            # This module is shared, return the canonical name
-            return module_id_to_name[module_id]
-        else:
-            # First time seeing this module
-            module_id_to_name[module_id] = full_name
-            return full_name
-    
-    # First pass: collect all modules and their paths
-    all_modules = {}
-    for name, module in model.named_modules():
-        all_modules[name] = module
-    
-    # Find all base layers and their parent contexts
-    base_layer_contexts = {}
-    for name, module in all_modules.items():
-        if "base_layer" in name:
-            # Get parent path (everything before .base_layer)
-            parent_path = name.rsplit('.base_layer', 1)[0]
-            base_layer_contexts[name] = parent_path
-    
-    current_shared_mlp_name = None
-    shared_mlp_counter = 0
-    current_inter_mlp_name = None
-    current_shared_qkv_name = None
-    shared_qkv_counter = 0
-    current_inter_qkv_name = None
-
-    # For each base layer, find its adapters
-    for base_layer_name, parent_path in base_layer_contexts.items():
-        adapters = {}
-
-        # Prefix renaming if needed
-        if base_layer_name.startswith('base_model.model.model.'):
-            base_layer_name = base_layer_name.replace('base_model.model.model.', 'backbone.model.')
-        
-        # Look for adapters in the parent context
-        for module_name, module in all_modules.items():
-            # Skip if not in the same parent context
-            if not module_name.startswith(parent_path + "."):
-                continue
-            
-            # Prefix renaming if needed
-            if module_name.startswith('base_model.model.model.'):
-                module_name.replace('base_model.model.model.', 'backbone.model.')
-
-            # Get the relative path from parent
-            relative_path = module_name[len(parent_path) + 1:]
-            
-            # Apply categorization rules based on path patterns
-            # Rule 1: shared_*.mars_down_* -> "shared_A"
-
-            if relative_path.startswith("shared_") and ".mars_down_" in relative_path:
-                canonical_name = register_unique_module(module, module_name)
-                adapters["shared_A"] = canonical_name
-
-                if relative_path.startswith("shared_mlp"):
-                    current_shared_mlp_name = module_name
-                    
-                elif relative_path.startswith("shared_qkv"):
-                    current_shared_qkv_name = module_name
-            
-            # Rule 2: shared_*.mars -> "intermediate" (direct mars in shared)
-            elif relative_path.startswith("shared_") and relative_path.endswith(".mars"):
-                canonical_name = register_unique_module(module, module_name)
-                adapters["intermediate"] = canonical_name
-
-                if relative_path.startswith("shared_mlp"):
-                    current_inter_mlp_name = module_name
-                    shared_mlp_counter = 0
-                    adapters["adapter_index"] = 0
-                    shared_mlp_counter += 1
-                elif relative_path.startswith("shared_qkv"):
-                    current_inter_qkv_name = module_name
-                    shared_qkv_counter = 0
-                    adapters["adapter_index"] = 0
-                    shared_qkv_counter += 1
-            
-            # Rule 3: up_project.mars -> "adapter_B"
-            elif relative_path == "up_project.mars":
-                canonical_name = register_unique_module(module, module_name)
-                adapters["adapter_B"] = canonical_name
-
-                if hasattr(module, 'rank'):
-                    adapters["rank"] = int(module.rank)
-                else:
-                    print(f'[WARNING] Could not find rank in {module_name}')
-                if hasattr(module, 'alpha'):
-                    adapters["alpha"] = float(module.alpha)
-
-            # Rule 4: down_project.mars -> "adapter_A"
-            elif relative_path == "down_project.mars":
-                canonical_name = register_unique_module(module, module_name)
-                adapters["adapter_A"] = canonical_name
-        
-        # Check if we need to add pointer to shared or intermediate layer
-        if "shared_A" not in adapters and "adapter_A" not in adapters:
-            if ('q' in shared_qkv and 'q_proj' in base_layer_name) or ('v' in shared_qkv and 'v_proj' in base_layer_name) or ('k' in shared_qkv and 'k_proj' in base_layer_name):
-                adapters["shared_A"] = current_shared_qkv_name
-                adapters["intermediate"] = current_inter_qkv_name
-                adapters["adapter_index"] = shared_qkv_counter
-                shared_qkv_counter += 1
-            elif shared_mlp_enabled and ('gate_proj' in base_layer_name or 'up_proj' in base_layer_name):
-                adapters["shared_A"] = current_shared_mlp_name
-                adapters["intermediate"] = current_inter_mlp_name
-                adapters["adapter_index"] = shared_mlp_counter
-                shared_mlp_counter += 1
-
-        if adapters:
-            mapping[base_layer_name] = adapters
-
-    #with open('base_mapping.json', 'w') as f:
-    #    json.dump(mapping, f)
-
-    return mapping
-
-def create_lora_mapping(peft_model) -> dict:
-    """
-    Creates a mapping from base layer names to their corresponding LoRA adapter layer names
-    within a PEFT LoRA model.
-
-    Args:
-        peft_model (PeftModel): An instance of a PEFT LoRA model with applied LoRA adapters.
-
-    Returns:
-        dict: A dictionary where:
-              - Keys are the full path names of the base layers with LoRA adapters.
-              - Values are dictionaries containing the full path names to their
-                corresponding 'lora_A' and 'lora_B' adapter modules.
-    """
-
-    peft_mapping = {}
-
-    for module_path, module in peft_model.named_modules():
-        # Identify modules that are LoRA-enabled layers
-        if isinstance(module, LoraLayer):
-            base_layer_name = module_path
-
-            # Iterate through all adapter names for this LoRA layer (e.g., 'default')
-            for adapter_name in module.lora_A.keys():
-                lora_a_full_path = f"{base_layer_name}.lora_A.{adapter_name}"
-                lora_b_full_path = f"{base_layer_name}.lora_B.{adapter_name}"
-
-                # Prioritize 'default' adapter or use the first one found
-                if adapter_name == 'default' or base_layer_name not in peft_mapping:
-                    peft_mapping[base_layer_name] = {
-                        "adapter_A": lora_a_full_path,
-                        "adapter_B": lora_b_full_path
-                    }
-
-    return peft_mapping
\ No newline at end of file
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..73752b4
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,4777 @@
+version = 1
+revision = 3
+requires-python = ">=3.10, <3.14"
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+conflicts = [[
+    { package = "mobiletransformers", extra = "export" },
+    { package = "mobiletransformers", group = "ort-training-local" },
+], [
+    { package = "mobiletransformers", group = "genai-smoke" },
+    { package = "mobiletransformers", group = "ort-training-local" },
+], [
+    { package = "mobiletransformers", extra = "export" },
+    { package = "mobiletransformers", group = "genai-smoke" },
+]]
+
+[manifest]
+overrides = [{ name = "langchain-core", specifier = ">=0.3.74,<0.4" }]
+
+[[package]]
+name = "accelerate"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "safetensors" },
+    { name = "torch" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/75/94cd5d389649578aca399e5aa822637eec18319a1dadc400ffe2f9a7493f/accelerate-1.14.0.tar.gz", hash = "sha256:41b9c4377a54e0b460a959b0defa1b736e4ca0a2373252d9a539964c2afe3c8d", size = 412167, upload-time = "2026-06-11T13:45:52.326Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/db/253133d7e7cb40d3af384bb2f5c0b4a2b7fdcffbc95c688cc67a20a3c103/accelerate-1.14.0-py3-none-any.whl", hash = "sha256:e94390c2863b873be18f623f9df48a0d8fe5eff13ea7f1a00092b0a7904888c6", size = 389246, upload-time = "2026-06-11T13:45:50.477Z" },
+]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/eec0465c2f67b2664688d0240b3212d5196fd89e741df67ddb81f8d35658/aiohappyeyeballs-2.7.1.tar.gz", hash = "sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d", size = 24757, upload-time = "2026-07-01T17:11:55.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/43/1947f06babed6b3f1d7f38b0c767f52df66bfb2bc10b468c4a7de9eceff2/aiohappyeyeballs-2.7.1-py3-none-any.whl", hash = "sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472", size = 15038, upload-time = "2026-07-01T17:11:54.055Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "async-timeout", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/78/8ea7308cac6934de8c74a14f3d5f65d1c89287426688be79538d0e5c013d/aiohttp-3.14.1.tar.gz", hash = "sha256:307f2cff90a764d329e77040603fa032db89c5c24fdad50c4c15334cba744035", size = 7955794, upload-time = "2026-06-07T21:09:35.529Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/67/58ded4b3f2e10f94972d8928050c85330e249a31dd45a0e5f3c0e9c3fa05/aiohttp-3.14.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8f6bb621e5863cfe8fe5ff5468002d200ec31f30f1280b259dc505b02595099e", size = 766140, upload-time = "2026-06-07T21:05:37.471Z" },
+    { url = "https://files.pythonhosted.org/packages/18/68/4ae5b4e08943f316594bb68da89957d3baf5760588fa09509594bd777e4b/aiohttp-3.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4f7215cb3933784f79ed20e5f050e15984f390424339b22375d5a53c933a0491", size = 519430, upload-time = "2026-06-07T21:05:40.751Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c1/316c8f3549dbe5245f92bfd523ec6f32dd4d98cafe21df3f6a19b1184c75/aiohttp-3.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d9d4e294455b23a68c9b8f042d0e8e377a265bcb15332753695f6e5b6819e0ce", size = 514406, upload-time = "2026-06-07T21:05:42.111Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ee/fb0ac28684e8d753b83c8a4eebc19a5846912aa0a4daaabb6a9936363840/aiohttp-3.14.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b238af795833d5731d049d82bc84b768ae6f8f97f0495963b3ed9935c5901cc3", size = 1703649, upload-time = "2026-06-07T21:05:43.427Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/57/aa2beab673331f111885db8a7b69dfe3ab0e53e446a0ace18ca694b4dc58/aiohttp-3.14.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4e5e0ae56914ecdbf446493addefc0159053dd53962cef37d7839f37f73d505", size = 1675126, upload-time = "2026-06-07T21:05:44.897Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ea/dad128abe365e79be03b16ed464198ac73e0d257e8260c6f7d6f31cbef26/aiohttp-3.14.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:092e4ce3619a7c6dee52a6bdabda973d9b34b66781f840ce93c7e0cec30cf521", size = 1771558, upload-time = "2026-06-07T21:05:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/63/f3/b5b4e10327cb85d34d24232c6b71b64602f190b3ccb238a043ac6b187dac/aiohttp-3.14.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bb33777ea21e8b7ecde0e6fc84f598be0a1192eab1a63bc746d75aa75d38e7bd", size = 1856631, upload-time = "2026-06-07T21:05:47.844Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9d/93294c3045775c708ac8310eb3d3622a11d2951345ad590d532d62a1faa4/aiohttp-3.14.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23119f8fd4f5d16902ed459b63b100bcd269628075162bddac56cc7b5273b3fb", size = 1714139, upload-time = "2026-06-07T21:05:49.982Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c4/93067c85a0373492ce8e577435203c5947c454af074ac48ed4f3a1b9dd4a/aiohttp-3.14.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:57fc6745a4b7d0f5a9eb4f40a69718be6c0bc1b8368cc9fe89e90118719f4f42", size = 1588321, upload-time = "2026-06-07T21:05:51.431Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/39/9ff91aaf02af8b7b8222a987466da539f154c3e01732c22b5f5a20a8ee66/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6fd35beba67c4183b09375c5fff9accb47524191a244a99f95fd4472f5402c2b", size = 1670375, upload-time = "2026-06-07T21:05:53.109Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/e4/77452a3676b8d99ac1375f77691d6bf65ea6e9f4b201b82ef77c916dc767/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:672b9d65f42eb877f5c3f234a4547e4e1a226ca8c2eed879bb34670a0ce51192", size = 1690933, upload-time = "2026-06-07T21:05:54.902Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/84/b0059a7c7fc05ea23f3bc1596ba91c12f79588b9450564a24cac37536d0a/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:24ba13339fed9251d9b1a1bec8c7ab84c0d1675d79d33501e11f94f8b9a84e05", size = 1740798, upload-time = "2026-06-07T21:05:56.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/3a/e2a513ecbfc362591caa51a7f7e011b3bfc8938b388ae44cd95560d36999/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:94da27378da0610e341c4d30de29a191672683cc82b8f9556e8f7c7212a020fe", size = 1576412, upload-time = "2026-06-07T21:05:57.953Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/10/08f1654f538f93d36dcac66310a06eefce4641cdafca83f9f0a5317be254/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:52cdac9432d8b4a719f35094a818d95adcae0f0b4fe9b9b921909e0c87de9e7d", size = 1750199, upload-time = "2026-06-07T21:05:59.488Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/d91b70c57d8b8e9611e4a2e52238ca3698d3dc1c2efe25b7a9bf594ac584/aiohttp-3.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:672ac254412a24d0d0cf00a9e6c238877e4be5e5fa2d188832c1244f45f31966", size = 1699356, upload-time = "2026-06-07T21:06:01.131Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/f1/15340176f35ff61b95dbe34020bcf43f9e624a2d7bbac934715ff97d2033/aiohttp-3.14.1-cp310-cp310-win32.whl", hash = "sha256:2fe3607e71acc6ebb0ec8e492a247bf7a291226192dc0084236dfc12478916f6", size = 458939, upload-time = "2026-06-07T21:06:02.86Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c2/a2f1ec5b37f903109e43ae2862268cfe4a67a60c1b2cf43169fcdff5995f/aiohttp-3.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:30099eda75a53c32efb0920e9c33c195314d2cc1c680fbfd30894932ac5f27df", size = 482583, upload-time = "2026-06-07T21:06:04.666Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7a/7b56f6732ef79530afaa72aa335d41b67c8d79b946995f0b11ad72985435/aiohttp-3.14.1-cp310-cp310-win_arm64.whl", hash = "sha256:5a837f49d901f9e368651b676912bff1104ed8c1a83b280bcd7b29adccef5c9c", size = 453470, upload-time = "2026-06-07T21:06:06.322Z" },
+    { url = "https://files.pythonhosted.org/packages/26/dd/bf526e6f0a1120dd6f2df2e97bacfe4d358f13d17a0ff5847301a1375a51/aiohttp-3.14.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa00140699487bd435fde4342d85c94cb256b7cd3a5b9c3396c67f19922afda2", size = 765225, upload-time = "2026-06-07T21:06:07.957Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/e1/a2872aa55495a70f61310d411541c6ee23812d9a884e000c716e1bc3edbf/aiohttp-3.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1c1af67559445498b502030c35c59db59966f47041ca9de5b4e707f86bd10b5f", size = 518743, upload-time = "2026-06-07T21:06:09.749Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e7/c60c7b209e509cc787de3cea0550a518538cfc08003e1c1e14c1c63fff71/aiohttp-3.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d44ec478e713ee7f29b439f7eb8dc2b9d4079e11ae114d2c2ac3d5daf30516c8", size = 514139, upload-time = "2026-06-07T21:06:11.26Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/8d/614ace2f579702c9840ab1e1447fd8509e35b0b904f7196418fa2f57b25d/aiohttp-3.14.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3b1a184a9a8f548a6b73f1e26b96b052193e4b3175ed7342aaf1151a1f00a04", size = 1784088, upload-time = "2026-06-07T21:06:12.887Z" },
+    { url = "https://files.pythonhosted.org/packages/49/e0/726e90f99542bf292f81a96a12cc4847deb86f3ccf62c6f4014a201f4d33/aiohttp-3.14.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5f2504bc0322437c9a1ff6d3333ca56c7477b727c995f036b976ae17b98372c8", size = 1737835, upload-time = "2026-06-07T21:06:14.564Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/4b/d176d5c4db9d33dacf0543102ea59503bc1d528af4cfd0b719949ca49389/aiohttp-3.14.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73f05ea02013e02512c3bf42714f1208c57168c779cc6fe23516e4543089d0a6", size = 1842801, upload-time = "2026-06-07T21:06:16.228Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/d6/5a99b563690ea0cbed912ae94a2ce33993a5709a651a3a4fe761e7dd973a/aiohttp-3.14.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:797457503c2d426bee06eef808d07b31ede30b65e054444e7de64cad0061b7af", size = 1929992, upload-time = "2026-06-07T21:06:17.947Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7f/a987b14a3859094b3cea3f4825219c3e5536242564af6e3f9c2f6c994eb2/aiohttp-3.14.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b821a1f7dedf7e37450654e620038ac3b2e81e8fa6ea269337e97101978ec730", size = 1786989, upload-time = "2026-06-07T21:06:19.677Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/1a/420e5c85a3e73349372ed22ce0b6af86bfa6ce16a4b20a64a2e94608c781/aiohttp-3.14.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4cd96b5ba05d67ed0cf00b5b405c8cd99586d8e3481e8ee0a831057591af7621", size = 1640129, upload-time = "2026-06-07T21:06:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/80/18a592ed3be0a402cc03670bd72ee1f8563ddbe1d8d5542dbf868f274136/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d459b98a932296c6f0e94f87511a0b1b90a8a02c30a50e60a297619cd5a58ee", size = 1756576, upload-time = "2026-06-07T21:06:24.8Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/0b/8b3d5713373858ff71a617daf6e3b0e81ad63e79d09a3cf2f6b6b983939c/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:764457a7be60825fb770a644852ff717bcbb5042f189f2bd16df61a81b3f6573", size = 1754668, upload-time = "2026-06-07T21:06:26.528Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/49/fd564575cf225821d7ba5a117cb8bc27213d8a7e1811162afb43ae077039/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f7a16ef45b081454ef844502d87a848876c490c4cb5c650c230f6ec79ed2c1e7", size = 1817019, upload-time = "2026-06-07T21:06:28.297Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1b/e850c9ae6fc91356552ae668bb6c51e93fa29c8aef13398a10b56678557f/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2fbc3ed048b3475b9f0cbcb9978e9d2d3511acd91ead203af26ed9f0056004cf", size = 1631638, upload-time = "2026-06-07T21:06:30.242Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/94/3c337ba72451a89806ace6f75bddc92bafc5b8d53d90115a512858024b63/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bedb0cd073cc2dc035e30aeb99444389d3cd2113afe4ef9fcd23d439f5bade85", size = 1835660, upload-time = "2026-06-07T21:06:31.943Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9c/9c18cf367a0498212d9ba7daf990b504a5e8ae064cda4b504e2647c89c03/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b6feea921016eb3d4e04d65fc4e9ca402d1a3801f562aef94989f54694917af3", size = 1775698, upload-time = "2026-06-07T21:06:33.72Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/63/a251a9d2a6cb45065b2ddc0bde2b3dd10108740a9a42f632c66405a761a2/aiohttp-3.14.1-cp311-cp311-win32.whl", hash = "sha256:313701e488100074ce99850404ee36e741abf6330179fec908a1944ecf570126", size = 458386, upload-time = "2026-06-07T21:06:35.279Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ca/69274c51dcd6e8947d77b2806cf47a4a15f2c846e2cbeb1882547d3da283/aiohttp-3.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:03ab4530fdcb3a543a122ba4b65ac9919da9fe9f78a03d328a6e38ff962f7aa5", size = 483406, upload-time = "2026-06-07T21:06:36.824Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8a/c25904f77690c3688ec140f87591ef11a0cfe36bf3d5c0f1f38056fb62b3/aiohttp-3.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:486f7d16ed54c39c2cbd7ca71fd8ba2b8bb7860df65bd7b6ed640bab96a38a8b", size = 452987, upload-time = "2026-06-07T21:06:38.371Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/21/151624b51cd92553d95424daf4bf19f19ce9be9002d19253e7e7ce67197b/aiohttp-3.14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d35143e27778b4bb0fb189562d7f275bff79c62ab8e98459717c0ea617ff2480", size = 757402, upload-time = "2026-06-07T21:06:40.311Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/82/280619e0bd7bf2454987e19282616e84762255dd9c8468f62382e8c191f1/aiohttp-3.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bcfb80a2cc36fba2534e5e5b5264dc7ae6fcd9bf15256da3e53d2f499e6fa29d", size = 512310, upload-time = "2026-06-07T21:06:42.207Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b2/2aac325583aaa1353045f96dffa586d8a34e8322e14a7ba49cffeb103ab4/aiohttp-3.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27fd7c91e51729b4f7e1577865fa6d34c9adccbc39aabe9000285b48af9f0ec2", size = 512448, upload-time = "2026-06-07T21:06:43.813Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/72/a60607cb849faa8af8a356c9329ea2eb6f395d49e82cc82ccba1fd8deb8f/aiohttp-3.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c567bf9eaf664280116a8688f63016e6b32db2505908e2bdaca1b6438142f2", size = 1766854, upload-time = "2026-06-07T21:06:45.391Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d3/d9fe1c9ec7557ab4d0d82bebaa728c6418f0b93295ec2f4ab015f7710cc7/aiohttp-3.14.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f5e6ff2bdbb8f4cd3fbe41f99e25bbcd58e3bf9f13d3dd31a11e7917251cc77a", size = 1740884, upload-time = "2026-06-07T21:06:47.413Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/dc/f2cecfaf9337ba3e63f181500814ff502aa3d00d9c7ec93a9d23d10a27b2/aiohttp-3.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2f73e01dc37122325caf079982621262f96d74823c179038a82fddfc50359264", size = 1810034, upload-time = "2026-06-07T21:06:50.165Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d7/2ff65c5e65c0d7476daf7e15c032e0805e36811185b9623e3238ad6c763e/aiohttp-3.14.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bb2c0c80d431c0d03f2c7dbf125150fedd4f0de17366a7ca33f7ccb822391842", size = 1904054, upload-time = "2026-06-07T21:06:52.035Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/d445818389df371f56d141d881153ba23183c4735a03f7356ffb43f7757d/aiohttp-3.14.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e6fc1a85fa7194a1a7d19f44e8609180f4a8eb5fa4c7ed8b4355f080fad235c", size = 1790278, upload-time = "2026-06-07T21:06:54.049Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/aa/bf04cb4d865fc6101c2229a294ad744973b72e513fdc5a6b791e6983d72a/aiohttp-3.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:686b6c0d3911ec387b444ddf5dc62fb7f7c0a7d5186a7861626496a5ab4aff95", size = 1591795, upload-time = "2026-06-07T21:06:55.911Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b4/4dac0038960427ba832f6609dfb4ea5437d7fd80c72001b9e48f834f428b/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c6fa4dc7ad6f8109c70bb1499e589f76b0b792baf39f9b017eb92c8a81d0a199", size = 1728397, upload-time = "2026-06-07T21:06:57.777Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/7cd4e8ad7aa3b75f17d56bb5498dd604a93d4e6eece822ba0568c413fff0/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:87a5eea1b2a5e21e1ebdbb33ad4165359189327e63fc4e4894693e7f821ac817", size = 1766504, upload-time = "2026-06-07T21:07:00.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/df/fc01d9fcad0f73fed3f3d361f1f94f975947b50dff82919f6dc2bf4316cc/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c1421eb01d4fd608d88cc8290211d177a58532b55ad94076fb349c5bf467f0a", size = 1777806, upload-time = "2026-06-07T21:07:02.064Z" },
+    { url = "https://files.pythonhosted.org/packages/41/09/47e2d090bddcc8fb4ccb4c314aadc32d7c5d9bb55f50f6ad1c92fc15d501/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:34b257ec41345c1e8f2df68fa908a7952f5de932723871eb633ecbbff396c9a4", size = 1580707, upload-time = "2026-06-07T21:07:03.942Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/36/f1a4ce904ae0b6930cfe9afc96d0896f7ec1a620c400405d63783bb95a9c/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:de538791a80e5d862addbc183f70f0158ac9b9bb872bb147f1fd2a683691e087", size = 1798121, upload-time = "2026-06-07T21:07:05.987Z" },
+    { url = "https://files.pythonhosted.org/packages/70/0a/e0075ce9ca0279ee1d4f0c0b85f54fea02ebc83c3007651a72bece658fec/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f71173be42d3241d428f760122febb748de0623f44308a6f120d0dd9ec572e3", size = 1767580, upload-time = "2026-06-07T21:07:07.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/a0c0a8f327a9c52095cdd8e312391b00d3ed64ab6c72bb5c33d8ec251cf7/aiohttp-3.14.1-cp312-cp312-win32.whl", hash = "sha256:ec8dc383ee57ea3e883477dcca3f11b65d58199f1080acaf4cd6ad9a99698be4", size = 452771, upload-time = "2026-06-07T21:07:09.669Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d9/ea367c75f16ac9c6cdc8febb25e8318fa21a2b1bc8d6514d4b2d890bface/aiohttp-3.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2aa92c87868cd13674989f9ee83e5f9f7ea4237589b728048e1f0c8f6caa3271", size = 479873, upload-time = "2026-06-07T21:07:11.538Z" },
+    { url = "https://files.pythonhosted.org/packages/03/64/8d96784a7851156db8a4c6c3f6f91042fdf39fb15a4cc38c8b3c14833c45/aiohttp-3.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:2c840c90759922cb5e6dda94596e079a30fb5a5ba548e7e0dc00574703940847", size = 448073, upload-time = "2026-06-07T21:07:13.637Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/97/bd137012dd97e1649162b099135a80e1fd59aaa807b2430fc448d1029aff/aiohttp-3.14.1-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:b3a03285a7f9c7b016324574a6d92a1c895da6b978cb8f1deee3ac72bc6da178", size = 506882, upload-time = "2026-06-07T21:07:15.501Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/79/e5cc690e9d922a66887ceeaca53a8ffd5a7b0be3816142b7abc433742d89/aiohttp-3.14.1-cp313-cp313-android_21_x86_64.whl", hash = "sha256:2a73f487ab8ef5abbb24b7aa9b73e98eaba9e9e031804ff2416f02eca315ccaf", size = 515270, upload-time = "2026-06-07T21:07:17.53Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/22/a73ccbf9dbd6e26dda0b24d5fd5db7da92ee3383a79f47677ffb834c5c5b/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:915fbb7b41b115192259f8c9ae58f3ddc444d2b5579917270211858e606a4afd", size = 485841, upload-time = "2026-06-07T21:07:19.555Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b9/57ed8eaf596321c2ad747bd480fb1700dbd7177c60dfc9e4c187f629662e/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:7fb4bdf95b0561a79f259f9d28fbc109728c5ee7f27aff6391f0ca703a329abe", size = 492088, upload-time = "2026-06-07T21:07:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c0/5ebe5270a7c140d7c6f79dcb018640225f14d406c149e4eec04a7d82fe71/aiohttp-3.14.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1b9748363260121d2927704f5d4fc498150669ca3ae93625986ee89c8f80dcd4", size = 501564, upload-time = "2026-06-07T21:07:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/75/7f/8cdaa24fc7983865e0915153b96a9ac5bcdd3548d64c5a27d17cecccad2d/aiohttp-3.14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:86a6dab78b0e43e2897a3bbe15745aa60dc5423ca437b7b0b164c069bf91b876", size = 751998, upload-time = "2026-06-07T21:07:25.046Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f4/c4227aacfacc5cb0cc2d119b65301d177912a6842cd64e120c47af76064f/aiohttp-3.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4dfd6e47d3c44c2279907607f73a4240b88c69eb8b90da7e2441a8045dfd21da", size = 510918, upload-time = "2026-06-07T21:07:27.28Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/01/a2d5f96cd4e74424864d30bc0a7e44d0a12dacdcfa91b5b2d1bd3dca6bf3/aiohttp-3.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:317acd9f8602858dc7d59679812c376c7f0b97bcbbf16e0d6237f54141d8a8a6", size = 508657, upload-time = "2026-06-07T21:07:29.252Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ed/3c0fb5c500fdd8e7ebc10d1889c04384fffa1a9163eac1356088ca9da1b1/aiohttp-3.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd869c427324e5cb15195793de951295710db28be7d818247f3097b4ab5d4b96", size = 1757907, upload-time = "2026-06-07T21:07:31.03Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ab/d4c924d9bd5be3050c226612413ce68cb54c70d2c31b661bfc8d9a5b6a70/aiohttp-3.14.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93b032b5ec3255473c143627d21a69ac74ae12f7f33974cb587c564d11b1066f", size = 1737565, upload-time = "2026-06-07T21:07:33.031Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/37326821ff779084020cdc33224d20b19f42f4183a500ff92022a739eda7/aiohttp-3.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f234b4deb12f3ad59127e037bc57c40c21e45b45282df7d3a55a0f409f595296", size = 1799018, upload-time = "2026-06-07T21:07:35.003Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/4f/6e947ba73e4ce09070761c05ed3a8ceb7c21f5e46798671d8b2aac0e4626/aiohttp-3.14.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9af6779bfb46abf124068327abcdf9ce95c9ef8287a3e8da76ccf2d0f16c28fa", size = 1894416, upload-time = "2026-06-07T21:07:36.956Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6e/dbf1d0625dc711fb2851f4f3c3055c39ed58bae92082d8c627dbe6013736/aiohttp-3.14.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:faccab372e66bc76d5731525e7f1143c922271725b9d38c9f97edcc66266b451", size = 1783881, upload-time = "2026-06-07T21:07:39.063Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c2/5e25098a67268ed369483ae7d1a58bd0a13d03aab860d2a0e4a6eb25b046/aiohttp-3.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f380468b09d2a81633ee863b0ec5648d364bd17bb8ecfb8c2f387f7ac1faf42c", size = 1587572, upload-time = "2026-06-07T21:07:41.058Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/bd/cf9cee17e140f942a3de73e658a543aa8fbf35a5fc67a9d2538d52d77f0b/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:97e704dcd26271f5bda3fa07c3ce0fb76d6d3f8659f4baa1a24442cc9ba177ca", size = 1722137, upload-time = "2026-06-07T21:07:43.014Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6d/5684f8c59045c96f81a18cefbc1fbbd79d25b88f1c622f2a5c5c08fcb632/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:269b76ac5394092b95bc4a098f4fc6c191c083c3bd12775d1e30e663132f6a09", size = 1755953, upload-time = "2026-06-07T21:07:45.933Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/40/35caf3170f8359760740a7d9aa0fff2e344bef98e1d1186f5a0f6dec17e6/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0b3e614340c889d575451696374c9d17affd54cd607ca0babed8f8c37b9397", size = 1766479, upload-time = "2026-06-07T21:07:48.047Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/a1/b0c61e7a137f0d81de49a82023a6df73c3c16d6fefb0f8e4a93d21639002/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5663ee9257cfa1add7253a7da3035a02f31b6600ec48261585e1800a81533080", size = 1580077, upload-time = "2026-06-07T21:07:50.069Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/41/194ea4623693009fcefebef7aef63c141754f153e9cd0d39d3b9e36c175c/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:603a2c834142172ffddc054067f5ec0ca65d57a0aa98a71bc81952573208e345", size = 1791688, upload-time = "2026-06-07T21:07:52.106Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/45/4de841f005cfe1fd63e2a2fe011262c515e2a62aa6994b15947e7d717ac9/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cb21957bb8aca671c1765e32f58164cf0c50e6bf41c0bbbd16da20732ecaf588", size = 1761094, upload-time = "2026-06-07T21:07:54.113Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ae/dbce10533d3896d544d5053939ed75b7dc31a1b0973d959b1b5ae21028d6/aiohttp-3.14.1-cp313-cp313-win32.whl", hash = "sha256:e509a55f681e6158c20f70f102f9cf61fb20fbc382272bc6d94b7343f2582780", size = 452662, upload-time = "2026-06-07T21:07:56.06Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/0bf1a19362c32f06229da5e7ddfcec91f93474d6307f7a2d3135e9c674dc/aiohttp-3.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:1ac8531b638959718e18c2207fbfe297819875da46a740b29dfa29beba64355a", size = 479748, upload-time = "2026-06-07T21:07:58.319Z" },
+    { url = "https://files.pythonhosted.org/packages/22/0a/62e7232dc9484fbec112ceb32efb6a624cc7994ec6e2b019286f17c4e8f2/aiohttp-3.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:250d14af67f6b6a1a4a811049b1afa69d61d617fca6bf33149b3ab1a6dbcf7b8", size = 447723, upload-time = "2026-06-07T21:08:00.154Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.14.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" },
+]
+
+[[package]]
+name = "ast-serialize"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/ad/0d70a3a2d6e01968d985415259e8ec7ad3f777903f9b1c1f3c8c44642c60/ast_serialize-0.6.0.tar.gz", hash = "sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe", size = 61489, upload-time = "2026-06-30T20:02:55.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/19/ac8348ae8711c9b5ae834634f635780cab62a0f5e6f988882e048b89c2ae/ast_serialize-0.6.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596", size = 1185367, upload-time = "2026-06-30T20:02:30.427Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/f6/ec7ec652c51db77c2f61d8573338e13e4704303265ccc658cb4031d9f354/ast_serialize-0.6.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad", size = 1178657, upload-time = "2026-06-30T20:02:31.964Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/02/613a7534a41d0122f37d1e0c64aa8ac78bfb831f8c92f6db057a311abb3c/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a", size = 1238620, upload-time = "2026-06-30T20:02:33.664Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/21/087957bba486242afc52f49b2d9e21c9dad00289356cf9efe67084015a9d/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081", size = 1236075, upload-time = "2026-06-30T20:02:34.936Z" },
+    { url = "https://files.pythonhosted.org/packages/82/04/78128bbb170071c2c72a210a181f1c00e11cc1cec60a8beef747b07f9201/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77", size = 1441348, upload-time = "2026-06-30T20:02:36.245Z" },
+    { url = "https://files.pythonhosted.org/packages/64/64/62fb99d6faf199b4c3e5b08a07136e9a0d7664bb249c6de3670e5b63e9b6/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790", size = 1258580, upload-time = "2026-06-30T20:02:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/87/b4d6c38e0ccd5e85dc54cecdf933a152c60b28fe5d993a6d8a72fa6d5896/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7", size = 1261693, upload-time = "2026-06-30T20:02:39.123Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/4b/3676ca2191f39bafb75f93f99b2f429ec464586158fece2165f3572805dc/ast_serialize-0.6.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b", size = 1252517, upload-time = "2026-06-30T20:02:40.511Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/58/494ef8c4b4acb2f4a265ac934caf45f792a08fe27d6b853de35ad991941a/ast_serialize-0.6.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b", size = 1304843, upload-time = "2026-06-30T20:02:41.961Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f2/13736d920ab3d49bbee80ef1a277dd7b7aaf3b3545efd9d2a8114fe05525/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32", size = 1413698, upload-time = "2026-06-30T20:02:44.179Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5a/e046f3899e2acba4677d7427b76431443a1aa1a0e583dfb05b55b69d55cf/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b", size = 1512209, upload-time = "2026-06-30T20:02:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/c7/e42aaca7bb2d22a7c06d5a8c7930086c5a334e93d716e6fa5e6647a4515f/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a", size = 1508464, upload-time = "2026-06-30T20:02:46.942Z" },
+    { url = "https://files.pythonhosted.org/packages/95/93/5524a3dc6c3f593de3228ed9cbef73afa047625b7000ec21b7f58e6eb4d4/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e", size = 1457164, upload-time = "2026-06-30T20:02:48.294Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c0/36a6ffb4d653cf621427b4c4928671f53ad800c453474de2b82564a44ad9/ast_serialize-0.6.0-cp39-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b", size = 863014, upload-time = "2026-06-30T20:02:49.742Z" },
+    { url = "https://files.pythonhosted.org/packages/09/c7/7d5ad8b49e1278e1c2a1e0274bd7850560b3f09313aa00c13bc8d5544792/ast_serialize-0.6.0-cp39-abi3-win32.whl", hash = "sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1", size = 1063165, upload-time = "2026-06-30T20:02:50.98Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ae/6710c14ecb276031cf10249f6adf5a59e2d3fdb3b5183bd59f70524067ee/ast_serialize-0.6.0-cp39-abi3-win_amd64.whl", hash = "sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e", size = 1101444, upload-time = "2026-06-30T20:02:52.554Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/c53deb2cd0c9b0fb636d24d9f40924cf2e65028e6b20b10cd5c1eeb2c730/ast_serialize-0.6.0-cp39-abi3-win_arm64.whl", hash = "sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e", size = 1072965, upload-time = "2026-06-30T20:02:54.097Z" },
+]
+
+[[package]]
+name = "async-timeout"
+version = "4.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/87/d6/21b30a550dafea84b1b8eee21b5e23fa16d010ae006011221f33dcd8d7f8/async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f", size = 8345, upload-time = "2023-08-10T16:35:56.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/fa/e01228c2938de91d47b307831c62ab9e4001e747789d0b05baf779a6488c/async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028", size = 5721, upload-time = "2023-08-10T16:35:55.203Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
+]
+
+[[package]]
+name = "backoff"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/d7/5bbeb12c44d7c4f2fb5b56abce497eb5ed9f34d85701de869acedd602619/backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba", size = 17001, upload-time = "2022-10-05T19:19:32.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148, upload-time = "2022-10-05T19:19:30.546Z" },
+]
+
+[[package]]
+name = "backports-asyncio-runner"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893, upload-time = "2025-07-02T02:27:15.685Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" },
+]
+
+[[package]]
+name = "backrefs"
+version = "8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/56/4744bcd0c82184e80c52b0ac4076c261a8ffa1f1b343ff2f6e89ce0e1cef/backrefs-8.0.tar.gz", hash = "sha256:b556cd7d36c3a3a2f256b89590b176b8eddfb73bcfaee3a3ddd84ea66d21ce50", size = 7013081, upload-time = "2026-07-26T19:54:24.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/fd/9bf53b6a6f6f519ffaac765df2f2a25e5c2fc6d32cfd2b2747099e72c911/backrefs-8.0-py310-none-any.whl", hash = "sha256:4a627b817fd2dce43b79ab48da63613340509381cd8ce0897078a0bce79a2ab8", size = 380377, upload-time = "2026-07-26T19:54:17.457Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/29/4bd7ae72a2634da00379c2b3bcc5439e7c94620235c6afea8af15229a973/backrefs-8.0-py311-none-any.whl", hash = "sha256:f0c35cf0102ba6b6070c12a492be3c1c1d3f5839529784b9a9565d6d04569a01", size = 392169, upload-time = "2026-07-26T19:54:18.782Z" },
+    { url = "https://files.pythonhosted.org/packages/29/13/232505664e8e2a0c7a2eb0c505cfade9d715538f89a5d62bc4c272968f62/backrefs-8.0-py312-none-any.whl", hash = "sha256:87f0fae8c5f207fe9f4b2887efc71d42f4900ac78faa1af08d675ef303692dc5", size = 398084, upload-time = "2026-07-26T19:54:19.954Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/69/47a3dc20abc4fa5486655fde681bd55e63211b46c886d8c02223d6468431/backrefs-8.0-py313-none-any.whl", hash = "sha256:601ce68ca12385dbda06ce264406b4c4210cf5b79fd0fd627592365c92f29a88", size = 400040, upload-time = "2026-07-26T19:54:21.194Z" },
+]
+
+[[package]]
+name = "cerberus"
+version = "1.3.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7a/cf/845d32e330e49e34f1a22dc44868750e75485d7c08c07d37795bcf0a780e/cerberus-1.3.8.tar.gz", hash = "sha256:579554887ffd189226774b87570f4a76db75cf0efcbaffcacd5e98b8ee877f61", size = 29660, upload-time = "2025-11-06T18:29:40.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/00/ff53f3a4d51e64e9137ce2408a43edf18fec96eebb61f87a6598578fa563/cerberus-1.3.8-py3-none-any.whl", hash = "sha256:46c029e3e2a4735408ed36bec14ef2cbf3e50d8ebe47fb34ee1e54b2da814df2", size = 30567, upload-time = "2025-11-06T18:29:38.815Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.6.17"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/c7/424b75da314c1045981bd9777432fad05a9e0c69daa4ed7e308bbaffe405/certifi-2026.6.17.tar.gz", hash = "sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432", size = 134594, upload-time = "2026-06-17T10:31:07.894Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl", hash = "sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db", size = 133289, upload-time = "2026-06-17T10:31:06.348Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/2a/23f34ec9d04624958e137efdc394888716353190e75f25dd22c7a2c7a8aa/charset_normalizer-3.4.9.tar.gz", hash = "sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b", size = 152439, upload-time = "2026-07-07T14:34:58.454Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/81/8e983840c6e5b93b33c2ba81aa3d52c2e42f0e9a690ce7607a2e61da4a5c/charset_normalizer-3.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a", size = 322240, upload-time = "2026-07-07T14:32:36.236Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d1/b4319dc3229d8272fba305e206fc0a148e2de8d4087917ce62ae6382f359/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616", size = 216475, upload-time = "2026-07-07T14:32:38.142Z" },
+    { url = "https://files.pythonhosted.org/packages/80/33/6c99c1b3e6b8bf730e1bc809b9a2608f224145069114c479a2e9e1494346/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209", size = 238670, upload-time = "2026-07-07T14:32:39.658Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f4/ffbb83546e1f198ecc70ecd372b65cf2b50f9068b380abd67640f17a8e18/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99", size = 233476, upload-time = "2026-07-07T14:32:41.155Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5f/b98b8da398637b551e427e7be922bdec19177dc54d6811dcdaa503f23aac/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8", size = 223817, upload-time = "2026-07-07T14:32:42.592Z" },
+    { url = "https://files.pythonhosted.org/packages/36/31/a276bb2e66243072a3fd06fdcab9cbb61a305b02143d70d2bda21d888fa8/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b", size = 207974, upload-time = "2026-07-07T14:32:44.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/be/7ee4453d7e88dfbc4104ccd34900b9f2c7c17dac22881865fe0e82424a25/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2", size = 221655, upload-time = "2026-07-07T14:32:45.64Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/85/181c652953eb5276d198f375b1dd641047392050098100a3a02d6534f657/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9", size = 219229, upload-time = "2026-07-07T14:32:47.376Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/e7/aaf6da33fc9f4691cda8f7efbc9f69179d3d39ec8a4799baf273ee1d8db0/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15", size = 209704, upload-time = "2026-07-07T14:32:48.855Z" },
+    { url = "https://files.pythonhosted.org/packages/63/01/f2fb3bd3a73be48b173ee0c6aa8d2497af97d5663a8c4c4b491de4c62f7a/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d", size = 226243, upload-time = "2026-07-07T14:32:50.239Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/02/c57a22739fe05246b0b5783b3bfb6afaac4eebb46f3ececdfb2f048f780e/charset_normalizer-3.4.9-cp310-cp310-win32.whl", hash = "sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381", size = 150935, upload-time = "2026-07-07T14:32:51.676Z" },
+    { url = "https://files.pythonhosted.org/packages/37/8d/ca39a7559a4797505530d084fd3a49a2c959efbbbff146302fb7be4e3b35/charset_normalizer-3.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee", size = 162314, upload-time = "2026-07-07T14:32:53.193Z" },
+    { url = "https://files.pythonhosted.org/packages/01/da/a44bd7a13d426e69e4894557106cd58669097bfad4a8681123b618fbfc5d/charset_normalizer-3.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419", size = 153075, upload-time = "2026-07-07T14:32:54.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/e3/85ec501f206fb049259288c1f3506e53876937fb00edb47009348e66756b/charset_normalizer-3.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5", size = 317075, upload-time = "2026-07-07T14:32:56.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/69/2a5385192e67175f7d8bd5ce4f57c24bc956439adeae5c13a99aa28a53d1/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2", size = 213837, upload-time = "2026-07-07T14:32:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/46/03ddc7da576d814fe0a36dd1f0fd3258e95404b4b2e3c026b7923d7e133f/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a", size = 235503, upload-time = "2026-07-07T14:32:59.205Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6e/de0229a7ef40f6f9d28a837eebf4ec47bdca5dab4e900c84f22919af636a/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29", size = 229944, upload-time = "2026-07-07T14:33:00.803Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/34/49b9060e8418b14fb5cba9cf6bfb383111e2538a03a1fb18e66a95aeb3d5/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c", size = 221276, upload-time = "2026-07-07T14:33:02.199Z" },
+    { url = "https://files.pythonhosted.org/packages/44/95/80282cce0fae9c3061203d723ee87da996aed79679e65d8935050ee7ca1f/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b", size = 205260, upload-time = "2026-07-07T14:33:03.698Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/74/2f62c8821b969ea3bd67cc2e6976834f48ca5d12664d2559ebcd9bcfbed7/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db", size = 217786, upload-time = "2026-07-07T14:33:05.12Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/8d/feabb82cb49fcad14515b1d7d1ca4787b0da7fc723a212bf89bc9e0fac52/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993", size = 216798, upload-time = "2026-07-07T14:33:06.629Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ff/c946d63bc3786d5b84d960b0f7ab7e25b828486a946b5aa997625bcaf6a6/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da", size = 206429, upload-time = "2026-07-07T14:33:08.006Z" },
+    { url = "https://files.pythonhosted.org/packages/af/ba/5e5007c370702f85d2ef75791fac7943ed41e080364a673b20142e430e3e/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3", size = 223066, upload-time = "2026-07-07T14:33:09.783Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d5/9096aa3cf532dfad237861544eb47a0f20d5adbf1039760fed8eaae935d9/charset_normalizer-3.4.9-cp311-cp311-win32.whl", hash = "sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d", size = 150456, upload-time = "2026-07-07T14:33:11.217Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/a1/e29995109e455dc8eff8d0fac6ae509be39561318a7cfeac5d33ad029213/charset_normalizer-3.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1", size = 161410, upload-time = "2026-07-07T14:33:12.743Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8d/1569f4d0032d6ba2a4fe4591c35bf87868c600c41a71eb5c2e1ffa8464c2/charset_normalizer-3.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec", size = 152649, upload-time = "2026-07-07T14:33:14.173Z" },
+    { url = "https://files.pythonhosted.org/packages/70/4a/ecbd131485c07fcdfad54e28946d513e3da22ef3b4bd854dcafae54ec739/charset_normalizer-3.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0", size = 319300, upload-time = "2026-07-07T14:33:15.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/96/5d9364e3342d69f3a045e1777bc47c85c383e6e9466d561b33fdb419d1f9/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9", size = 215802, upload-time = "2026-07-07T14:33:17.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/4c/5361f9aa7f2cb58d94f2ab831b3d493f69efb1d239654b4744e3c09527cb/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44", size = 237171, upload-time = "2026-07-07T14:33:18.576Z" },
+    { url = "https://files.pythonhosted.org/packages/50/78/ce342ca4ff30b2eb49fe6d9578df85974f90c67d294113e94efdd9664cbd/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9", size = 233075, upload-time = "2026-07-07T14:33:20.084Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c4/4fa4c8b3097a11f3c5f09a35b72ed6855fb1d332469504962ab7bafcc702/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd", size = 224256, upload-time = "2026-07-07T14:33:21.747Z" },
+    { url = "https://files.pythonhosted.org/packages/87/3a/ad914516df7e358a81aae018caa5e0470ba827fa6d763b1d2e87d920a5f6/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84", size = 208784, upload-time = "2026-07-07T14:33:23.313Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/74/3c12f9755717dfe5c5c87da63f35d765fa0c00382ec26bf23f7fae34f2ba/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b", size = 219928, upload-time = "2026-07-07T14:33:24.814Z" },
+    { url = "https://files.pythonhosted.org/packages/33/9a/895095b83e7907abd6d3d99aad3a38ad0d9686cc186cb0c94c24320fe63e/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde", size = 218489, upload-time = "2026-07-07T14:33:26.42Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/34/ef5c05f412f42520d7709b7d3784d19640839eb7366ded1755511585429f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39", size = 210267, upload-time = "2026-07-07T14:33:27.952Z" },
+    { url = "https://files.pythonhosted.org/packages/83/dc/9b29fa4412b318bf3bfea985c35d67eb55e04b59a7c3f2237168b0e0be6f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62", size = 226030, upload-time = "2026-07-07T14:33:29.397Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/42/6dbc00b8cd16011691203e33570fa42ed5746599a2e878112d16eab403a3/charset_normalizer-3.4.9-cp312-cp312-win32.whl", hash = "sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642", size = 151185, upload-time = "2026-07-07T14:33:30.781Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cc/f920afd1a23c58ccd53c1d36085a71893a4737ff5e66e0371efab6809850/charset_normalizer-3.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0", size = 162557, upload-time = "2026-07-07T14:33:32.176Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/e6/0386d43a261ff4e4b30c5857af7df877254b46bec7b9d1b74b6bf969a90b/charset_normalizer-3.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2", size = 152665, upload-time = "2026-07-07T14:33:33.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/06/97ec2aeae780b31d742b6352218b43841a6871e2564578ca522dce4a45c3/charset_normalizer-3.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614", size = 317688, upload-time = "2026-07-07T14:33:35.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/39/8ff066c672434225f8d25f8b739f992af250944392173dcc88362681c9bf/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698", size = 214982, upload-time = "2026-07-07T14:33:36.996Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8f/3a47a3667c83c2df9483d91644c6c107de3bf8874aa1793da9d3012eb986/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b", size = 236460, upload-time = "2026-07-07T14:33:38.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/60/b22cdbee7e4013dab8b0d7647fc6181120fbbbc8f7025c226d15bd5a47fc/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9", size = 232003, upload-time = "2026-07-07T14:33:40.059Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f8/72eb13dcabe7257035cea8aefd922caad2f110d252bf9f67c4c2ca763aee/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33", size = 223149, upload-time = "2026-07-07T14:33:41.631Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3e/faee8f9de92b14ee1198e9163252bb15efee7301b31256a3b6d9ebfdd0dd/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63", size = 207901, upload-time = "2026-07-07T14:33:43.209Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/25/45f30093ae27dd7b92a793b61882a38685f993700113ca36e0c9c14965e1/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0", size = 219176, upload-time = "2026-07-07T14:33:44.725Z" },
+    { url = "https://files.pythonhosted.org/packages/48/18/c8f397329c35e32f6a837e488986f4ae03bd2abebc453b48714991630c2f/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe", size = 217356, upload-time = "2026-07-07T14:33:46.192Z" },
+    { url = "https://files.pythonhosted.org/packages/86/7e/5ce0bba863470fd1902d5e5843968951bddf38abe4742fc97116ef4598b3/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35", size = 209614, upload-time = "2026-07-07T14:33:47.705Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/ef/2473d3c4d869155be4af1191111d59c4d5c4e0173026f7e85b176e23bf65/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8", size = 224991, upload-time = "2026-07-07T14:33:49.238Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a3/53ddae3db108a088156aa8ddfafd411ebbc1340f48c5573f697b27f69a39/charset_normalizer-3.4.9-cp313-cp313-win32.whl", hash = "sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9", size = 150622, upload-time = "2026-07-07T14:33:50.711Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ef/6953a77c7cf2c2ff9998e6f575ab3e380119f100223381565a4f94c1f836/charset_normalizer-3.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115", size = 161947, upload-time = "2026-07-07T14:33:52.197Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/fb/d560d1d1555debbfe7849d9cac6145c1b537709d79576bf22557ed803b82/charset_normalizer-3.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012", size = 152594, upload-time = "2026-07-07T14:33:53.486Z" },
+    { url = "https://files.pythonhosted.org/packages/98/2b/f97f1c193fb855c345d678f5077d6926034db0722df74c8f057020e05a25/charset_normalizer-3.4.9-py3-none-any.whl", hash = "sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5", size = 64538, upload-time = "2026-07-07T14:34:56.993Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" },
+    { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" },
+    { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" },
+    { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" },
+    { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" },
+    { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" },
+    { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" },
+    { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" },
+    { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" },
+    { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" },
+    { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" },
+    { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" },
+    { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" },
+    { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },
+    { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },
+    { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },
+    { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" },
+    { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" },
+    { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" },
+    { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" },
+    { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },
+    { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" },
+    { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" },
+    { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" },
+    { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" },
+    { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "deepeval"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "click" },
+    { name = "grpcio" },
+    { name = "jinja2" },
+    { name = "nest-asyncio" },
+    { name = "openai" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-sdk" },
+    { name = "portalocker" },
+    { name = "posthog" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyfiglet" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-repeat" },
+    { name = "pytest-rerunfailures" },
+    { name = "pytest-xdist" },
+    { name = "python-dotenv" },
+    { name = "questionary" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "sentry-sdk" },
+    { name = "setuptools" },
+    { name = "tabulate" },
+    { name = "tenacity" },
+    { name = "tqdm" },
+    { name = "typer" },
+    { name = "wheel" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/39/85/0e0bc02626f931b38a89b4e424ffa02f334c273daffbd7a1a195da39e3ea/deepeval-4.1.0.tar.gz", hash = "sha256:03c5206a4258c6831affdb92aee1a4b131d37daf92df8af122c745f482d85268", size = 765789, upload-time = "2026-07-12T09:29:38.52Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/c6/6c9afa2f8056dc22c21aad8cf0278e231032faa79331cfbe5840e64a3ec4/deepeval-4.1.0-py3-none-any.whl", hash = "sha256:d493d80ac298eaa4336fd92a61539a7da836c0a8ee5870fb4075c30bd4d13dd6", size = 1097326, upload-time = "2026-07-12T09:29:40.456Z" },
+]
+
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "execnet"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.29.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/94/00f2059e4835eace3ae8fde680b932c496f8ec7bdc99168dfa53fb2e6b79/filelock-3.29.7.tar.gz", hash = "sha256:5b481979797ae69e72f0b389d89a80bdd585c260c5b3f1fb9c0a5ba9bb3f195d", size = 71521, upload-time = "2026-07-08T05:46:58.716Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/02/be4a57b60c7149b55b9e3b3c13f609cd8eb5307c751f22bd8fb8d262e75b/filelock-3.29.7-py3-none-any.whl", hash = "sha256:987db6f789a3a2a59f55081801b2b3697cb97e2a736b5f1a9e99b559285fbc51", size = 46036, upload-time = "2026-07-08T05:46:57.53Z" },
+]
+
+[[package]]
+name = "flatbuffers"
+version = "24.3.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/74/2df95ef84b214d2bee0886d572775a6f38793f5ca6d7630c3239c91104ac/flatbuffers-24.3.25.tar.gz", hash = "sha256:de2ec5b203f21441716617f38443e0a8ebf3d25bf0d9c0bb0ce68fa00ad546a4", size = 22139, upload-time = "2024-03-26T05:33:36.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/f0/7e988a019bc54b2dbd0ad4182ef2d53488bb02e58694cd79d61369e85900/flatbuffers-24.3.25-py2.py3-none-any.whl", hash = "sha256:8dbdec58f935f3765e4f7f3cf635ac3a77f83568138d6a2311f524ec96364812", size = 26784, upload-time = "2024-03-26T05:33:35.24Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.63.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/c9/4141c90a90db20f807c7e10bfd689fe53eb8f7f4caff58ee4d4dfe46919f/fonttools-4.63.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e3297a6a4059b4acc3a1e9a8b04741f240a80044eef08ebd32e8b5bcdddce75b", size = 2884632, upload-time = "2026-05-14T12:02:38.56Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/46/ad12b5c10eae602d7ef814b02afa08aacbf89da917fed5b071282b7eadc2/fonttools-4.63.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b1cd75a03ad8cb5bc40c90bfde68c0c47de423aa19e5c0f362b43520645eea94", size = 2429441, upload-time = "2026-05-14T12:02:41.162Z" },
+    { url = "https://files.pythonhosted.org/packages/90/8f/bdca24a84c81d56fffed052229cdcff368f6e05882e526f4558891481f65/fonttools-4.63.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0425b277a59cff3d80ca42162a8de360f318438a2ac83570842a678d826d579", size = 4946346, upload-time = "2026-05-14T12:02:43.41Z" },
+    { url = "https://files.pythonhosted.org/packages/04/59/a639c0e136441ee91a65b56fdf89e5d075927e7a09c559d1b0f5276577db/fonttools-4.63.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d7e5c9973aa04c95650c96e5f5ad865fbf42d62079163ecfab1e01cbc2504c22", size = 4903184, upload-time = "2026-05-14T12:02:45.742Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/53/91b7e0cb45b536f3da1b29ba8cbab89f27e8b986809e0b1982303a3f4eca/fonttools-4.63.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cb014d58140a38135f16064c74c652ed57aa0b75cbf8bb59cac821f7edb5334e", size = 4922967, upload-time = "2026-05-14T12:02:48.386Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b7/87439bf44e6b97c5538cd29d0b7e366a5b8ce2cc132a4134fb67fa3f2fa2/fonttools-4.63.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:032038247a96c1690f9f31e377c389383c902531b085aa4e4dabd6f57f870e69", size = 5042799, upload-time = "2026-05-14T12:02:50.424Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/7c/8b96c3263b89ef99cded544c0f0636686f85dbd3c211c4dceef0231fca23/fonttools-4.63.0-cp310-cp310-win32.whl", hash = "sha256:a8b33a82979e0a6a34ff435cc81317be1f95ec1ebb7a3a2d1c8a6a54f02ae44e", size = 1519704, upload-time = "2026-05-14T12:02:52.523Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/4d/2c2f0069970b6907de8fb5b05c5c0193cc22f717df151d1c7aef1c738f58/fonttools-4.63.0-cp310-cp310-win_amd64.whl", hash = "sha256:0c18358a155d75034911c5ee397a5b44cd19dd325dbb8b35fb60bf421d6a72ac", size = 1568666, upload-time = "2026-05-14T12:02:54.917Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" },
+    { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" },
+    { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" },
+    { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" },
+    { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" },
+    { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" },
+    { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/4a/557715d5047da48d54e659203b9335be7bfaafda2c3f627b7c47e0b3aaf3/frozenlist-1.8.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011", size = 86230, upload-time = "2025-10-06T05:35:23.699Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/fb/c85f9fed3ea8fe8740e5b46a59cc141c23b842eca617da8876cfce5f760e/frozenlist-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565", size = 49621, upload-time = "2025-10-06T05:35:25.341Z" },
+    { url = "https://files.pythonhosted.org/packages/63/70/26ca3f06aace16f2352796b08704338d74b6d1a24ca38f2771afbb7ed915/frozenlist-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad", size = 49889, upload-time = "2025-10-06T05:35:26.797Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ed/c7895fd2fde7f3ee70d248175f9b6cdf792fb741ab92dc59cd9ef3bd241b/frozenlist-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2", size = 219464, upload-time = "2025-10-06T05:35:28.254Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/83/4d587dccbfca74cb8b810472392ad62bfa100bf8108c7223eb4c4fa2f7b3/frozenlist-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186", size = 221649, upload-time = "2025-10-06T05:35:29.454Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c6/fd3b9cd046ec5fff9dab66831083bc2077006a874a2d3d9247dea93ddf7e/frozenlist-1.8.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e", size = 219188, upload-time = "2025-10-06T05:35:30.951Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/80/6693f55eb2e085fc8afb28cf611448fb5b90e98e068fa1d1b8d8e66e5c7d/frozenlist-1.8.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450", size = 231748, upload-time = "2025-10-06T05:35:32.101Z" },
+    { url = "https://files.pythonhosted.org/packages/97/d6/e9459f7c5183854abd989ba384fe0cc1a0fb795a83c033f0571ec5933ca4/frozenlist-1.8.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef", size = 236351, upload-time = "2025-10-06T05:35:33.834Z" },
+    { url = "https://files.pythonhosted.org/packages/97/92/24e97474b65c0262e9ecd076e826bfd1d3074adcc165a256e42e7b8a7249/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4", size = 218767, upload-time = "2025-10-06T05:35:35.205Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/bf/dc394a097508f15abff383c5108cb8ad880d1f64a725ed3b90d5c2fbf0bb/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff", size = 235887, upload-time = "2025-10-06T05:35:36.354Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/25b201b9c015dbc999a5baf475a257010471a1fa8c200c843fd4abbee725/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c", size = 228785, upload-time = "2025-10-06T05:35:37.949Z" },
+    { url = "https://files.pythonhosted.org/packages/84/f4/b5bc148df03082f05d2dd30c089e269acdbe251ac9a9cf4e727b2dbb8a3d/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f", size = 230312, upload-time = "2025-10-06T05:35:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/db/4b/87e95b5d15097c302430e647136b7d7ab2398a702390cf4c8601975709e7/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7", size = 217650, upload-time = "2025-10-06T05:35:40.377Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/70/78a0315d1fea97120591a83e0acd644da638c872f142fd72a6cebee825f3/frozenlist-1.8.0-cp310-cp310-win32.whl", hash = "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a", size = 39659, upload-time = "2025-10-06T05:35:41.863Z" },
+    { url = "https://files.pythonhosted.org/packages/66/aa/3f04523fb189a00e147e60c5b2205126118f216b0aa908035c45336e27e4/frozenlist-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6", size = 43837, upload-time = "2025-10-06T05:35:43.205Z" },
+    { url = "https://files.pythonhosted.org/packages/39/75/1135feecdd7c336938bd55b4dc3b0dfc46d85b9be12ef2628574b28de776/frozenlist-1.8.0-cp310-cp310-win_arm64.whl", hash = "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e", size = 39989, upload-time = "2025-10-06T05:35:44.596Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/a1/ae4e3e5003468d6391d2c77b6fa1cd73bd5d13511d81c642d7b28ac90ed4/fsspec-2026.6.0.tar.gz", hash = "sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a", size = 313646, upload-time = "2026-06-16T01:57:28.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl", hash = "sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1", size = 203949, upload-time = "2026-06-16T01:57:26.358Z" },
+]
+
+[[package]]
+name = "ghp-import"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
+]
+
+[[package]]
+name = "greenlet"
+version = "3.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e2/f1/fbbfef6af0bad0548f09bc28948ea3c275b4edb19e17fc5ca9900a6a634d/greenlet-3.5.3.tar.gz", hash = "sha256:a61efc018fd3eb317eeca31aba90ee9e7f26f22884a79b6c6ec715bf71bb62f1", size = 200270, upload-time = "2026-06-26T19:28:24.832Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/a1/1f7f0c555f5858fd2906fe9f7b0a3554fddb85cb70df7a6aaec41dc292c2/greenlet-3.5.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:c180d22d325fb613956b443c3c6f4406eb70e6defc70d3974da2a7b59e06f48c", size = 285838, upload-time = "2026-06-26T18:21:05.167Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/29/be9f43ed61677a5759b38c8a9389248133c8c731bbfc0574ecdff66c99fc/greenlet-3.5.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:483d08c11181c83a6ce1a7a61df0f624a208ec40817a3bb2302714592eee4f04", size = 602342, upload-time = "2026-06-26T19:07:06.908Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/42/ba41c97ec36aa4b3ec25e5aa691d79561254805fad7f2f826dd6770587e2/greenlet-3.5.3-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1dae6e0091eae084317e411f047f0b7cb241c6db570f7c45fd6b900a274914ce", size = 615541, upload-time = "2026-06-26T19:10:04.909Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/8c/231ca675b0df779816950ca66b40b1fa14dbff4a0ed9814a9a29ec399140/greenlet-3.5.3-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0f6ff50ff8dbd51fae9b37f4101648b04ea0df19b3f50ab2beb5061e7716a5c8", size = 622473, upload-time = "2026-06-26T19:24:12.786Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c7/28747042e1df8a9cd120a1ebe15529fc4be3b486e13e8d551ff307a82412/greenlet-3.5.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcd2d72ccd70a1ec68ba6ef93e7fbb4420ef9997dabc7010d893bd4015e0bec", size = 615675, upload-time = "2026-06-26T18:32:14.444Z" },
+    { url = "https://files.pythonhosted.org/packages/81/fe/dd97c483a3ff82849196ccd07851600edd3ac9de74669ca8a6022ada9ea1/greenlet-3.5.3-cp310-cp310-manylinux_2_39_riscv64.whl", hash = "sha256:37bf9c538f5ae6e63d643f88dec37c0c83bdf0e2ebc62961dedcf458822f7b71", size = 418421, upload-time = "2026-06-26T19:25:34.503Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a8/b85525a6c8fba9f009a5f7c8df1545de8fb0f0bf3e0179194ef4e500317f/greenlet-3.5.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:73f152c895e09907e0dbe24f6c2db37beb085cd63db91c3825a0fcd0064124a8", size = 1575057, upload-time = "2026-06-26T19:09:00.264Z" },
+    { url = "https://files.pythonhosted.org/packages/03/79/fb76edb218fe6735ab0edeba176c7ab80df9618f7c02ce4208979f3ae7db/greenlet-3.5.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8bdb43e1a1d1873721acab2be99c5befd4d2044ddfd52e4d610801019880a702", size = 1641692, upload-time = "2026-06-26T18:31:41.454Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/79/86fe3ee50ed55d9b3907eecd3208b5c3fe8a79515519aae98b4753c3fa1d/greenlet-3.5.3-cp310-cp310-win_amd64.whl", hash = "sha256:0909f9355a9f24845d3299f3112e266a06afb68302041989fd26bd68894933db", size = 238742, upload-time = "2026-06-26T18:20:40.758Z" },
+    { url = "https://files.pythonhosted.org/packages/51/58/5404031044f55afad7aad1aff8be3f22b1bed03e237cfeabbc7e5c8cfde0/greenlet-3.5.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:aca9b4ce85b152b5524ef7d88170efdff80dc0032aa8b75f9aaf7f3479ea95b4", size = 287424, upload-time = "2026-06-26T18:20:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/bf/1c65e9b94a54d547068fa5b5a8a06f221f3316b48908e08668d29c77cb50/greenlet-3.5.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f71be4920368fe1fabeeaa53d1e3548337e2b223d9565f8ad5e392a75ba23fc", size = 606523, upload-time = "2026-06-26T19:07:08.859Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/c7/b66baacc95775ad511287acb0137b95574a9ce5491902372b7564799d790/greenlet-3.5.3-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d77e67f65f98449e3fb83f795b5d0a8437aead2f874ca89c96576caf4be3af6", size = 618315, upload-time = "2026-06-26T19:10:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/a0/68afd1ebad40db87dac0a28ffa120726b98bf9c7c40c481b0f63c105d298/greenlet-3.5.3-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e18619ba655ac05d78d80fc83cac4ba892bd6927b99e3b8237aee861aaacc8bb", size = 626155, upload-time = "2026-06-26T19:24:14.44Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2b/28ed29463522fdbe4c15b1f63922041626a7478316b34ab4adda3f0a4aba/greenlet-3.5.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8540f1e6205bd13ca0ce685581037219ca54a1b41a0a15d228c6c9b8ad5903d7", size = 617381, upload-time = "2026-06-26T18:32:16.077Z" },
+    { url = "https://files.pythonhosted.org/packages/07/7f/e327d912239ec4b3b49999e3967389bcf1ee8722b9ee9194d2752ecd558a/greenlet-3.5.3-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:d27c0c653a60d9535f690226474a5cc1036a8b0d7b57504d1c4f89c44a07a80c", size = 421083, upload-time = "2026-06-26T19:25:35.804Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7b/ad04e9d1337fc04965dc9fc616b6a72cb65a24b800a014c011ec812f5489/greenlet-3.5.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ef56fe650f50575bf843acde967b9c567687f3c22340941a899b7bc56e956a8", size = 1577771, upload-time = "2026-06-26T19:09:01.537Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/33/6c87ab7ba663f70ca21f3022aad1ffe56d3f3e0521e836c2415e13abcc3c/greenlet-3.5.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5121af01cf911e70056c00d4b46d5e9b5d1415550038573d744138bacb59e6b8", size = 1644048, upload-time = "2026-06-26T18:31:42.996Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/35/f0d8ee998b422cf8693b270f098e55d8d4ec8006b061b333f54f177d28d9/greenlet-3.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:0f41e4a05a3c0cb31b17023eff28dd111e1d16bf7d7d00406cd7df23f31398a7", size = 239137, upload-time = "2026-06-26T18:23:21.664Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/96/b9820295576ef18c9edc404f10e260ae7215ceaf3781a54b720ed2627862/greenlet-3.5.3-cp311-cp311-win_arm64.whl", hash = "sha256:ec6f1af59f6b5f3fc9678e2ea062d8377d22ac644f7844cb7a292910cf12ff44", size = 237630, upload-time = "2026-06-26T18:24:00.281Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6e/4c37d51a2b7f82d2ff11bb6b5f7d766d9a011726624af255e843727627a3/greenlet-3.5.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:719757059f5a53fd0dde23f78cffeafcdd97b21c850ddb7ca684a3c1a1f122e2", size = 288685, upload-time = "2026-06-26T18:22:08.977Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/73/815dd90131c1b71ebdf53dbc7c276cafec2a1173b97559f97aba72724a87/greenlet-3.5.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:efa9f765dd09f9d0cdac651ffdf631ee59ec5dc6ee7a73e0c012ba9c52fbdf5b", size = 604761, upload-time = "2026-06-26T19:07:10.114Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/57/079cfe76bcef36b153b25607ee91c6fcb58f17f8b23c86bbbeabe0c88d72/greenlet-3.5.3-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7faba15ac005376e02a0384504e0243be3370ce010296a44a820feb342b505ab", size = 617044, upload-time = "2026-06-26T19:10:07.25Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/fb/d97dc261209c80744b7c8132693a30d70ec6e7315e632cb0a10b3fec94dd/greenlet-3.5.3-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5795cd1101371140551c645f2d408b8d3c01a5a29cf8a9bce6e759c983682d23", size = 622351, upload-time = "2026-06-26T19:24:16.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/87/b4d095775a3fb1bcafbb483fc206b27ebb785724c83051447737085dc54e/greenlet-3.5.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:87142215824be6ac05e2e8e2786eec307ccbc27c36723c3881959df654af6861", size = 614244, upload-time = "2026-06-26T18:32:17.594Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/e5fee13cbbd0e8de312d9a146584b8a51891c68847330ef9dc8b5109d23f/greenlet-3.5.3-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:af4923b3096e26a36d7e9cf24ab88083a20f97d191e3b97f253731ce9b41b28c", size = 425395, upload-time = "2026-06-26T19:25:37.144Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/70/7559b609683650fa2b95b8ab84b4ab0b26556a635d19675e12aa832d826d/greenlet-3.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:215275b1b49320987352e6c1b054acca0064f965a2c66992bed9a6f7d913f149", size = 1574210, upload-time = "2026-06-26T19:09:03.077Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/73/be55392074c60fc37655ca40fa6022457bfbf6718e9e342a7b0b41f96dd2/greenlet-3.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6b1b0eed82364b0e32c4ea0f221452d33e6bb17ae094d9f72aed9851812747ea", size = 1638627, upload-time = "2026-06-26T18:31:44.748Z" },
+    { url = "https://files.pythonhosted.org/packages/14/40/c57489acf8e37d74e2913d4eff63aa0dba17acccc4bdeef874dde2dbbec9/greenlet-3.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:cde8adafa2365676f74a979744629589999093bc86e2484214f58e61df08902c", size = 239882, upload-time = "2026-06-26T18:23:27.518Z" },
+    { url = "https://files.pythonhosted.org/packages/71/fd/6fea0e3d6600f785069481ee637e09378dd4118acdfd38ad88ae2db31c98/greenlet-3.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:c4e7b79d83805475f0102008843f6eb45fd3bb0b2e88c774adab5fbaab27117d", size = 238211, upload-time = "2026-06-26T18:22:37.671Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ff/a620267401db30a50cc8450ee90730e2d4a85658c055c0e760d4ed47fb13/greenlet-3.5.3-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:c8d87c2134d871df96ecdea9cec7cbaab286dadab0f56476e57aaf9e8ac11550", size = 287609, upload-time = "2026-06-26T18:21:14.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fa/5401ac78021c826a25b6dde0c705e0a8f29b617509f9185a31dac15fbe1b/greenlet-3.5.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2d185dd1621757e70c3861cceffd5317ab4e7ed7eb09c82994828468527ade5", size = 607435, upload-time = "2026-06-26T19:07:11.412Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/76/1dc144a2e56e65d36405078ed774224375ea520a1870a6e46e08bb4ac7bf/greenlet-3.5.3-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1c514a468149bf8fbbab874188a3535cd8a48a3e353eb53a3d424296f8dbacd3", size = 619787, upload-time = "2026-06-26T19:10:08.396Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/2f5b1adf256d039f5dab8005de8d3d7ad2b0070a3219c0e036b3fbfeb440/greenlet-3.5.3-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9ad04dd75458c6300b047c61b8639092433d205a25a14e310d6582a480efcca1", size = 625580, upload-time = "2026-06-26T19:24:18.344Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/87/c298cee62df1de4ad7fec32abda73526cff347fd143a6ed4ac369246668a/greenlet-3.5.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:915f887cf2682b66419b879423a2e072634aa7b7dce6f3ada4957cfced3f1e9a", size = 616786, upload-time = "2026-06-26T18:32:19.128Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/ab7fc9e543e44d6879b0a6ef9a4b2188940fd180cc65d6f646883ddf7201/greenlet-3.5.3-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:afaabdd554cd7ae9bbb3ca070b0d7fdfd207dbf1d16865f7233837709d354bda", size = 427933, upload-time = "2026-06-26T19:25:38.219Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/2e/e6f009885ed0705ccf33fe0583c117cfd03cde77e31a596dd5785a30762b/greenlet-3.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:766cfd421c13e450feb340cd472a3ed9957d438727b7b4593ad7c76c5d2b0deb", size = 1574316, upload-time = "2026-06-26T19:09:04.273Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fe/43fd110b01e40da0adb7c90ac7ea744bef2d43dca00de5095fd2351c2a68/greenlet-3.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2ecda9ec22edf38fa389369eaed8c3d37c05f3c54e69f69438dbb2cc1de1458b", size = 1638614, upload-time = "2026-06-26T18:31:46.297Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/7c/062447147a61f8b4337b156fe70d32a165fcf2f89d7ca6255e572806705c/greenlet-3.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:c82304750f057167ff60d188df1d0cc1764ce9567eadf03e6a7443bcedd0b30b", size = 239850, upload-time = "2026-06-26T18:21:54.613Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7e/220a7f5824a64a60443fc03b39dfac4ea63a7fb6d481efa27eafa928e7f4/greenlet-3.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:dc133a1569ee667b2a6ef56ce551084aeefd87a5acbc4736d336d1e2edc6cfc4", size = 238141, upload-time = "2026-06-26T18:22:48.507Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.82.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/bc/656b89387d6f4ed7e0686c7b64c2ae7e554a759aa58122c8e5fb99392c32/grpcio-1.82.1.tar.gz", hash = "sha256:707b24abd90fcb1e45bcc080577da1dbf9971d107490589b9539af8e1e77b4b5", size = 13187300, upload-time = "2026-07-08T12:36:16.588Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/14/5d05bfd85c101cbe44a12d7c1cea9c40698e0438cddf3a70019f735b5a27/grpcio-1.82.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:91859d1cac5f47caec5fc40e9f827500cdb54ce5b36450dc9a65616b5af49c17", size = 6177087, upload-time = "2026-07-08T12:34:06.825Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2e/c906f8e6d0b54c0137885fff6f7b5883c6bbc381b44a0ba5ea07d7d1579b/grpcio-1.82.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:c80c9741dcef192f669876a81957cf7713b441c2f0c43631350d75fa49321d31", size = 11960907, upload-time = "2026-07-08T12:34:10.583Z" },
+    { url = "https://files.pythonhosted.org/packages/de/be/ec4aa76cdf25539b9e960cbb9d5739f892ea6cde58078b5293860c1159d3/grpcio-1.82.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b89cff456796d2f0581783726ad017a2c70aff2d27b0f05504c34e2e417f7560", size = 6754802, upload-time = "2026-07-08T12:34:13.082Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/dd/47519c2a8fd9db47ec4493f44bd9f5b0175307e07089b1132e54b7b5b19c/grpcio-1.82.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d6e8a08f7038ba7a77f71e250804e4aba84fe91d22cfc54ff43c07b7529c4728", size = 7484535, upload-time = "2026-07-08T12:34:15.164Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/659711e9689c4dd553bcd4eacff9cb9f458f34b60edf7afb3bbc1b0a58a2/grpcio-1.82.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:50fd2fe83426b1b1c6cdc4d72d555223b7dddf8ce07c5bac218b13fc6d684c6f", size = 6919066, upload-time = "2026-07-08T12:34:17.367Z" },
+    { url = "https://files.pythonhosted.org/packages/29/39/f2b772356b4f593ffe439795509fcbf675b0ff98211ae8ce2a180f2e559f/grpcio-1.82.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b758540a24d5394a9c578bf9f6126389f474b106ac3d9df1d53de56cb14c9fd9", size = 7525855, upload-time = "2026-07-08T12:34:19.479Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/b28cfffb989a84d8272593498bddd2d68148cce1813ad55189c469b0f1f8/grpcio-1.82.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:c4ba4aac238f685743575d9d700003ac16537cce26e7c774993134f530652464", size = 8565122, upload-time = "2026-07-08T12:34:21.951Z" },
+    { url = "https://files.pythonhosted.org/packages/97/f9/54956cb0c701190cbc9d7e535c3f84acf0285c6b9ed198a902766e17c3cd/grpcio-1.82.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ed6fc621d6f366c88a60f0b971d5afd21d441d9aa561ee688de5b7acdb2cf901", size = 7933872, upload-time = "2026-07-08T12:34:24.539Z" },
+    { url = "https://files.pythonhosted.org/packages/76/85/5f9cd1f965bbe4329556a212f178ae0c072b18b446cae05ed32fa8847c53/grpcio-1.82.1-cp310-cp310-win32.whl", hash = "sha256:bd2f45e46fff5b91c10997d0743a987517a7dde67c64c592835c2dcaac66f587", size = 4257373, upload-time = "2026-07-08T12:34:26.566Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b0/c4f42f7c69c53d27ed41643421b55908bcbe885b68f5a208135c72917c98/grpcio-1.82.1-cp310-cp310-win_amd64.whl", hash = "sha256:5e171d5f0d6a0af78ea7512783f170a44f80c165259d8773e3a354a7f991f2b5", size = 5006571, upload-time = "2026-07-08T12:34:28.778Z" },
+    { url = "https://files.pythonhosted.org/packages/26/5b/e5092af97fa671ca279b3e373251af4bf87d5fbda7dc85f6a616899562a7/grpcio-1.82.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:0ddb18a9a9e1f46692b3567ae4abb3f8d117ce6afea48650f8eca06d8ab5d06f", size = 6181472, upload-time = "2026-07-08T12:34:31.009Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/18053a3a2ca03d0c2a1b8cc7271e705007a16aa5dae84bac00935c5b1a7f/grpcio-1.82.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:cf855b1af246720f567b0ce5d0724d45dfa4188eecc3296a2a69257b11b9e94b", size = 11970995, upload-time = "2026-07-08T12:34:33.603Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/21b1acb052876ad00959ec4d1b05fe08607d650bcfa282073bb164c2703c/grpcio-1.82.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb30cb13e25bc13cea70ffc69d6d90c49d36ea6c1d4549e6912f70177834cac", size = 6760127, upload-time = "2026-07-08T12:34:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/12/25eef9c245c54f0061317d13a302357fe8ea03bac240b2b02ececcf54da4/grpcio-1.82.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1e822b2774f719c017cbe700b6e47173b6ae290fb84906f52a5a3c2c60b62e1e", size = 7484377, upload-time = "2026-07-08T12:34:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/41/1a348767eb9d9bd7765dc4fa8a01723d3bb386d67f981ee5c6f9c02b8b1c/grpcio-1.82.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5dafb1ece8ed45dee7c738f166ec82e19673221ed5ab8967f72858a4685345b2", size = 6924269, upload-time = "2026-07-08T12:34:40.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/b9/3aae7a03d34c86ea27988db859a6087c186f6c3f53f9b551e07afd989bfa/grpcio-1.82.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e06503106e7271e0a49fd5a1ac04747f1e47e87d900476db6fe45bc87ee411f4", size = 7531848, upload-time = "2026-07-08T12:34:43.277Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/3c4afa625d0dac9090707966916284c035fc5b2fb3e2c51e156accee6735/grpcio-1.82.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ff99bc8cafb6a952201c37b995f425e641c93ffa6e072258525feab57290141d", size = 8568217, upload-time = "2026-07-08T12:34:45.502Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/d8489c628e73e20a3d034e7f66912de7b1acb405f01d388f056a88e47924/grpcio-1.82.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:644ae1b94266ac785330f4590a69e52b6a7eb73029043a02209db81c81397d69", size = 7938771, upload-time = "2026-07-08T12:34:48.323Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/b7/0a92cfd1658f3a896d4aa12d4efeb7dd4ddfc723725ae22741a5241ea710/grpcio-1.82.1-cp311-cp311-win32.whl", hash = "sha256:e203d2e19d471630084a16c815616f8211dff21c268ab3c5f5bf38417832e074", size = 4256432, upload-time = "2026-07-08T12:34:50.432Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/6a/2872c761b025d9ec74386f22a4a7d59c5a5b00ebf718761b33739ffc45de/grpcio-1.82.1-cp311-cp311-win_amd64.whl", hash = "sha256:0d8299c285fe6cc6a1f56badf8d3bc5078c8d20273ee64bafa3783b4bc29a769", size = 5009633, upload-time = "2026-07-08T12:34:52.67Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/88/d1350bf3343a2ed87d801584e40609f6c6bd3087926eeca03de50348cf4a/grpcio-1.82.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:c09bd5fa0d5b1fbd773ec349fe61441c3e4ebf168c229aa7538a820bdfad6a58", size = 6144689, upload-time = "2026-07-08T12:34:55.567Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/33/71875cdecd27c24ac1385d4783a09853f01b84a825a36aec2a2bc7d0d080/grpcio-1.82.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:1eae24810720734598e3e6a1a528d5de0f265fe3fc86575e9ecce424b9ec7379", size = 11952034, upload-time = "2026-07-08T12:34:58.128Z" },
+    { url = "https://files.pythonhosted.org/packages/82/b2/d9125df3d8a140dec12cc82c05b7deafedeababcff6496f28b2fd5634d10/grpcio-1.82.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a6bd5daf5bde7b24d7ad2cbaf8bf9eac620d96222016bb5e7ddde930dec0673f", size = 6710772, upload-time = "2026-07-08T12:35:01.33Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9b/69e2d1627398b964f34437dc476a5aff5a2cc8e7f247d26272b5674b5faf/grpcio-1.82.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1ecfde669cb687ac020d31ff76debe5dc7a62213335f02262eb6625628da1c03", size = 7450677, upload-time = "2026-07-08T12:35:03.926Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e7/8f855ca29c294956122a2a73023655b9b02602d5111dad2b9b00e7631c68/grpcio-1.82.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:011c8badee95734dee8bf05ce3464756a0ac3ebb8d443afd20c0e2b5e4640ad9", size = 6886855, upload-time = "2026-07-08T12:35:06.174Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f0/fa87e85f49925f44c479d07e58b051e69bcfef6b6d5fbc6749d140f6730a/grpcio-1.82.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b85f4564926fb23114d239392bdcae200db1e6179629edd7d7ab0ab89c96a197", size = 7501323, upload-time = "2026-07-08T12:35:08.49Z" },
+    { url = "https://files.pythonhosted.org/packages/67/55/2e0b10ae1d3ef9dcc480b91dc2158f4931fc4675d3af0a2836e39b2a744f/grpcio-1.82.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:2c0c8270833395644c3fe6b6a806397955a2bc0538000a19a78b90c05a6c16e0", size = 8536899, upload-time = "2026-07-08T12:35:10.975Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/95/a3d8b0431fa221efc51ee39d73595ede74ba82a43b7c4313192e580face2/grpcio-1.82.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2ba199205ff46c7778290fe1673c91ac8e7e45678dd5c86e9e56fa33ec8788f6", size = 7913892, upload-time = "2026-07-08T12:35:13.944Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/92/f2651ec704d9852a56faef394775038afba435b50ce82ab2404d119c3355/grpcio-1.82.1-cp312-cp312-win32.whl", hash = "sha256:06127691866e295c14e84a1fb86356dd962254f6abd0da4ca4b001eea9e89438", size = 4240985, upload-time = "2026-07-08T12:35:16.048Z" },
+    { url = "https://files.pythonhosted.org/packages/96/4f/a5fe8bf0d0a1b24855f370293075c931f27de4eb55f0f158786095bf3c11/grpcio-1.82.1-cp312-cp312-win_amd64.whl", hash = "sha256:1fa3223a3a2e1db74f4c2b255189eb7ea875dfba56e221d252ee3fc7b204778e", size = 5001580, upload-time = "2026-07-08T12:35:18.689Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/3e/496992d08c0aaa11272eb6228dc8ab947da01fe835de243cd00521bce4c4/grpcio-1.82.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:b454a2d97bfab7565683a02345f86bd182ab69fd7c2bdb7414171e7538f266b1", size = 6146068, upload-time = "2026-07-08T12:35:21.365Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/8f/f263d6f14fdba6b56cfadd91fd3e158a52682b72c6016d1f8723d435659f/grpcio-1.82.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:3dde70abfc80b3be11de53ba0d601c439e7fb2afd3583ad1788d1146bec92fdc", size = 11948600, upload-time = "2026-07-08T12:35:24.312Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/14/3a02e6ee49c2d85bc15eaae321e0e11ab3542cad3c5b2de121ecce0c4296/grpcio-1.82.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f5523099c98c292ea1ae08e617249db760c56a78f8deae879027fe7d1ffbcbf6", size = 6714591, upload-time = "2026-07-08T12:35:27.027Z" },
+    { url = "https://files.pythonhosted.org/packages/69/80/58e3738696f48ab7645347b98d8a7f93d10e00e6218388fbfcd6c9310e3d/grpcio-1.82.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:5e5c4dc0a59b0f8490a6bdfd6fc8395b9d8ad8a8407c7d67ca7b5bba15c0877f", size = 7454995, upload-time = "2026-07-08T12:35:29.599Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6c/2557c1a889363072fbf2285ecd0e8c44860d4dbd60f017a32537c5b863e2/grpcio-1.82.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c40d94ba820329cc191981bc22fa6f6eed0799c6d921f3c6709521d59d4a2fd7", size = 6888621, upload-time = "2026-07-08T12:35:32.38Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/66/907706ccaff1223f1e10fd5b37fc16faead43392fccb4e786e7e390ac141/grpcio-1.82.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4c816180e31e273caaec6f8bd86a8392499d5bbb26f41da44e3dce48bde69095", size = 7505069, upload-time = "2026-07-08T12:35:35.072Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7c/ff97b0d0f635987ee5ec80dfedafa1aad629303745d48e8637d10eec5b80/grpcio-1.82.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e31fd780b261830720cb70b0fd8f0aa51d49e75a66d7464ad2e31d4b765f2580", size = 8535384, upload-time = "2026-07-08T12:35:37.954Z" },
+    { url = "https://files.pythonhosted.org/packages/62/9e/a97fddd970a8d1588cade06eca20443761c1858b0ad6590a5c835aa18062/grpcio-1.82.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d76152d7c31d7210d4a106e5d8b64da5bba5d6abf11be30e2f7b0a0c59bbcbf", size = 7910707, upload-time = "2026-07-08T12:35:40.797Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e4/eaba1517888af483a88d449eb7566f0f7f63446d46f339c5891798435875/grpcio-1.82.1-cp313-cp313-win32.whl", hash = "sha256:38e9dcb5258226fb3282630b31b16a968df52c8c6ad514af540646e0a4578f8a", size = 4240363, upload-time = "2026-07-08T12:35:43.298Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/42/66a98d47732e35290bef722f6149fed3709cd4cf61166f6f53a12f417302/grpcio-1.82.1-cp313-cp313-win_amd64.whl", hash = "sha256:3dbfb52c36d9511ac2b8e6c94fdde837b393ae520cc321f52a333a2deedf5a90", size = 5000980, upload-time = "2026-07-08T12:35:46.262Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "h5py"
+version = "3.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.12.*'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/db/33/acd0ce6863b6c0d7735007df01815403f5589a21ff8c2e1ee2587a38f548/h5py-3.16.0.tar.gz", hash = "sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738", size = 446526, upload-time = "2026-03-06T13:49:08.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/6b/231413e58a787a89b316bb0d1777da3c62257e4797e09afd8d17ad3549dc/h5py-3.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e06f864bedb2c8e7c1358e6c73af48519e317457c444d6f3d332bb4e8fa6d7d9", size = 3724137, upload-time = "2026-03-06T13:47:35.242Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f9/557ce3aad0fe8471fb5279bab0fc56ea473858a022c4ce8a0b8f303d64e9/h5py-3.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ec86d4fffd87a0f4cb3d5796ceb5a50123a2a6d99b43e616e5504e66a953eca3", size = 3090112, upload-time = "2026-03-06T13:47:37.634Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/e15b3d0dc8a18e56409a839e6468d6fb589bc5207c917399c2e0706eeb44/h5py-3.16.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:86385ea895508220b8a7e45efa428aeafaa586bd737c7af9ee04661d8d84a10d", size = 4844847, upload-time = "2026-03-06T13:47:39.811Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/92/a8851d936547efe30cc0ce5245feac01f3ec6171f7899bc3f775c72030b3/h5py-3.16.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:8975273c2c5921c25700193b408e28d6bdd0111c37468b2d4e25dcec4cd1d84d", size = 5065352, upload-time = "2026-03-06T13:47:41.489Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/ae/f2adc5d0ca9626db3277a3d87516e124cbc5d0eea0bd79bc085702d04f2c/h5py-3.16.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1677ad48b703f44efc9ea0c3ab284527f81bc4f318386aaaebc5fede6bbae56f", size = 4839173, upload-time = "2026-03-06T13:47:43.586Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0b/e0c8c69da1d8838da023a50cd3080eae5d475691f7636b35eff20bb6ef20/h5py-3.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c4dd4cf5f0a4e36083f73172f6cfc25a5710789269547f132a20975bfe2434c", size = 5076216, upload-time = "2026-03-06T13:47:45.315Z" },
+    { url = "https://files.pythonhosted.org/packages/66/35/d88fd6718832133c885004c61ceeeb24dbd6397ef877dbed6b3a64d6a286/h5py-3.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:bdef06507725b455fccba9c16529121a5e1fbf56aa375f7d9713d9e8ff42454d", size = 3183639, upload-time = "2026-03-06T13:47:47.041Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/95/a825894f3e45cbac7554c4e97314ce886b233a20033787eda755ca8fecc7/h5py-3.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:719439d14b83f74eeb080e9650a6c7aa6d0d9ea0ca7f804347b05fac6fbf18af", size = 3721663, upload-time = "2026-03-06T13:47:49.599Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3b/38ff88b347c3e346cda1d3fc1b65a7aa75d40632228d8b8a5d7b58508c24/h5py-3.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c3f0a0e136f2e95dd0b67146abb6668af4f1a69c81ef8651a2d316e8e01de447", size = 3087630, upload-time = "2026-03-06T13:47:51.249Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a8/2594cef906aee761601eff842c7dc598bea2b394a3e1c00966832b8eeb7c/h5py-3.16.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a6fbc5367d4046801f9b7db9191b31895f22f1c6df1f9987d667854cac493538", size = 4823472, upload-time = "2026-03-06T13:47:53.085Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a0/c1f604538ff6db22a0690be2dc44ab59178e115f63c917794e529356ab23/h5py-3.16.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:fb1720028d99040792bb2fb31facb8da44a6f29df7697e0b84f0d79aff2e9bd3", size = 5027150, upload-time = "2026-03-06T13:47:55.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/fd/301739083c2fc4fd89950f9bcfce75d6e14b40b0ca3d40e48a8993d1722c/h5py-3.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:314b6054fe0b1051c2b0cb2df5cbdab15622fb05e80f202e3b6a5eee0d6fe365", size = 4814544, upload-time = "2026-03-06T13:47:56.893Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/42/2193ed41ccee78baba8fcc0cff2c925b8b9ee3793305b23e1f22c20bf4c7/h5py-3.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ffbab2fedd6581f6aa31cf1639ca2cb86e02779de525667892ebf4cc9fd26434", size = 5034013, upload-time = "2026-03-06T13:47:59.01Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/20/e6c0ff62ca2ad1a396a34f4380bafccaaf8791ff8fccf3d995a1fc12d417/h5py-3.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:17d1f1630f92ad74494a9a7392ab25982ce2b469fc62da6074c0ce48366a2999", size = 3191673, upload-time = "2026-03-06T13:48:00.626Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/48/239cbe352ac4f2b8243a8e620fa1a2034635f633731493a7ff1ed71e8658/h5py-3.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b9c49dd58dc44cf70af944784e2c2038b6f799665d0dcbbc812a26e0faa859", size = 2673834, upload-time = "2026-03-06T13:48:02.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c0/5d4119dba94093bbafede500d3defd2f5eab7897732998c04b54021e530b/h5py-3.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5313566f4643121a78503a473f0fb1e6dcc541d5115c44f05e037609c565c4d", size = 3685604, upload-time = "2026-03-06T13:48:04.198Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/42/c84efcc1d4caebafb1ecd8be4643f39c85c47a80fe254d92b8b43b1eadaf/h5py-3.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:42b012933a83e1a558c673176676a10ce2fd3759976a0fedee1e672d1e04fc9d", size = 3061940, upload-time = "2026-03-06T13:48:05.783Z" },
+    { url = "https://files.pythonhosted.org/packages/89/84/06281c82d4d1686fde1ac6b0f307c50918f1c0151062445ab3b6fa5a921d/h5py-3.16.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:ff24039e2573297787c3063df64b60aab0591980ac898329a08b0320e0cf2527", size = 5198852, upload-time = "2026-03-06T13:48:07.482Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/1a19e42cd43cc1365e127db6aae85e1c671da1d9a5d746f4d34a50edb577/h5py-3.16.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:dfc21898ff025f1e8e67e194965a95a8d4754f452f83454538f98f8a3fcb207e", size = 5405250, upload-time = "2026-03-06T13:48:09.628Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8e/9790c1655eabeb85b92b1ecab7d7e62a2069e53baefd58c98f0909c7a948/h5py-3.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:698dd69291272642ffda44a0ecd6cd3bda5faf9621452d255f57ce91487b9794", size = 5190108, upload-time = "2026-03-06T13:48:11.26Z" },
+    { url = "https://files.pythonhosted.org/packages/51/d7/ab693274f1bd7e8c5f9fdd6c7003a88d59bedeaf8752716a55f532924fbb/h5py-3.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2b2c02b0a160faed5fb33f1ba8a264a37ee240b22e049ecc827345d0d9043074", size = 5419216, upload-time = "2026-03-06T13:48:13.322Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c1/0976b235cf29ead553e22f2fb6385a8252b533715e00d0ae52ed7b900582/h5py-3.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:96b422019a1c8975c2d5dadcf61d4ba6f01c31f92bbde6e4649607885fe502d6", size = 3182868, upload-time = "2026-03-06T13:48:15.759Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d9/866b7e570b39070f92d47b0ff1800f0f8239b6f9e45f02363d7112336c1f/h5py-3.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:39c2838fb1e8d97bcf1755e60ad1f3dd76a7b2a475928dc321672752678b96db", size = 2653286, upload-time = "2026-03-06T13:48:17.279Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/9e/6142ebfda0cb6e9349c091eae73c2e01a770b7659255248d637bec54a88b/h5py-3.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:370a845f432c2c9619db8eed334d1e610c6015796122b0e57aa46312c22617d9", size = 3671808, upload-time = "2026-03-06T13:48:19.737Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/65/5e088a45d0f43cd814bc5bec521c051d42005a472e804b1a36c48dada09b/h5py-3.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42108e93326c50c2810025aade9eac9d6827524cdccc7d4b75a546e5ab308edb", size = 3045837, upload-time = "2026-03-06T13:48:21.854Z" },
+    { url = "https://files.pythonhosted.org/packages/da/1e/6172269e18cc5a484e2913ced33339aad588e02ba407fafd00d369e22ef3/h5py-3.16.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:099f2525c9dcf28de366970a5fb34879aab20491589fa89ce2863a84218bb524", size = 5193860, upload-time = "2026-03-06T13:48:24.071Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/98/ef2b6fe2903e377cbe870c3b2800d62552f1e3dbe81ce49e1923c53d1c5c/h5py-3.16.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9300ad32dea9dfc5171f94d5f6948e159ed93e4701280b0f508773b3f582f402", size = 5400417, upload-time = "2026-03-06T13:48:25.728Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/81/5b62d760039eed64348c98129d17061fdfc7839fc9c04eaaad6dee1004e4/h5py-3.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:171038f23bccddfc23f344cadabdfc9917ff554db6a0d417180d2747fe4c75a7", size = 5185214, upload-time = "2026-03-06T13:48:27.436Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c4/532123bcd9080e250696779c927f2cb906c8bf3447df98f5ceb8dcded539/h5py-3.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7e420b539fb6023a259a1b14d4c9f6df8cf50d7268f48e161169987a57b737ff", size = 5414598, upload-time = "2026-03-06T13:48:29.49Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d9/a27997f84341fc0dfcdd1fe4179b6ba6c32a7aa880fdb8c514d4dad6fba3/h5py-3.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:18f2bbcd545e6991412253b98727374c356d67caa920e68dc79eab36bf5fedad", size = 3175509, upload-time = "2026-03-06T13:48:31.131Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/23/bb8647521d4fd770c30a76cfc6cb6a2f5495868904054e92f2394c5a78ff/h5py-3.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:656f00e4d903199a1d58df06b711cf3ca632b874b4207b7dbec86185b5c8c7d4", size = 2647362, upload-time = "2026-03-06T13:48:33.411Z" },
+]
+
+[[package]]
+name = "hf-xet"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/2d/57fd21d84d93efb4bd0b962383790e19dd1bc053501b4264c97903b4e83e/hf_xet-1.5.1.tar.gz", hash = "sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6", size = 876636, upload-time = "2026-06-08T23:02:53.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/ee/dd9ba7beae1005e54131b7d45263cc74c8a066d47d354e6d58ae9445a388/hf_xet-1.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577", size = 4069485, upload-time = "2026-06-08T23:02:13.193Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/bc/9cae6cfeb4e03070874e73e5c97c66eb90369d3206b6a2b1ef5f96520888/hf_xet-1.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43", size = 3838493, upload-time = "2026-06-08T23:02:15.282Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b4/d5c01e0eb6d9f2ca2dacd84d0d1b71e6cfbb2ef3208c968528e010e9b3d7/hf_xet-1.5.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947", size = 4505658, upload-time = "2026-06-08T23:02:17.196Z" },
+    { url = "https://files.pythonhosted.org/packages/76/c5/29a7598c0c6383c523dc22186d577f4e04267a626cd95ae60f67c00bfe66/hf_xet-1.5.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8", size = 4292822, upload-time = "2026-06-08T23:02:18.608Z" },
+    { url = "https://files.pythonhosted.org/packages/04/9a/dceaf6ca69390126b86ea825fb354b93d01163199070b7bd849225de9468/hf_xet-1.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283", size = 4491255, upload-time = "2026-06-08T23:02:20.124Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a7/e5a7afaacf6c1791fdbeeac42951fb81c3d2bc482992b115dedcc86d963e/hf_xet-1.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342", size = 4711062, upload-time = "2026-06-08T23:02:21.863Z" },
+    { url = "https://files.pythonhosted.org/packages/53/49/2802f8433c9742ce281bddc1e65c02c32268ca3098d66828b05e12e45ee2/hf_xet-1.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff", size = 4017205, upload-time = "2026-06-08T23:02:23.495Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5a/50c71195b9fb883659f596e7252faf4c18c58e753a9013bdbf9bac5d2250/hf_xet-1.5.1-cp313-cp313t-win_arm64.whl", hash = "sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d", size = 3845426, upload-time = "2026-06-08T23:02:25.124Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d8/5e54cf37434759d1f4f2ba9b66077ff9d4c4e1f37b6bd7975da5c40d94ab/hf_xet-1.5.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e", size = 4077794, upload-time = "2026-06-08T23:02:40.656Z" },
+    { url = "https://files.pythonhosted.org/packages/35/94/4b2ecfbad8f8b04701a23aefb62f540b9137d058b7e1dbef16a32676f0e9/hf_xet-1.5.1-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e", size = 3845354, upload-time = "2026-06-08T23:02:42.702Z" },
+    { url = "https://files.pythonhosted.org/packages/de/cc/f99f4bc7295023d7bd9ebbfd51f75cc530ca262c1227666268b8208f4b77/hf_xet-1.5.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350", size = 4514864, upload-time = "2026-06-08T23:02:44.497Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/6e/21f7e5a2381278bd3b7b7a5a4d90038518bb6308a0c1daf5d9f8268bb178/hf_xet-1.5.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4", size = 4303784, upload-time = "2026-06-08T23:02:46.203Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0e/f992bb6927ac1cb30ef74e62268f551f338bc32b2191f7c96a44c6f7283e/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6", size = 4500703, upload-time = "2026-06-08T23:02:47.628Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d1/90a498d05447980b977b1669246eeeeae4cfb0ea3e7a286eaba627f91bf9/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf", size = 4719498, upload-time = "2026-06-08T23:02:49.268Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b6/20f99cfe97cc663a711f7b33cc21d4793e51968e9a26125b4afcd77315ba/hf_xet-1.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5", size = 4026419, upload-time = "2026-06-08T23:02:50.829Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/fa/77453694888f03e5a8c8852d1514a0894d8e81c622d39edbaf308ea0dcf4/hf_xet-1.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e", size = 3855178, upload-time = "2026-06-08T23:02:52.452Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "0.36.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", hash = "sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a", size = 649782, upload-time = "2026-02-06T09:24:13.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270", size = 566395, upload-time = "2026-02-06T09:24:11.133Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "jiter"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/1f/10936e16d8860c70698a1aa939a46aa0224813b782bce4e000e637da0b2d/jiter-0.16.0.tar.gz", hash = "sha256:7b24c3492c5f4f84a37946ad9cf504910cf6a782d6a4e0689b6673c5894b4a1c", size = 176431, upload-time = "2026-06-29T13:05:13.657Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/d8/b959609e44012a42b1f3e5ba98ea3b33c7e41e6d4b77cd8f00fd19b1d3ad/jiter-0.16.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fc4f8def331036a7b8e981b4347ebe409981edbc8308a5ea842b8c3614fa6c", size = 310082, upload-time = "2026-06-29T13:02:31.356Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/3d/4d7f5667ea0e0548534ba880b84bb3d12924fd133aa83ad6c6c80fca3d76/jiter-0.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a71d0d2014c3275043e1170bf3d4e771493cb0dcf07be54c567155f4d8ee64b", size = 315643, upload-time = "2026-06-29T13:02:33.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/83/bed2dcb5c9f3e1ccfcbc67dda48265fe7d5ad0c9cadda5fe95f6e3b87f94/jiter-0.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:741eed508c233a76313a1c7b001f8f21b82f14327e9196ae8bd29a2cc164ae84", size = 341363, upload-time = "2026-06-29T13:02:34.853Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/2f/6bb3c3dda668ebc0445689c81a2b0f26a82b10843d67ed9c9b2c3edc177f/jiter-0.16.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3fb7bc819187b56dc48aa5c833aaf92257da8e07efdb9306156667bd2eeb491c", size = 365483, upload-time = "2026-06-29T13:02:36.295Z" },
+    { url = "https://files.pythonhosted.org/packages/92/35/8a045ccb39164e70dcdae696413b661771f148b68b12b175c3a04d901937/jiter-0.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7c9610fd25ebccb43fca584136f5c2fbb26802447eccd430dfdbab95a0fd5126", size = 461219, upload-time = "2026-06-29T13:02:38.116Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/99/22292dbbf0ed0c610cfe5ddc7f3bd67237a412f121318f865196e62a07bd/jiter-0.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4a1d68ff7ca1d3b5dee20a97a3decda7d5f15003823bf6d140c81f8561d3bc5c", size = 374905, upload-time = "2026-06-29T13:02:40.357Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ac/2f55ccb1f0eeafa6d89d24caf52f6f0944a59290ee199e9ade62177dca42/jiter-0.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb08c276dd02dac3a284acdd02cacc630d2e3cd6572a4b85519f35cbd133c3de", size = 348320, upload-time = "2026-06-29T13:02:41.923Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e3/7d88b9174c40064fabc07c84a9b62e6b10f5644562ec0e0a29392edbe978/jiter-0.16.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:8fc4d94713c4697347e38faf7d6ef91547c142219bdcfc7220c4870879974244", size = 356519, upload-time = "2026-06-29T13:02:43.436Z" },
+    { url = "https://files.pythonhosted.org/packages/27/57/c4a33aeef513a9d5e26e31534e0bcc752d6ea0e54c94ddb7b68bade669c2/jiter-0.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a0f05e229edb29e68cdd0ccb83cea13b64263416120cf943767a6fd72e6787f", size = 394204, upload-time = "2026-06-29T13:02:44.987Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/70/c6c23e76ebb3766b111bc399437bbc9f870a76e2a92e10b2a5f561d57372/jiter-0.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2c842cbf374a8daf50b2c04212995bee34ca2ac2cdc29a901b4cdb072c9c4131", size = 521477, upload-time = "2026-06-29T13:02:46.724Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d3/0001c8c0c5976af2625bb1cfb1895e8ec693b6589fe4574b8e6fc2c85501/jiter-0.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5ed466aee31294d7cdcd4d37dfe5c42c97bc29d9a5f00eacf24504358309cb9b", size = 552187, upload-time = "2026-06-29T13:02:48.144Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/76/311b718e07e85740e48619c0632b36f7e0b8d113984499e436452ed13a9a/jiter-0.16.0-cp310-cp310-win32.whl", hash = "sha256:b42e9ff5376819c053da25809a8d4b6fa6e473b4856ebe42e298ac958be3d7f9", size = 206513, upload-time = "2026-06-29T13:02:49.515Z" },
+    { url = "https://files.pythonhosted.org/packages/db/7f/ac680eeb0777dc0eb7dc824800ba27880d7f6bc712e362d34ad8ee559f36/jiter-0.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:10438939205546132189c8e74a2d536a707841f3a25cd7c74ee91fe503407a26", size = 199505, upload-time = "2026-06-29T13:02:50.829Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/3f/fae6cc967d120ec89e31c5418a51176d8278b3087fbb384a9176754f353c/jiter-0.16.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:67fddeda1688f0cce2d2ae83ccf8a80f79936f2d2997d6cc2261f82fdb54a4d3", size = 309289, upload-time = "2026-06-29T13:02:52.301Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e3/97c6c3562c077f6247d6e6ce5c82562500b6316c0d928e97e106b7a1321a/jiter-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c90c0f63df322be920eda6ce622e3083d8906ba267f8220fe7873213b8b4430e", size = 315181, upload-time = "2026-06-29T13:02:53.964Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/89/d8d073f8aa2667e46c6c0873f86fe4a512bba4293cc730f626a076211a62/jiter-0.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64c0203212098470032aabcde9356fc168f377aade3e43def61dfe17e92f2037", size = 340939, upload-time = "2026-06-29T13:02:55.412Z" },
+    { url = "https://files.pythonhosted.org/packages/87/c9/db4fda3ed73fb864139305e935e5b8b38a5a24692a5a9dd356c22f1b9c8d/jiter-0.16.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12288303c9844e61e1651d02a9a6f6633e47d39f897d6991d1427161ce6b746e", size = 364932, upload-time = "2026-06-29T13:02:57.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/74/52b5e86241057f52ddd7c9a580f90effb51f9d06239f6fc612279b91a838/jiter-0.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cf109d010b4b05a105afb3d43be36a21322d345ad3111e13d15f680afef0e5b", size = 461132, upload-time = "2026-06-29T13:02:58.994Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/87/544a700f7447c1f31c5d7833821a4daa5683165c2d5a094fbf5b5800c3dc/jiter-0.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62c1b7fe1f77925acf5af68b6140b8810fa87dfd4dc0a9c8568ec2fa2a10429c", size = 374857, upload-time = "2026-06-29T13:03:00.455Z" },
+    { url = "https://files.pythonhosted.org/packages/40/cd/0fcc3f7d39183674d5bfa9ec640faaeb506c60be7c8f94625dfba366e37c/jiter-0.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8597d23c87f59294f83bcb6229b9ed1fccee13dbba967b46930d2f1759466fee", size = 347053, upload-time = "2026-06-29T13:03:02.045Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ae/c7e64e7932ad597fa395b61440b249ada6366716e25c6e08dd2afbd021e6/jiter-0.16.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:3126a5dbad56401989ac769aca0cb56005bfb3e2366eea0ca99d1a91c3c1ee03", size = 356153, upload-time = "2026-06-29T13:03:03.706Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/1c/1c719044f14da814e1a060191ab19b96f3e99207bc5b4bfc6d6be34b3f80/jiter-0.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c4b4717bdb35ae456f831a6b08d01880fff399887a6bbc526a583a406e484eea", size = 393956, upload-time = "2026-06-29T13:03:05.165Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/dc/7b2f303a2847207e265503853a2d964a55354cffd62a5f2936c155486798/jiter-0.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:adff21bc78edfe086c15eb495b900306076de378dc2337c132401fc39bd79c91", size = 521081, upload-time = "2026-06-29T13:03:06.886Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/5f/501cf6e1e09caeb420195179ffc6f62aca603f1220ec53fd80d0d70b3e56/jiter-0.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dab907db06fc593645e73109acf4581ba5b548897d28b9348dc41ddc8343b2d3", size = 552085, upload-time = "2026-06-29T13:03:08.339Z" },
+    { url = "https://files.pythonhosted.org/packages/79/54/aa5be86520113b79455c3877f3d1f07a348098df4083ba3688e9537e52dd/jiter-0.16.0-cp311-cp311-win32.whl", hash = "sha256:560b2cf3fb03240cd34f27409a238547488708f05b7c3924f571a60422251ec7", size = 206755, upload-time = "2026-06-29T13:03:09.653Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ec/2feb893eb330bd69b413866f4d5daada33c3962f1c6f270c91ca2d87fdf9/jiter-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:e431cfc9caf44c1d5459ff77d4e64cbf85fddb6a35dad836a15c6a9ec23087c1", size = 199155, upload-time = "2026-06-29T13:03:10.979Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9c/ca040d94415048a3666fc237774df8151c96f8d2b661cbe3b184acc95876/jiter-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:2a8e9e39cf083016137aa5cadafe3188adc2ba6ba1fbf1e5d18889ad3e9ad056", size = 194403, upload-time = "2026-06-29T13:03:12.341Z" },
+    { url = "https://files.pythonhosted.org/packages/83/2b/52ace16ed031354f0539749a49e4bf33797d82bea5137910835fa4b09793/jiter-0.16.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:67c3bc1760f8c99d805dcab4e644027142a53b1d5d861f18780ebdbd5d40b72a", size = 306943, upload-time = "2026-06-29T13:03:14.035Z" },
+    { url = "https://files.pythonhosted.org/packages/94/2e/34957c2c1b661c252ba9bcc60ae0bddc27e0f7202c6073326a13c5390eec/jiter-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5af7780e4a26bd7d0d989592bf9ef12ebf806b74ab709223ecca37c749872ea9", size = 307779, upload-time = "2026-06-29T13:03:15.418Z" },
+    { url = "https://files.pythonhosted.org/packages/88/6c/59bd309cab4460c54cf1079f3eb7fe7af6a4c895c5c957a53378693bad2b/jiter-0.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5bf78d0e05e45cfdd66558893938d59afe3d1b1a824a202039b20e607d25a72", size = 335826, upload-time = "2026-06-29T13:03:17.11Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8c/f5ef7b65f0df47afa16596969defb281ebb86e96df346d62be6fd853d620/jiter-0.16.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4444a83f946605990c98f625cdd3d2725bfb818158760c5748c653170a20e0e", size = 362573, upload-time = "2026-06-29T13:03:18.781Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0b/ace4354da061ee38844a0c27dc2c21eecd27aea119e8da324bea987522d0/jiter-0.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a23f0e4f957e1be65752d2dfac9a5a06b1917af8dc85deb639c3b9d02e31290", size = 457979, upload-time = "2026-06-29T13:03:20.293Z" },
+    { url = "https://files.pythonhosted.org/packages/55/40/c0253d3772eb9dcd8e6606ee9b2d53ec8e5b814589c47f140aa585f21eaa/jiter-0.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c22a488f7b9218e245a0025a9ba6b100e2e54700831cf4cf16833a27fba3ad01", size = 372302, upload-time = "2026-06-29T13:03:21.739Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/d2/4839422241aa12860ce597b20068727094ba0bc480723c74924ca5bad483/jiter-0.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46add52f4ad47a08bfb1219f3e673da972191489a33016edefdb5ea55bfa8c48", size = 343805, upload-time = "2026-06-29T13:03:23.384Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/59/e196888a05befdda7dbe299b722d56f2f6eec65402bc34c0a3306d595feb/jiter-0.16.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:9c8a956fd72c2cf1e730d01ea080341f13aa0a97a4a33b51abebe725b7ae9ca9", size = 351107, upload-time = "2026-06-29T13:03:24.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/74/4cd9e0fca65232136400354b630fbfcd2de634e22ccbb96567725981b548/jiter-0.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:561926e0573ffe4a32498420a76d64b16c513e1ab413b9d28158a8764ac701e5", size = 388441, upload-time = "2026-06-29T13:03:26.266Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/8c/554691e48bc711299c0a293dd8a6179e24b2d66a54dc295421fcf64569c0/jiter-0.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:44d019fa8cdaf89bf29c71b39e3712143fdd0ac76725c6ef954f9957a5ea8730", size = 516354, upload-time = "2026-06-29T13:03:28.02Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/cb/01e9d69dc2cc6759d4f91e230b34489c4fdb2518992650633f9e20bece89/jiter-0.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0df91907609837f33341b8e6fe73b95991fdaa57caf1a0fbd343dffe826f386f", size = 547880, upload-time = "2026-06-29T13:03:29.534Z" },
+    { url = "https://files.pythonhosted.org/packages/79/70/2953195f1c6ad00f49fa67e13df7e60acb3dd4f387101bc15abccddd905e/jiter-0.16.0-cp312-cp312-win32.whl", hash = "sha256:51d7b836acb0108d7c77df1742332cac2a1fa04a74d6dacec46e7091f0e91274", size = 203473, upload-time = "2026-06-29T13:03:31.025Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/05/2909a8b10699a4d560f8c502b6b2c5f3991b682b1922c1eedda242b225bd/jiter-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:1878349266f8ee36ecb1375cc5ba2f115f35fd9f0a1a4119e725e379126647f7", size = 196905, upload-time = "2026-06-29T13:03:32.472Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a9/6b82bb1c8d7790d602489b967b982a909e5d092875a6c2ade96444c8dfc5/jiter-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:2ed5738ae4af18271a51a528b8811b0cbfa4a1858de9d83359e4169855d6a331", size = 190618, upload-time = "2026-06-29T13:03:34.672Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c0/555fc60473d30d66894ba825e63615e3be7524fac23858356afa7a38906c/jiter-0.16.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:41977aa5654023948c2dae2a81cbf9c43343954bef1cd59a154dd15a4d84c195", size = 306203, upload-time = "2026-06-29T13:03:36.243Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/2b/c3eaf16f5d7c9bad66ea32f40a95bd169b29a91217fcc7f081375157e99c/jiter-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d28bb3c26762358dadf3e5bf0bccd29ae987d65e6988d2e6f49829c76b003c09", size = 306489, upload-time = "2026-06-29T13:03:37.846Z" },
+    { url = "https://files.pythonhosted.org/packages/96/3f/02fdfc6705cad96127d883af5c34e4867f554f29ec7705ec1a46156400a9/jiter-0.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0542a7189c26920778658fc8fcf2af8bae05bae9924577f71804acef37996536", size = 335453, upload-time = "2026-06-29T13:03:39.221Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a6/e4bda5920d4b0d7c5dfb7174ce4a6b2e4d3e11c9162c452ef0eab4cdbdbd/jiter-0.16.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8fb8de1e23a0cb2a7f53c335049c7b72b6db41aa6227cdcc0972a1de5cb39450", size = 361625, upload-time = "2026-06-29T13:03:40.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/97/4e6b59b2c6e55cbb3e183595f81ad65dcfb21c915fee5e19e335df21bc55/jiter-0.16.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b72d0b2990ca754a9102779ac98d8597b7cb31678958562214a007f909eab78e", size = 456958, upload-time = "2026-06-29T13:03:42.074Z" },
+    { url = "https://files.pythonhosted.org/packages/15/e0/97e9557686d2f94f4b93786eccb7eed28e9228ad132ea8237f44727314a7/jiter-0.16.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5f91b1c27fc22a57993d5a5cb8a627cb8ed4b10502716fac1ffbfe1d19d84e8", size = 372017, upload-time = "2026-06-29T13:03:43.658Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/94/db768b6938e0df35c86beeba3dfbbb025c9ee5c19e1aa271f2396e50864d/jiter-0.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c682bea068a90b764577bdb78a60a4c1d1606daf9cd4c893832a37c7cc9d9026", size = 343320, upload-time = "2026-06-29T13:03:45.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/d6/5a59d938244a30735fe62d9433fd325f9021ea29d89780ea4596ea93bc89/jiter-0.16.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:8d031aabecc4f1b6276adfb42e3aabb77c89d468bf616600e8d3a11328929053", size = 350520, upload-time = "2026-06-29T13:03:46.671Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f8/c4a857f49c9af125f6bbcac7e3eee7f7978ed89682833062e2dbf62576b1/jiter-0.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eab2cd170150e70153de16896a1774e3a1dca80154c56b54d7a812c479a7165e", size = 387550, upload-time = "2026-06-29T13:03:48.361Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/d6/5fbc2f7d6b67b754caa61a993a2e626e815dec47ffc2f9e35f01adfebec7/jiter-0.16.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:6edb63a46e65a82c26800a868e49b2cac30dd5a4218b88d74bc2c848c8ad60bb", size = 515424, upload-time = "2026-06-29T13:03:49.881Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/54/284f0164b64a5fed915fea6ba7e9ba9b3d8d37c67d59cf2e3bb99d45cdfe/jiter-0.16.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:659039cc50b5addcc35fcc87ae2c1833b7c0a8e5326ef631a75e4478447bcf84", size = 546981, upload-time = "2026-06-29T13:03:51.363Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c5/2a467585a576594384e1d2c43e1224deaafc085f24e243529cf98beef8e1/jiter-0.16.0-cp313-cp313-win32.whl", hash = "sha256:c9c53be232c2e206ef9cdbad81a48bfa74c3d3f08bcf8124630a8a748aad993e", size = 202853, upload-time = "2026-06-29T13:03:53.015Z" },
+    { url = "https://files.pythonhosted.org/packages/88/6a/de61d04b9eec69c71719968d2f716532a3bc121170c44a39e14979c6be81/jiter-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:baad945ed47f163ad833314f8e3288c396118934f94e7bbb9e243ce4b341a4fd", size = 196160, upload-time = "2026-06-29T13:03:54.447Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4b/b390ed59bafb3f31d008d1218578f10327714484b334439947f7e5b11e7f/jiter-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:3c1fd2dbe1b0af19e987f03fe66c5f5bd105a2229c1aff4ab14890b24f41d21a", size = 189862, upload-time = "2026-06-29T13:03:55.754Z" },
+    { url = "https://files.pythonhosted.org/packages/06/d3/8e278946d43eeca2585b4dd0834a887cd71136329b837f3a16ed86a8b4b0/jiter-0.16.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:850ccb1d7eedb4200f4014b1c0e8a577de114fc3cd88faad646dcc9bc4bb12ad", size = 304518, upload-time = "2026-06-29T13:05:00.172Z" },
+    { url = "https://files.pythonhosted.org/packages/72/43/28d4ef495028bf0506a413d4db3f4eb3e7288a382e0f065f306a17bbeb5e/jiter-0.16.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:e34e97bda77eb63242a410243c071e28ac7e0d8c0948c5ee658498690a4b2f2f", size = 310207, upload-time = "2026-06-29T13:05:02.123Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ca/c366b1012da1d640de975d9683acd44e4d150d9068845d0ca2610435253f/jiter-0.16.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7dc85ea77d4abbae8bad0d3538678aedee75bceec4e2f6c8dfb1c74772e5aa5", size = 342771, upload-time = "2026-06-29T13:05:03.55Z" },
+    { url = "https://files.pythonhosted.org/packages/16/52/50cc4056fc1ae02e7154704e7ecc89df0afb8300222cfe8a52d3f67e4730/jiter-0.16.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17ca7fae79f6d99cd9a042b75f917eaada7b895cfc7dd2ee3a16089dcaec7a85", size = 346468, upload-time = "2026-06-29T13:05:05.452Z" },
+    { url = "https://files.pythonhosted.org/packages/98/ab/664fd8c4be028b2bedd3d2ff08769c4ede23d0dbc87a77c62384a0515b5d/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:f17d61a28b4b3e0e3e2ba98490c70501403b4d196f78732439160e7fd3678127", size = 303106, upload-time = "2026-06-29T13:05:07.118Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/421f1d5b65493a76e16027b848aba6a7d28073ae75944fa4289cc914d39f/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:96e38eea538c8ddf853a35727c7be0741c76c13f04148ac5c116222f50ece3b3", size = 304658, upload-time = "2026-06-29T13:05:08.708Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/db/bba1155f01a01c3c37a89425d571da751bbedf5c54247b831a04cb971798/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d284fb8d94d5855d60c44fefcab4bf966f1da6fada73992b01f6f0c9bc0c6702", size = 339719, upload-time = "2026-06-29T13:05:10.41Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f7/18a1afcd64f35314b68c1f23afcd9994d0bc13e65cc77517afff4e83986d/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d613743df53199b1aa256a7d328340da6d7078aac7705a7db9d7a791e9cfd2", size = 343885, upload-time = "2026-06-29T13:05:12.087Z" },
+]
+
+[[package]]
+name = "joblib"
+version = "1.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
+]
+
+[[package]]
+name = "jsonpatch"
+version = "1.33"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonpointer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" },
+]
+
+[[package]]
+name = "jsonpointer"
+version = "3.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ac/f8/06549565caa026e540b7e7bab5c5a90eb7ca986015f4c48dace243cd24d9/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374", size = 122802, upload-time = "2026-03-09T13:12:37.515Z" },
+    { url = "https://files.pythonhosted.org/packages/84/eb/8476a0818850c563ff343ea7c9c05dcdcbd689a38e01aa31657df01f91fa/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd", size = 66216, upload-time = "2026-03-09T13:12:38.812Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/f9c8a6b4c21aed4198566e45923512986d6cef530e7263b3a5f823546561/kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476", size = 63917, upload-time = "2026-03-09T13:12:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/0e/ba4ae25d03722f64de8b2c13e80d82ab537a06b30fc7065183c6439357e3/kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22", size = 1628776, upload-time = "2026-03-09T13:12:41.976Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/e4/3f43a011bc8a0860d1c96f84d32fa87439d3feedf66e672fef03bf5e8bac/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b", size = 1228164, upload-time = "2026-03-09T13:12:44.002Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/34/3a901559a1e0c218404f9a61a93be82d45cb8f44453ba43088644980f033/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e", size = 1246656, upload-time = "2026-03-09T13:12:45.557Z" },
+    { url = "https://files.pythonhosted.org/packages/87/9e/f78c466ea20527822b95ad38f141f2de1dcd7f23fb8716b002b0d91bbe59/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb", size = 1295562, upload-time = "2026-03-09T13:12:47.562Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/66/fd0e4a612e3a286c24e6d6f3a5428d11258ed1909bc530ba3b59807fd980/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537", size = 2178473, upload-time = "2026-03-09T13:12:50.254Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8e/6cac929e0049539e5ee25c1ee937556f379ba5204840d03008363ced662d/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4", size = 2274035, upload-time = "2026-03-09T13:12:51.785Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/d3/9d0c18f1b52ea8074b792452cf17f1f5a56bd0302a85191f405cfbf9da16/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c", size = 2443217, upload-time = "2026-03-09T13:12:53.329Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2a/6e19368803a038b2a90857bf4ee9e3c7b667216d045866bf22d3439fd75e/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede", size = 2249196, upload-time = "2026-03-09T13:12:55.057Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2b/3f641dfcbe72e222175d626bacf2f72c3b34312afec949dd1c50afa400f5/kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2", size = 73389, upload-time = "2026-03-09T13:12:56.496Z" },
+    { url = "https://files.pythonhosted.org/packages/da/88/299b137b9e0025d8982e03d2d52c123b0a2b159e84b0ef1501ef446339cf/kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875", size = 64782, upload-time = "2026-03-09T13:12:57.609Z" },
+    { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" },
+    { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" },
+    { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" },
+    { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" },
+    { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" },
+    { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" },
+    { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" },
+    { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" },
+    { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" },
+    { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" },
+    { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" },
+    { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" },
+    { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" },
+    { url = "https://files.pythonhosted.org/packages/17/6f/6fd4f690a40c2582fa34b97d2678f718acf3706b91d270c65ecb455d0a06/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4", size = 59606, upload-time = "2026-03-09T13:15:40.81Z" },
+    { url = "https://files.pythonhosted.org/packages/82/a0/2355d5e3b338f13ce63f361abb181e3b6ea5fffdb73f739b3e80efa76159/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca", size = 57537, upload-time = "2026-03-09T13:15:42.071Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b9/1d50e610ecadebe205b71d6728fd224ce0e0ca6aba7b9cbe1da049203ac5/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f", size = 79888, upload-time = "2026-03-09T13:15:43.317Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/ee/b85ffcd75afed0357d74f0e6fc02a4507da441165de1ca4760b9f496390d/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed", size = 77584, upload-time = "2026-03-09T13:15:44.605Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/dd/644d0dde6010a8583b4cd66dd41c5f83f5325464d15c4f490b3340ab73b4/kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc", size = 73390, upload-time = "2026-03-09T13:15:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" },
+    { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" },
+    { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" },
+]
+
+[[package]]
+name = "langchain-classic"
+version = "1.0.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "async-timeout", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "langchain-core" },
+    { name = "langchain-text-splitters" },
+    { name = "langsmith" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sqlalchemy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/65/6b5e8a7ff2f2968652c88a67dcecb925b9d8f0a0ce9458c76cd5a0dbd138/langchain_classic-1.0.8.tar.gz", hash = "sha256:ada0cc341a8a5b80fb24d73bdfaaeb849056ee2d8a41cc468355163fd3667484", size = 10557071, upload-time = "2026-06-10T21:27:54.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/9a/b8f5cb7490fdbf233088031fc69c9c747439d4097f67f196c1eb4869916d/langchain_classic-1.0.8-py3-none-any.whl", hash = "sha256:1a11ea7fbe630c4f2af2f3873d27718ceac9488cf32d0821030be7cf039a6213", size = 1041536, upload-time = "2026-06-10T21:27:52.767Z" },
+]
+
+[[package]]
+name = "langchain-community"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "httpx-sse" },
+    { name = "langchain-classic" },
+    { name = "langchain-core" },
+    { name = "langsmith" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pydantic-settings" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sqlalchemy" },
+    { name = "tenacity" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ea/0c/e3aca1f2b1c5b95f8b87cb2b6e81a6f20d538c07a128419dc01cef0617b6/langchain_community-0.4.2.tar.gz", hash = "sha256:a99308160d53d7e9b5965ee665e5173709914338210089fd5788ad724432c21e", size = 33268708, upload-time = "2026-05-22T19:42:59.374Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/39/5d97e42a3e95dc2a6d71b2f902a3fae71786131e11d01bddb604accb0ebe/langchain_community-0.4.2-py3-none-any.whl", hash = "sha256:84dd8c5122532394d5b6849a5fc9995ef28e4f77227daeb09f24b3d942e9e466", size = 2364406, upload-time = "2026-05-22T19:42:57.103Z" },
+]
+
+[[package]]
+name = "langchain-core"
+version = "0.3.86"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonpatch" },
+    { name = "langsmith" },
+    { name = "packaging" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "tenacity" },
+    { name = "typing-extensions" },
+    { name = "uuid-utils" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fe/8d/d54586b8f65c6fc209db93916ff9e919e1cc14bad8fe66880ea4d7ea9d6c/langchain_core-0.3.86.tar.gz", hash = "sha256:671cbc96a325fe47f7dbab421236ada2d437bc4bfad0038102264885d0b462e2", size = 603154, upload-time = "2026-05-07T16:48:08.14Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/93/ba19ca54701c6118e68f8785949b6c0eab1df3a5cfa5310508cc86877994/langchain_core-0.3.86-py3-none-any.whl", hash = "sha256:7d2a1c50d2d2a139dbc6465cd339f32d14aa43db5ac9bd232e5b567a238709e8", size = 461306, upload-time = "2026-05-07T16:48:06.283Z" },
+]
+
+[[package]]
+name = "langchain-huggingface"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "langchain-core" },
+    { name = "tokenizers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/e8/4068ad02179253f55958e59e442e5b6e8cb95ffc5e805cc4db0b1ef61d4e/langchain_huggingface-1.2.2.tar.gz", hash = "sha256:1dd91ec415190d2704e93ec149618e3145075863ba37e74afc9080d685dc2743", size = 255513, upload-time = "2026-04-16T19:57:41.046Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/ed/648b87f9b67153ade616f360bf4145b76ed428b4adb89525938f611e9828/langchain_huggingface-1.2.2-py3-none-any.whl", hash = "sha256:f94944b0c0d5afc687568d426c87ed5236907464c41e72108ed76eee1a690f6d", size = 31926, upload-time = "2026-04-16T19:57:40.079Z" },
+]
+
+[[package]]
+name = "langchain-objectbox"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+    { name = "objectbox" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/15/7c/7b10fd550bc193d4cec715fcc93ae44675ea2af847dad8da084b880af7fe/langchain_objectbox-0.1.0.tar.gz", hash = "sha256:672d2457d51e73b5714ac583e65f6450de5ccff793a6583fec55119d628bc382", size = 5604, upload-time = "2024-05-28T12:04:06.839Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/27/fb79470372e8f23d079e9fa6b1c362835ad33ebb454b6a0e24a879747f0f/langchain_objectbox-0.1.0-py3-none-any.whl", hash = "sha256:e516a007a6f6e07c747138d40eac3237fa776a178d93d084445531f212258759", size = 7159, upload-time = "2024-05-28T12:04:05.571Z" },
+]
+
+[[package]]
+name = "langchain-text-splitters"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/9f/6c545900fefb7b00ddfa3f16b80d61338a0ec68c31c5451eeeab99082760/langchain_text_splitters-1.1.2.tar.gz", hash = "sha256:782a723db0a4746ac91e251c7c1d57fd23636e4f38ed733074e28d7a86f41627", size = 293580, upload-time = "2026-04-16T14:20:39.162Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/26/1ef06f56198d631296d646a6223de35bcc6cf9795ceb2442816bc963b84c/langchain_text_splitters-1.1.2-py3-none-any.whl", hash = "sha256:a2de0d799ff31886429fd6e2e0032df275b60ec817c19059a7b46181cc1c2f10", size = 35903, upload-time = "2026-04-16T14:20:38.243Z" },
+]
+
+[[package]]
+name = "langsmith"
+version = "0.10.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "orjson", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging" },
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "requests-toolbelt" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+    { name = "uuid-utils" },
+    { name = "websockets" },
+    { name = "xxhash" },
+    { name = "zstandard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/8e/49a69c6793bf3fc5af62481e7e9b678fce59d1b384323d3ce87959a653e3/langsmith-0.10.2.tar.gz", hash = "sha256:9aa685383fbdec07a0df51dafc333ab0d4b6b995771172a232c3364714eb17a6", size = 4707343, upload-time = "2026-07-10T13:21:54.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/17/cc8eaf4e82e4bb22009bdde20085ff91719dce643d355fed94d523300130/langsmith-0.10.2-py3-none-any.whl", hash = "sha256:c2a3929055758ac1831582f0939fafc0973cc08432365bbad335c336338ec37c", size = 652545, upload-time = "2026-07-10T13:21:52.13Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/2f/3908645ddddab7120b46295e541ead308109fa48dbec7d67d7a778870d60/librt-0.13.0.tar.gz", hash = "sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781", size = 211402, upload-time = "2026-07-08T12:26:29.834Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/2f/ec5241c38e7fa0fe6c26bfc450e78b9489a6c3c08b394b85d2c10e506975/librt-0.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5", size = 148654, upload-time = "2026-07-08T12:24:30.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/1a/d651e18d3ee7aa2879322368c4f278bb7ecaa6b90caadfdec4ebfa8389f3/librt-0.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547", size = 153537, upload-time = "2026-07-08T12:24:31.773Z" },
+    { url = "https://files.pythonhosted.org/packages/45/18/10bff2122577246009d9619b6569596daf69b7648812f997ca9ca0426f60/librt-0.13.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2", size = 494336, upload-time = "2026-07-08T12:24:33.079Z" },
+    { url = "https://files.pythonhosted.org/packages/67/69/87dfee871b852970f137fdeae8e2ca356c5ab38e6f21d2a3299535fc3159/librt-0.13.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929", size = 485393, upload-time = "2026-07-08T12:24:34.324Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d5/625447a8c0441ff5f15f4ac5e1d323fb9d4d256ebfde7a3c8e003f646057/librt-0.13.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a", size = 515382, upload-time = "2026-07-08T12:24:35.575Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/d8/1c8c49ea04235960426444deece9092a6b3a9587a850a81bae2335317411/librt-0.13.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac", size = 509483, upload-time = "2026-07-08T12:24:36.923Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/65/f1760fc48050e215201a03506c32b7270159088d01f64557b53e39e74a45/librt-0.13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7", size = 532503, upload-time = "2026-07-08T12:24:38.203Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1b/793e281dcf494879eff99f642b63ebc9c7c58694a1c2d1e93362a22c7041/librt-0.13.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40", size = 537027, upload-time = "2026-07-08T12:24:39.34Z" },
+    { url = "https://files.pythonhosted.org/packages/69/45/0801bbb40c9eea795d3dd3ce91c4c5f3fe7d42d23ec4be3e8cb283bcc754/librt-0.13.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a", size = 517100, upload-time = "2026-07-08T12:24:40.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/6c/eb5f514f8e29d4924bc0ff4601dd7b4175557e182e7c0721e84cffa39b8a/librt-0.13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde", size = 558653, upload-time = "2026-07-08T12:24:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/bf/f140100d1b59fe87ff40b5ecbb4e27924335b189a784e230ee465452f6c2/librt-0.13.0-cp310-cp310-win32.whl", hash = "sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8", size = 104402, upload-time = "2026-07-08T12:24:43.668Z" },
+    { url = "https://files.pythonhosted.org/packages/22/7c/57e40fef7cfb61869341cb28bdcefe8a950bebcbecca74a397bae14dce4a/librt-0.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc", size = 125002, upload-time = "2026-07-08T12:24:44.793Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/a6498964cfeec270c468cffdc118f69c29b412593610d55fa1327ca51ff4/librt-0.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082", size = 148029, upload-time = "2026-07-08T12:24:45.961Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/dc86d1bffd8e0c2818bace29d9f7783cfbb8e0673bf3673b5bbd5bbe0420/librt-0.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14", size = 153036, upload-time = "2026-07-08T12:24:47.257Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3f/b923826660f02f286186cd9303d52bb05ced0a13708edc104dc8480920e3/librt-0.13.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79", size = 493062, upload-time = "2026-07-08T12:24:48.483Z" },
+    { url = "https://files.pythonhosted.org/packages/88/87/6c0980a9c9b1302cb68d108906697b89eceb55889bb1dcf77c109aa56ca5/librt-0.13.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176", size = 485510, upload-time = "2026-07-08T12:24:49.727Z" },
+    { url = "https://files.pythonhosted.org/packages/32/81/795ae3b9df5dd94079fb807e38191855e023e8c6249014ae6bc3f0d9a490/librt-0.13.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89", size = 515909, upload-time = "2026-07-08T12:24:51.135Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e5/182de15abce8907108a6fdb41487de65beb5099b74dc5841b19b099168db/librt-0.13.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f", size = 508620, upload-time = "2026-07-08T12:24:52.358Z" },
+    { url = "https://files.pythonhosted.org/packages/32/03/33978d32db76e1f66377e8f78e42a2ca3c162143331677d1f50bbad36cfb/librt-0.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d", size = 530363, upload-time = "2026-07-08T12:24:53.503Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/f5/b291fbd2d00f7d8287bcbf67b5aa0c6afed4bc26cef23e079629c47a2c04/librt-0.13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd", size = 534209, upload-time = "2026-07-08T12:24:55.138Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/03/6f41f17939d191bc21609f220da8509316bc62797f078545fe83be522e78/librt-0.13.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588", size = 514254, upload-time = "2026-07-08T12:24:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/af/c2/2e4befa5410a7443019c14abccc94ff619797171f6b72013635fb87f31d7/librt-0.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1", size = 557611, upload-time = "2026-07-08T12:24:57.561Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/54/8b69f81448417adbc040a2185f4e2eece1e1994b7dcfaeed4662b30f98a5/librt-0.13.0-cp311-cp311-win32.whl", hash = "sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21", size = 104906, upload-time = "2026-07-08T12:24:58.806Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5a/f4aaf37b50f2fde12c8c663b83fdd499cdc24f957f19543d7414bfcc9e25/librt-0.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b", size = 125852, upload-time = "2026-07-08T12:25:00.065Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/99/bf1820e6feeabc2f218c24450ec0c995d6a91e8ba0fd3caf042c9e8adb2a/librt-0.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c", size = 111832, upload-time = "2026-07-08T12:25:01.148Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f4/b2933ddae222dac338476abb872641169a5cfed2c2bb5444a5b07b32b0c3/librt-0.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0", size = 150990, upload-time = "2026-07-08T12:25:02.42Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ef/db98f744ca50e6efc9c95c70ee49b77aefac31f6a3fc7c83754a42d6a74f/librt-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5", size = 155238, upload-time = "2026-07-08T12:25:03.681Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e7/a197e7bc72baf2c61ce7fdc6906a5054dc05bd8da0819aa894e4857bf87e/librt-0.13.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9", size = 503073, upload-time = "2026-07-08T12:25:05.049Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e7/7887712e27da7c1ab80fcabb1de6eb24243964f6557cae530d4b70706dbd/librt-0.13.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b", size = 496528, upload-time = "2026-07-08T12:25:06.26Z" },
+    { url = "https://files.pythonhosted.org/packages/94/f0/f2283385bb6b950b26a1410f4ce51ec27231e0b3a4b925c46366d218b198/librt-0.13.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03", size = 531786, upload-time = "2026-07-08T12:25:07.658Z" },
+    { url = "https://files.pythonhosted.org/packages/36/11/69ac3b54766ffba5fd7e5acebfb048d66dbe1f9f2d14516c2b3edc59cf87/librt-0.13.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e", size = 524393, upload-time = "2026-07-08T12:25:09.121Z" },
+    { url = "https://files.pythonhosted.org/packages/61/5f/d72f95fd444a926a3c14b4e24979474116988dd57a45be242077c45d3c22/librt-0.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd", size = 543026, upload-time = "2026-07-08T12:25:10.459Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/08/dcd9993ad192737a004ba263d549f8ea605b326b952e7d6205c7d4170b76/librt-0.13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348", size = 546829, upload-time = "2026-07-08T12:25:11.716Z" },
+    { url = "https://files.pythonhosted.org/packages/96/d5/6d9bb2f54e4109a956b7128836529653eb9d740f784bc47ed10a02c1000e/librt-0.13.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7", size = 535700, upload-time = "2026-07-08T12:25:13.144Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/f2/10946922503858a359492fa27f13e86228bde702116a740ac7b3cd185f24/librt-0.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82", size = 573566, upload-time = "2026-07-08T12:25:14.336Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a8/94f00e3c99479a18088af3685ea016c42f3c7d5d1964d8dbb40c08d7f1aa/librt-0.13.0-cp312-cp312-win32.whl", hash = "sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3", size = 106099, upload-time = "2026-07-08T12:25:16.159Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/7b/2da9c74c1ed25a89cc4e1c8e007ea2eb4a0f1fafa3e70d757fe3242c5c5c/librt-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa", size = 126934, upload-time = "2026-07-08T12:25:17.275Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/65/aead61bbf3b5358593f9d4779d2a0e88eaf6ec191a6342dde36dd1df6371/librt-0.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1", size = 112236, upload-time = "2026-07-08T12:25:18.425Z" },
+    { url = "https://files.pythonhosted.org/packages/67/3b/18e7b63255297a2bdc9c25c8d6d4ca8eca9f63aceb1252c0f7427ac7099e/librt-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3", size = 151027, upload-time = "2026-07-08T12:25:19.638Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/68/e2248452c00d1a03b45fee1752cdc8f790a476efd2402b75181da88a9e61/librt-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c", size = 155152, upload-time = "2026-07-08T12:25:20.851Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/16/52b1c99bf19057a062aac39c900cbb81499f6f75d6c537c14463d247ba78/librt-0.13.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c", size = 502499, upload-time = "2026-07-08T12:25:22.055Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/54/b811151805c795f55e0dedee6ec687b75f9982a8105d240ea3910737a77b/librt-0.13.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b", size = 496108, upload-time = "2026-07-08T12:25:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/f8/094d6b2bd93f3fdaa54db54cc788c4a365333bddad65ab02e04da0b1d004/librt-0.13.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9", size = 531576, upload-time = "2026-07-08T12:25:24.648Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/40/541733d5755824f968f7ec39d78ffbd75d145964157ae5e69a09ec6d7326/librt-0.13.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db", size = 524390, upload-time = "2026-07-08T12:25:25.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/b5/255673cfdbf5ba663339d36cd863c897289ab4337577e19f9405ce059f36/librt-0.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6", size = 543053, upload-time = "2026-07-08T12:25:27.436Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/11/ab5005e9c9850710f21e354201bf090646349d3fabf5f951eaf70235729e/librt-0.13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7", size = 546387, upload-time = "2026-07-08T12:25:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/04/a5d7ce1d1df1afd15ca283dcdf7530ac073e12d69ae8c40879dda96f7868/librt-0.13.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1", size = 535970, upload-time = "2026-07-08T12:25:30.171Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/76/927e267a6daa290174ac281b23c9804c8829b042ade9c6f24a065f540958/librt-0.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a", size = 573582, upload-time = "2026-07-08T12:25:31.507Z" },
+    { url = "https://files.pythonhosted.org/packages/10/24/b6c5213efe39c19f9e13605644d0cf063b4ddaa33ac2e45b088e23a70e2e/librt-0.13.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628", size = 82189, upload-time = "2026-07-08T12:25:32.675Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/00/d29736be177a906ac0b84a5b04b4fbfa22c776dc2f366de4172b0f968c08/librt-0.13.0-cp313-cp313-win32.whl", hash = "sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927", size = 106193, upload-time = "2026-07-08T12:25:33.692Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ac/aff6fb45393cb8912f39dfb156ef6b2d1cadb207ff465fc8f66141054be8/librt-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650", size = 126962, upload-time = "2026-07-08T12:25:34.769Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/3a/d68cb2b334d53fd30fac81d3a489ce4ba0d9506f4df43fcf676b68352b19/librt-0.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566", size = 112127, upload-time = "2026-07-08T12:25:35.981Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.9"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "cycler", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "fonttools", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "kiwisolver", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pillow", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pyparsing", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "python-dateutil", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/6f/340b04986e67aac6f66c5145ce68bf72c64bed30f92c8913499a6e6b8f99/matplotlib-3.10.9-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77210dce9cb8153dffc967efaae990543392563d5a376d4dd8539bebcb0ed217", size = 8296625, upload-time = "2026-04-24T00:11:43.376Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/2f/127081eb83162053ebb9678ceac64220b93a663e0167432566e9c7c82aab/matplotlib-3.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1e7698ac9868428e84d2c967424803b2472ff7167d9d6590d4204ed775343c3b", size = 8188790, upload-time = "2026-04-24T00:11:46.556Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b7/d8bcec2626c35f96972bff656299fef4578113ea6193c8fdad324710410c/matplotlib-3.10.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aa972116abb4c9d201bf245620b433726cb6856f3bef6a78f776a00f5c92d37", size = 8769389, upload-time = "2026-04-24T00:11:48.959Z" },
+    { url = "https://files.pythonhosted.org/packages/12/49/b78e214a527ea732033b7f4d37f7afb504d74ba9d134bd47938230dfb8b1/matplotlib-3.10.9-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2f11957b27ce53497dd4d7b235c4d4f1faf383dfb39d0c5beb833bff883294", size = 9589657, upload-time = "2026-04-24T00:11:51.915Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/15/5246f7b43beae19c74dfee651d58d6cc8112e06f77adb4e88cc04f2e3a23/matplotlib-3.10.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b049278ddce116aaa1c1377ebf58adea909132dfce0281cf7e3a1ea9fc2e2c65", size = 9651983, upload-time = "2026-04-24T00:11:54.766Z" },
+    { url = "https://files.pythonhosted.org/packages/75/77/5acecfe672ba0fa1b8c0454f69ce155d1e6fc5852fa7206bf9afaf767121/matplotlib-3.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:82834c3c292d24d3a8aae77cd2d20019de69d692a34a970e4fdb8d33e2ea3dda", size = 8199701, upload-time = "2026-04-24T00:11:58.389Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" },
+    { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" },
+    { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" },
+    { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" },
+    { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" },
+    { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" },
+    { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" },
+    { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" },
+    { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" },
+    { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/2b/0e92ad0ac446633f928a1563db4aa8add407e1924faf0ded5b95b35afb27/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1872fb212a05b729e649754a72d5da61d03e0554d76e80303b6f83d1d2c0552b", size = 8293058, upload-time = "2026-04-24T00:13:56.339Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/23/74682fd369f5299ceda438fea2a0662e6383b85c9383fb9cdfcf04713e07/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:985f2238880e2e69093f588f5fe2e46771747febf0649f3cf7f7b7480875317f", size = 8186627, upload-time = "2026-04-24T00:13:58.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e8/368aab88f3c4cd8992800f31abfe0670c3e47540ba20a97e9fdbcde594b3/matplotlib-3.10.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6640f75af2c6148293caa0a2b39dd806a492dd66c8a8b04035813e33d0fd2585", size = 8764117, upload-time = "2026-04-24T00:14:01.684Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.11.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "cycler", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "fonttools", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "kiwisolver", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pillow", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pyparsing", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "python-dateutil", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/a2/78f662f1b18968531f67d3fcde1b7ea8496920bacd4f16ddb5b79d112e46/matplotlib-3.11.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f857524b442f0f36e641868ce2171aafa88cb0bc0644f4e1d8a5df9b32649fef", size = 9436261, upload-time = "2026-06-12T02:27:34.161Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/92/044f1de43901310202f4c79acf4f141be53b2ca8d8380e2fcefb3d523a75/matplotlib-3.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:57baa92fdc82948ed716eae6d2579d4d6f40965cd8d2f416755b4a72580a3233", size = 9264669, upload-time = "2026-06-12T02:27:37.413Z" },
+    { url = "https://files.pythonhosted.org/packages/53/f4/f0b4f9ba7ec14a7af8151f3ad71ecfe3561e6ba38cfab1db3681ba4ca112/matplotlib-3.11.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:630eee0e67d35cce2019a0e670719f4816e3b86aff0fa72729f6c69786fceb45", size = 10021076, upload-time = "2026-06-12T02:27:39.926Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/33/4d679c6dcd594a156542080ac907ddccf7b09ca11655c4b28eca8e9ee5da/matplotlib-3.11.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5106c444d0bf966eee2853548c03772af4ab7199118e086c62fbac8ccb07c055", size = 10828999, upload-time = "2026-06-12T02:27:42.433Z" },
+    { url = "https://files.pythonhosted.org/packages/07/74/0a3683802037d8cd013144d77c247219b47f2aabace6fdde74faa12bacf7/matplotlib-3.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4d7aea652b58e686444079be3376ef546bffa1eee9b9bb9c472b9fcf6cf410d3", size = 10913103, upload-time = "2026-06-12T02:27:44.827Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9f/970fcbf381e82ec66fdf5da8ea76e2e9240f61a24011ce9fd1d42c37ac2d/matplotlib-3.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:70a5b3e9a5dab708c0f039709ae7c68d5b4d254e291ef76492cdba230c8bb5e4", size = 9310945, upload-time = "2026-06-12T02:27:46.867Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4e/6e7cfed23611265ded53806852343b5c59339e506e84c474a9b5afc3b249/matplotlib-3.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:3d68266213e73823ac3be90615bab0cf31f88851e114cdb1dd25dacf3b01e1a7", size = 8999304, upload-time = "2026-06-12T02:27:48.798Z" },
+    { url = "https://files.pythonhosted.org/packages/da/17/f5276b496c61477a6c4fc5e7401f4bfe1c2e5ef7c6cd67896f2ade3809cb/matplotlib-3.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:06b5872e9cf11adc8f589ded3ce11bc3e1061ad498259664fabc1f6615beb918", size = 9449976, upload-time = "2026-06-12T02:27:50.989Z" },
+    { url = "https://files.pythonhosted.org/packages/82/34/bdd77418adb2178a1d59f044bd67bfebb115896e91b840b8a197eb3f4f4e/matplotlib-3.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0515d495124be3124340e59f164d901ed4484e2246a5b74cfa483cac3b80bd97", size = 9279307, upload-time = "2026-06-12T02:27:53.247Z" },
+    { url = "https://files.pythonhosted.org/packages/94/95/7f522393c88313336b20d70fc849555757b2e5febc22b83b3a3f0fd4bce9/matplotlib-3.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be5f93a1d21981bfb802ded0d77a0caa92d4342a47d45754fac77e314a506344", size = 10031353, upload-time = "2026-06-12T02:27:55.215Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ce/8f25a0e3186aefd61913e7467d1b999465bcd0d0c03ac695c1b26ca559b7/matplotlib-3.11.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41635d7909d19e52e924a521dde6d8f670b0f53ab1d0e8c331fa831554f681d1", size = 10839232, upload-time = "2026-06-12T02:27:57.746Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c2/db15da2bbdf9e3ca66df7db8e2c33a1dfed67be24a24d2c878efaaff01d6/matplotlib-3.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:94f5000f67ca9faa300863ea17f8bce9175cb67b88bec4bc7780502d53dd7c9e", size = 10923899, upload-time = "2026-06-12T02:28:00.223Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2f/a58a4443a4d052a4ea77557478336aefc26c7981f6408d37adba763aa758/matplotlib-3.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac6f1ef39f3d0f9e2463303013094992cdbe0f85f43bc54155bc472b2042768e", size = 9329528, upload-time = "2026-06-12T02:28:02.27Z" },
+    { url = "https://files.pythonhosted.org/packages/61/0f/4b669589d47733b97ab9df4b58d6fc1e68acb5ea42a928dc7cbdd6bf5871/matplotlib-3.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:9dd11fb612ce7bc60b1de5b4fc87ff959d22317b5de42aabf392f66f97af22eb", size = 9003413, upload-time = "2026-06-12T02:28:04.49Z" },
+    { url = "https://files.pythonhosted.org/packages/55/41/aa47f156b061d14c98b906f76c428507397708ec63ff94f410ae1752b426/matplotlib-3.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6ce3b839b34ae1f430b4616893a2945a2999debaa7e94e7e29a2a8bbf286f7b5", size = 9450532, upload-time = "2026-06-12T02:28:06.769Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/4f/5a9eb0375e81413953febf8af7b012a6b6357f53438a15c4f5ad86c6bbb5/matplotlib-3.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:373db8f91214e8ccaf35ac833cc1dd59dd961e148bbd55dd027141591dde1313", size = 9279760, upload-time = "2026-06-12T02:28:09.152Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/c0/1117d53077e3ac3152503a84e9cf7a5c239576805ee71276e80c2aaa7471/matplotlib-3.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be152b7570324dc8d01574cc9474dd2d803237acf528bcbb5b211fa347461a09", size = 10031623, upload-time = "2026-06-12T02:28:11.26Z" },
+    { url = "https://files.pythonhosted.org/packages/92/7e/e937138daffad65b71bf831a377809dcbc830fb4f31a31e067dc1faa2575/matplotlib-3.11.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:126f256df600652d7e4b394cf3164ff75210a00038f287c95a012a6f58d0e83f", size = 10839372, upload-time = "2026-06-12T02:28:14.102Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/c2/438ecc197ffb8023b6b9922915542f2172f5fd45b76703b0b4fc47322243/matplotlib-3.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:03acfeddf87b0dddb11b081ef7740ad445a3ca8bcb6b8e3011b08f2cf802b75c", size = 10924099, upload-time = "2026-06-12T02:28:16.383Z" },
+    { url = "https://files.pythonhosted.org/packages/40/2e/395883da416f378b3ed2c9f3e843ac477eae1ce731b671b79adaa6f0bacd/matplotlib-3.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:ab3722f04f3ff34c23b5012c5873d2894174e06c3822fcdac3610965a5ac7d06", size = 9329727, upload-time = "2026-06-12T02:28:18.581Z" },
+    { url = "https://files.pythonhosted.org/packages/61/82/2c388956abf8bf392dfb5b8917c502f1082df6a941b781ab8c8e5ba2474b/matplotlib-3.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:c945824670fb8915b4ac879e5e61f3c58e0913022f70a0de4c082b17372f8771", size = 9003506, upload-time = "2026-06-12T02:28:20.474Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c1/34454baa44da7975ada82e9aea37105ec47059514dc967d3be14426ba8dc/matplotlib-3.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3489c3dc487669b4a980bc3068f87856de7a1564248d3f6c629efb2a58b03f24", size = 9499838, upload-time = "2026-06-12T02:28:22.713Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c3/98fe79a398cf232219f090163a7fa7e6766e9f2e0ad26df54d6f8934d8ee/matplotlib-3.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6a98f5476ce784a50ce09998f4ae1e6a9f25043cef8a480c98949902eda74620", size = 9332298, upload-time = "2026-06-12T02:28:24.796Z" },
+    { url = "https://files.pythonhosted.org/packages/95/e4/b4b7c33151e74e5c802f3cde1ba807ebfc38401e329b44e215a5888dd76d/matplotlib-3.11.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:565af866fd63e4bd3f987d580afe27c44c2552a3b3305f4ecbb85133601ea6f3", size = 10045491, upload-time = "2026-06-12T02:28:27.141Z" },
+    { url = "https://files.pythonhosted.org/packages/71/28/394548efd68354110c1a1be11fe6b6e559e06d1a23da35908a0e316c55a9/matplotlib-3.11.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6b3e64dea5062c570f04358e2711859f3531b459f29516274fbad889079e4f3", size = 10857059, upload-time = "2026-06-12T02:28:29.222Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/44/e7922e6e2a4d63bdfbc9dc4a53e3850ab438d46cf42e6779bb15ec92c948/matplotlib-3.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:942b37c5db1899610bd1543ce8e13e4ecff9a4633e7f63bb6aa9205d2644ebd1", size = 10939576, upload-time = "2026-06-12T02:28:31.66Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/be/b1ca96003a441d619b727fee21d671fdff7a5ce2f1bb797b2521aa2f679a/matplotlib-3.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:c08e649a6313e1291e713623b97a38e5bb4aa580b2a100a94a3309bc6b9c8eb3", size = 9379519, upload-time = "2026-06-12T02:28:33.888Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/72/4bf3b91821c34596dd6a7bdac5836d94f744144c8208939ef49d8ec43f7e/matplotlib-3.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2746cd2c113742ff6ce37a864c5ac5fd7aa644568f445e66166e457ac78e40e0", size = 9055456, upload-time = "2026-06-12T02:28:35.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c2/f5da6cd37ed6871f5c9b3c0507ddb69f14d6c36fac4541e4e0c60cb8cdfc/matplotlib-3.11.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:81ae77077a1e16d37a5b61096ccb07c8d90a99b518fa8256b8f21578932f2f62", size = 9434094, upload-time = "2026-06-12T02:29:09.135Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/07/56f66906e0f87a0c6d0d0acbd34dbc9432b1931d8f26ef618bd6f92932a9/matplotlib-3.11.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ddef37840695f5eef65f9f070fe2d2f510f584c2156203f9f622a5b0584efffd", size = 9262183, upload-time = "2026-06-12T02:29:11.283Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/d8/c4ecab06b7ea36a570c4f3bd2d48d1799fd5d9174470e45c2194199431e7/matplotlib-3.11.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf662e5ac5707658cb931e19972c4bd99f7b4f8b7bf79d3c821d239fa6b71e64", size = 10015653, upload-time = "2026-06-12T02:29:13.251Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mergedeep"
+version = "1.3.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
+]
+
+[[package]]
+name = "mkdocs"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "ghp-import" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mergedeep" },
+    { name = "mkdocs-get-deps" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
+]
+
+[[package]]
+name = "mkdocs-get-deps"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mergedeep" },
+    { name = "platformdirs" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/25/b3cccb187655b9393572bde9b09261d267c3bf2f2cdabe347673be5976a6/mkdocs_get_deps-0.2.2.tar.gz", hash = "sha256:8ee8d5f316cdbbb2834bc1df6e69c08fe769a83e040060de26d3c19fad3599a1", size = 11047, upload-time = "2026-03-10T02:46:33.632Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/29/744136411e785c4b0b744d5413e56555265939ab3a104c6a4b719dad33fd/mkdocs_get_deps-0.2.2-py3-none-any.whl", hash = "sha256:e7878cbeac04860b8b5e0ca31d3abad3df9411a75a32cde82f8e44b6c16ff650", size = 9555, upload-time = "2026-03-10T02:46:32.256Z" },
+]
+
+[[package]]
+name = "mkdocs-material"
+version = "9.7.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "backrefs" },
+    { name = "colorama" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material-extensions" },
+    { name = "paginate" },
+    { name = "pygments" },
+    { name = "pymdown-extensions" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/cd/c05d3a530ba7934f144fb45f7203cd236adc25c7bdcc34673d202f4b0278/mkdocs_material-9.7.7.tar.gz", hash = "sha256:c0649c065b1b0512d60aad8c10f947f8e455284475239b364b610f2deb4d0855", size = 4097923, upload-time = "2026-07-17T16:21:33.156Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/21/17c1bc9e6f47c972ad66fb2ac2568f99f90f1207eeb6fc3b34d094dba7b5/mkdocs_material-9.7.7-py3-none-any.whl", hash = "sha256:8ea9bb1737a5b524a5f9dcf2e1b4ebda8274ae3008aa7845720a97083bef708f", size = 9305438, upload-time = "2026-07-17T16:21:30.017Z" },
+]
+
+[[package]]
+name = "mkdocs-material-extensions"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
+]
+
+[[package]]
+name = "ml-dtypes"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/3a/c5b855752a70267ff729c349e650263adb3c206c29d28cc8ea7ace30a1d5/ml_dtypes-0.5.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c", size = 679735, upload-time = "2025-11-17T22:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/41/79/7433f30ee04bd4faa303844048f55e1eb939131c8e5195a00a96a0939b64/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a", size = 5051883, upload-time = "2025-11-17T22:31:33.658Z" },
+    { url = "https://files.pythonhosted.org/packages/10/b1/8938e8830b0ee2e167fc75a094dea766a1152bde46752cd9bfc57ee78a82/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270", size = 5030369, upload-time = "2025-11-17T22:31:35.595Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a3/51886727bd16e2f47587997b802dd56398692ce8c6c03c2e5bb32ecafe26/ml_dtypes-0.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2", size = 210738, upload-time = "2025-11-17T22:31:37.43Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/5e/712092cfe7e5eb667b8ad9ca7c54442f21ed7ca8979745f1000e24cf8737/ml_dtypes-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90", size = 679734, upload-time = "2025-11-17T22:31:39.223Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/cf/912146dfd4b5c0eea956836c01dcd2fce6c9c844b2691f5152aca196ce4f/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040", size = 5056165, upload-time = "2025-11-17T22:31:41.071Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/80/19189ea605017473660e43762dc853d2797984b3c7bf30ce656099add30c/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483", size = 5034975, upload-time = "2025-11-17T22:31:42.758Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/24/70bd59276883fdd91600ca20040b41efd4902a923283c4d6edcb1de128d2/ml_dtypes-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb", size = 210742, upload-time = "2025-11-17T22:31:44.068Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c9/64230ef14e40aa3f1cb254ef623bf812735e6bec7772848d19131111ac0d/ml_dtypes-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de", size = 160709, upload-time = "2025-11-17T22:31:46.557Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a1/4008f14bbc616cfb1ac5b39ea485f9c63031c4634ab3f4cf72e7541f816a/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48", size = 676888, upload-time = "2025-11-17T22:31:56.907Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/b7/dff378afc2b0d5a7d6cd9d3209b60474d9819d1189d347521e1688a60a53/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b", size = 5036993, upload-time = "2025-11-17T22:31:58.497Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/33/40cd74219417e78b97c47802037cf2d87b91973e18bb968a7da48a96ea44/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d", size = 5010956, upload-time = "2025-11-17T22:31:59.931Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/8b/200088c6859d8221454825959df35b5244fa9bdf263fd0249ac5fb75e281/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328", size = 212224, upload-time = "2025-11-17T22:32:01.349Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/75/dfc3775cb36367816e678f69a7843f6f03bd4e2bcd79941e01ea960a068e/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175", size = 160798, upload-time = "2025-11-17T22:32:02.864Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/74/e9ddb35fd1dd43b1106c20ced3f53c2e8e7fc7598c15638e9f80677f81d4/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6", size = 702083, upload-time = "2025-11-17T22:32:04.08Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f5/667060b0aed1aa63166b22897fdf16dca9eb704e6b4bbf86848d5a181aa7/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d", size = 5354111, upload-time = "2025-11-17T22:32:05.546Z" },
+    { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" },
+]
+
+[[package]]
+name = "mobiletransformers"
+version = "0.2.0"
+source = { editable = "." }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "tokenizers" },
+]
+
+[package.optional-dependencies]
+eval = [
+    { name = "deepeval" },
+    { name = "matplotlib", version = "3.10.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "matplotlib", version = "3.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+export = [
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" } },
+    { name = "onnxscript" },
+    { name = "optimum-onnx", extra = ["onnxruntime"], marker = "extra == 'extra-18-mobiletransformers-export' or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "transformers" },
+]
+hub = [
+    { name = "huggingface-hub" },
+]
+rag = [
+    { name = "langchain-community" },
+    { name = "langchain-huggingface" },
+    { name = "langchain-objectbox" },
+    { name = "sentence-transformers" },
+]
+train = [
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "onnxscript" },
+    { name = "peft", version = "0.13.2", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "peft", version = "0.19.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "transformers" },
+]
+
+[package.dev-dependencies]
+android-build = [
+    { name = "pyyaml" },
+]
+dev = [
+    { name = "mypy" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+docs = [
+    { name = "mkdocs" },
+    { name = "mkdocs-material" },
+]
+genai-smoke = [
+    { name = "onnxruntime-genai", marker = "python_full_version >= '3.11'" },
+]
+ort-training-local = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.12.*'" },
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.12.*'" },
+    { name = "onnxruntime-training", marker = "python_full_version == '3.12.*'" },
+    { name = "onnxscript" },
+    { name = "optimum-onnx" },
+    { name = "peft", version = "0.13.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "torch" },
+    { name = "transformers" },
+]
+smoke = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "deepeval", marker = "extra == 'eval'", specifier = ">=3.4.7" },
+    { name = "huggingface-hub", specifier = ">=0.34" },
+    { name = "huggingface-hub", marker = "extra == 'hub'", specifier = ">=0.34" },
+    { name = "langchain-community", marker = "extra == 'rag'", specifier = ">=0.3.27" },
+    { name = "langchain-huggingface", marker = "extra == 'rag'", specifier = ">=0.3" },
+    { name = "langchain-objectbox", marker = "extra == 'rag'", specifier = "==0.1.0" },
+    { name = "matplotlib", marker = "extra == 'eval'", specifier = ">=3.10" },
+    { name = "numpy", specifier = ">=1.26" },
+    { name = "onnx", specifier = ">=1.16" },
+    { name = "onnx", marker = "extra == 'export'" },
+    { name = "onnx", marker = "extra == 'train'" },
+    { name = "onnxscript", marker = "extra == 'export'", specifier = ">=0.3" },
+    { name = "onnxscript", marker = "extra == 'train'", specifier = ">=0.3" },
+    { name = "optimum-onnx", extras = ["onnxruntime"], marker = "extra == 'export'", specifier = ">=0.1.0" },
+    { name = "peft", marker = "extra == 'train'", specifier = ">=0.13" },
+    { name = "pydantic", specifier = ">=2" },
+    { name = "python-dotenv", specifier = ">=1.0" },
+    { name = "pyyaml", specifier = ">=6.0" },
+    { name = "sentence-transformers", marker = "extra == 'rag'", specifier = ">=5" },
+    { name = "tokenizers", specifier = ">=0.20" },
+    { name = "transformers", marker = "extra == 'export'", specifier = ">=4.50,<4.58" },
+    { name = "transformers", marker = "extra == 'train'", specifier = ">=4.45,<4.58" },
+]
+provides-extras = ["export", "train", "rag", "eval", "hub"]
+
+[package.metadata.requires-dev]
+android-build = [{ name = "pyyaml", specifier = ">=6.0" }]
+dev = [
+    { name = "mypy", specifier = ">=1.11" },
+    { name = "pytest", specifier = ">=8" },
+    { name = "ruff", specifier = ">=0.6" },
+]
+docs = [
+    { name = "mkdocs", specifier = ">=1.6" },
+    { name = "mkdocs-material", specifier = ">=9.5" },
+]
+export-rocm = []
+genai-smoke = [{ name = "onnxruntime-genai", marker = "python_full_version >= '3.11'", specifier = ">=0.14" }]
+ort-training-local = [
+    { name = "numpy", marker = "python_full_version == '3.12.*'", specifier = "<2" },
+    { name = "onnx", marker = "python_full_version == '3.12.*'", specifier = "<1.19" },
+    { name = "onnxruntime-training", marker = "python_full_version == '3.12.*'", path = "third_party/wheels/onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl" },
+    { name = "onnxscript", specifier = ">=0.3" },
+    { name = "optimum-onnx", specifier = ">=0.1.0" },
+    { name = "peft", specifier = "==0.13.2" },
+    { name = "torch", specifier = "==2.7.1" },
+    { name = "transformers", specifier = ">=4.50,<4.58" },
+]
+smoke = [{ name = "pytest", specifier = ">=8" }]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/0b/19348d4c98980c4851d2f943f8ebafdece2ae7ef737adcfa5994ce8e5f10/multidict-6.7.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c93c3db7ea657dd4637d57e74ab73de31bccefe144d3d4ce370052035bc85fb5", size = 77176, upload-time = "2026-01-26T02:42:59.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/04/9de3f8077852e3d438215c81e9b691244532d2e05b4270e89ce67b7d103c/multidict-6.7.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:974e72a2474600827abaeda71af0c53d9ebbc3c2eb7da37b37d7829ae31232d8", size = 44996, upload-time = "2026-01-26T02:43:01.674Z" },
+    { url = "https://files.pythonhosted.org/packages/31/5c/08c7f7fe311f32e83f7621cd3f99d805f45519cd06fafb247628b861da7d/multidict-6.7.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cdea2e7b2456cfb6694fb113066fd0ec7ea4d67e3a35e1f4cbeea0b448bf5872", size = 44631, upload-time = "2026-01-26T02:43:03.169Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/7f/0e3b1390ae772f27501199996b94b52ceeb64fe6f9120a32c6c3f6b781be/multidict-6.7.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17207077e29342fdc2c9a82e4b306f1127bf1ea91f8b71e02d4798a70bb99991", size = 242561, upload-time = "2026-01-26T02:43:04.733Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/f4/8719f4f167586af317b69dd3e90f913416c91ca610cac79a45c53f590312/multidict-6.7.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4f49cb5661344764e4c7c7973e92a47a59b8fc19b6523649ec9dc4960e58a03", size = 242223, upload-time = "2026-01-26T02:43:06.695Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ab/7c36164cce64a6ad19c6d9a85377b7178ecf3b89f8fd589c73381a5eedfd/multidict-6.7.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a9fc4caa29e2e6ae408d1c450ac8bf19892c5fca83ee634ecd88a53332c59981", size = 222322, upload-time = "2026-01-26T02:43:08.472Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/79/a25add6fb38035b5337bc5734f296d9afc99163403bbcf56d4170f97eb62/multidict-6.7.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c5f0c21549ab432b57dcc82130f388d84ad8179824cc3f223d5e7cfbfd4143f6", size = 254005, upload-time = "2026-01-26T02:43:10.127Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/7b/64a87cf98e12f756fc8bd444b001232ffff2be37288f018ad0d3f0aae931/multidict-6.7.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7dfb78d966b2c906ae1d28ccf6e6712a3cd04407ee5088cd276fe8cb42186190", size = 251173, upload-time = "2026-01-26T02:43:11.731Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ac/b605473de2bb404e742f2cc3583d12aedb2352a70e49ae8fce455b50c5aa/multidict-6.7.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b0d9b91d1aa44db9c1f1ecd0d9d2ae610b2f4f856448664e01a3b35899f3f92", size = 243273, upload-time = "2026-01-26T02:43:13.063Z" },
+    { url = "https://files.pythonhosted.org/packages/03/65/11492d6a0e259783720f3bc1d9ea55579a76f1407e31ed44045c99542004/multidict-6.7.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dd96c01a9dcd4889dcfcf9eb5544ca0c77603f239e3ffab0524ec17aea9a93ee", size = 238956, upload-time = "2026-01-26T02:43:14.843Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/a7/7ee591302af64e7c196fb63fe856c788993c1372df765102bd0448e7e165/multidict-6.7.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:067343c68cd6612d375710f895337b3a98a033c94f14b9a99eff902f205424e2", size = 233477, upload-time = "2026-01-26T02:43:16.025Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/99/c109962d58756c35fd9992fed7f2355303846ea2ff054bb5f5e9d6b888de/multidict-6.7.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5884a04f4ff56c6120f6ccf703bdeb8b5079d808ba604d4d53aec0d55dc33568", size = 243615, upload-time = "2026-01-26T02:43:17.84Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5f/1973e7c771c86e93dcfe1c9cc55a5481b610f6614acfc28c0d326fe6bfad/multidict-6.7.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8affcf1c98b82bc901702eb73b6947a1bfa170823c153fe8a47b5f5f02e48e40", size = 249930, upload-time = "2026-01-26T02:43:19.06Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a5/f170fc2268c3243853580203378cd522446b2df632061e0a5409817854c7/multidict-6.7.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:0d17522c37d03e85c8098ec8431636309b2682cf12e58f4dbc76121fb50e4962", size = 243807, upload-time = "2026-01-26T02:43:20.286Z" },
+    { url = "https://files.pythonhosted.org/packages/de/01/73856fab6d125e5bc652c3986b90e8699a95e84b48d72f39ade6c0e74a8c/multidict-6.7.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:24c0cf81544ca5e17cfcb6e482e7a82cd475925242b308b890c9452a074d4505", size = 239103, upload-time = "2026-01-26T02:43:21.508Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/46/f1220bd9944d8aa40d8ccff100eeeee19b505b857b6f603d6078cb5315b0/multidict-6.7.1-cp310-cp310-win32.whl", hash = "sha256:d82dd730a95e6643802f4454b8fdecdf08667881a9c5670db85bc5a56693f122", size = 41416, upload-time = "2026-01-26T02:43:22.703Z" },
+    { url = "https://files.pythonhosted.org/packages/68/00/9b38e272a770303692fc406c36e1a4c740f401522d5787691eb38a8925a8/multidict-6.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:cf37cbe5ced48d417ba045aca1b21bafca67489452debcde94778a576666a1df", size = 46022, upload-time = "2026-01-26T02:43:23.77Z" },
+    { url = "https://files.pythonhosted.org/packages/64/65/d8d42490c02ee07b6bbe00f7190d70bb4738b3cce7629aaf9f213ef730dd/multidict-6.7.1-cp310-cp310-win_arm64.whl", hash = "sha256:59bc83d3f66b41dac1e7460aac1d196edc70c9ba3094965c467715a70ecb46db", size = 43238, upload-time = "2026-01-26T02:43:24.882Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ast-serialize" },
+    { name = "librt", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/12/af/4e516a05d3ca2eb9283e9ec45b2c02225c1514dd6da49fd3c9eaa6639370/mypy-2.3.0.tar.gz", hash = "sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e", size = 3988104, upload-time = "2026-07-13T11:34:53.387Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/09/f2f5f45dae0c9a0891e4751a73312730e009395102e5d72a22a976cca41f/mypy-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc", size = 14927774, upload-time = "2026-07-13T11:28:38.224Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/345367effd3a6877275a94d481614bfca983f45e028c6290e2cc54603811/mypy-2.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3", size = 14000127, upload-time = "2026-07-13T11:30:19.57Z" },
+    { url = "https://files.pythonhosted.org/packages/99/6c/a10b7a7b9f0a755fb94e27ae834d4cea9ad6c5221f9325eef8f182641feb/mypy-2.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805", size = 14229437, upload-time = "2026-07-13T11:28:17.765Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/bd/a26a602acb1bbf849fa4bdac4bc657ee2f11c0c2a764a2cc87a5304e865c/mypy-2.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117", size = 15171457, upload-time = "2026-07-13T11:29:01.834Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/14/124f462bef69bcbc90b9358088460b6091954a3e004852fcd9948db617a5/mypy-2.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5", size = 15478281, upload-time = "2026-07-13T11:32:23.413Z" },
+    { url = "https://files.pythonhosted.org/packages/db/a4/8bdca6a8ac8d856d82ed049144af2721245a135c2e8001d3890c93975852/mypy-2.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494", size = 11148008, upload-time = "2026-07-13T11:34:17.332Z" },
+    { url = "https://files.pythonhosted.org/packages/83/41/490eea348e60ba50decec20bc750605444149a5d7a8cc560042f90ba2c75/mypy-2.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee", size = 10142329, upload-time = "2026-07-13T11:32:52.116Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b9/d75b3082b05f1b3028828aeb18e74ae5ab0a0936051bbf1f32f59f654747/mypy-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329", size = 14838725, upload-time = "2026-07-13T11:32:44.655Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/50/79a65c6ea6e115bc73296038a4543b2d5c91f07912b918a2c616a2514bba/mypy-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f", size = 13911128, upload-time = "2026-07-13T11:32:02.021Z" },
+    { url = "https://files.pythonhosted.org/packages/90/48/e11ed7716c26953ca321f726e452e374dbf81a6f2b8b212ec02af29b6b8f/mypy-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a", size = 14146742, upload-time = "2026-07-13T11:33:03.313Z" },
+    { url = "https://files.pythonhosted.org/packages/06/72/6807565b1c4861ef66f7fdd98b51c61556356eab80235717b46c53bb8627/mypy-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36", size = 15081418, upload-time = "2026-07-13T11:31:13.899Z" },
+    { url = "https://files.pythonhosted.org/packages/00/80/1ea14c5d80e589e415973db3e47c78c2219a305b808b2b506395342c1d79/mypy-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461", size = 15328164, upload-time = "2026-07-13T11:31:35.723Z" },
+    { url = "https://files.pythonhosted.org/packages/37/28/8223157404a3d51920078459c37f80fbdc590e1d8ea049dc5ce48643022a/mypy-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd", size = 11136472, upload-time = "2026-07-13T11:27:37.018Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/cc/ea27e5959c5f258585a756b252031f3b313583d81b5064b2bebc41d3706b/mypy-2.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568", size = 10135800, upload-time = "2026-07-13T11:30:08.92Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/0e7e592619e2133596a47cdd642534b0456545c218430bd3b9d8fefdd1b1/mypy-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5", size = 15026523, upload-time = "2026-07-13T11:34:49.206Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/d2/1e1731df090a857df2807177a4626863e5ac0f0256513c35780efe53986f/mypy-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c", size = 14032189, upload-time = "2026-07-13T11:33:57.168Z" },
+    { url = "https://files.pythonhosted.org/packages/44/95/cab921f4a806e171f34113e6181dd23c55358ccf6a80741269ef594a410e/mypy-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491", size = 14198696, upload-time = "2026-07-13T11:32:12.767Z" },
+    { url = "https://files.pythonhosted.org/packages/66/80/e6d008bb19fe446e3662d85e0e2717bf9f2d611a2164fb29d6e067dbf46c/mypy-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7", size = 15286904, upload-time = "2026-07-13T11:34:27.594Z" },
+    { url = "https://files.pythonhosted.org/packages/db/83/94397c9293608a364aa03e8084fb34ede4ae976a260384b9b52929308135/mypy-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3", size = 15528342, upload-time = "2026-07-13T11:34:07.819Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/96/d8b37d819adec6cfccfb1fd3afc1735d94717ddeafb45536db9c6943e09b/mypy-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c", size = 11218346, upload-time = "2026-07-13T11:28:27.745Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/cd/cd9f725b19b19e5b530a154cf9bcf9e94279c5d55b3c34fb42b3aa48ea1b/mypy-2.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595", size = 10204525, upload-time = "2026-07-13T11:31:02.552Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ae/f7d056eb0294586a572d0d0d89580ec633c064db520f11d37d5a2fb833bd/mypy-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97", size = 14947298, upload-time = "2026-07-13T11:27:47.734Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d5/db3e7af01e7844d21662c6ddc1f7825ec7cb4053f0391ac02faf3638396f/mypy-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac", size = 13950768, upload-time = "2026-07-13T11:27:57.726Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/fb/43c031f0190513d1ec248ed037eceb742ddd2a4d74bbf406658a28173837/mypy-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6", size = 14151586, upload-time = "2026-07-13T11:29:18.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/c3/f8b2ffc60883084da91be51af58e88a7ffd4ff9795acb7d902ff88d31eb1/mypy-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b", size = 15227411, upload-time = "2026-07-13T11:30:29.904Z" },
+    { url = "https://files.pythonhosted.org/packages/83/2e/16b917fc7adcf03f1aadddfc93aab804ffb234b1ab09c0ffd6d92a5d34a2/mypy-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2", size = 15478790, upload-time = "2026-07-13T11:33:14.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/88/aaa65a93c73d0cdae7e42f8adb302bf6885bb281302084f99d0290a35347/mypy-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757", size = 11234919, upload-time = "2026-07-13T11:33:39.28Z" },
+    { url = "https://files.pythonhosted.org/packages/35/19/b40de63f1a80e63bc2d40f0679a6a8dbd34e95176c8122119bdf406aa552/mypy-2.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1", size = 10201510, upload-time = "2026-07-13T11:31:52.619Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/fa/fdc54fe583ba3cafbcedfb70eeeaf03849f75b1827a07096c7bd996f582d/mypy-2.3.0-py3-none-any.whl", hash = "sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88", size = 2753292, upload-time = "2026-07-13T11:33:18.48Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "narwhals"
+version = "2.24.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/1d/58946e5aab18393e793bd4add6985b95d0e01c3a2d832f38f54468b10dcd/narwhals-2.24.0.tar.gz", hash = "sha256:b5c0f684ccd9d7475b564111e319a4964abcf2baf79d3cf6b1003d06ac9b828d", size = 661143, upload-time = "2026-07-13T10:49:19.086Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/85/a5bfaebfd305ac18b57b0854d74e37e586809061a91fda62f0bd50c8518e/narwhals-2.24.0-py3-none-any.whl", hash = "sha256:42fdedf44e5b2ca7505630d45b4ac3058f38d8485cba9fe1652ca23152df7489", size = 461030, upload-time = "2026-07-13T10:49:17.571Z" },
+]
+
+[[package]]
+name = "nest-asyncio"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "1.26.4"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/94/ace0fdea5241a27d13543ee117cbc65868e82213fb31a8eb7fe9ff23f313/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0", size = 20631468, upload-time = "2024-02-05T23:48:01.194Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f7/b24208eba89f9d1b58c1668bc6c8c4fd472b20c45573cb767f59d49fb0f6/numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a", size = 13966411, upload-time = "2024-02-05T23:48:29.038Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4", size = 14219016, upload-time = "2024-02-05T23:48:54.098Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d7/ecf66c1cd12dc28b4040b15ab4d17b773b87fa9d29ca16125de01adb36cd/numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f", size = 18240889, upload-time = "2024-02-05T23:49:25.361Z" },
+    { url = "https://files.pythonhosted.org/packages/24/03/6f229fe3187546435c4f6f89f6d26c129d4f5bed40552899fcf1f0bf9e50/numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a", size = 13876746, upload-time = "2024-02-05T23:49:51.983Z" },
+    { url = "https://files.pythonhosted.org/packages/39/fe/39ada9b094f01f5a35486577c848fe274e374bbf8d8f472e1423a0bbd26d/numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2", size = 18078620, upload-time = "2024-02-05T23:50:22.515Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ef/6ad11d51197aad206a9ad2286dc1aac6a378059e06e8cf22cd08ed4f20dc/numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07", size = 5972659, upload-time = "2024-02-05T23:50:35.834Z" },
+    { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" },
+    { url = "https://files.pythonhosted.org/packages/11/57/baae43d14fe163fa0e4c47f307b6b2511ab8d7d30177c491960504252053/numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71", size = 20630554, upload-time = "2024-02-05T23:51:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/2e/151484f49fd03944c4a3ad9c418ed193cfd02724e138ac8a9505d056c582/numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef", size = 13997127, upload-time = "2024-02-05T23:52:15.314Z" },
+    { url = "https://files.pythonhosted.org/packages/79/ae/7e5b85136806f9dadf4878bf73cf223fe5c2636818ba3ab1c585d0403164/numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e", size = 14222994, upload-time = "2024-02-05T23:52:47.569Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/d0/edc009c27b406c4f9cbc79274d6e46d634d139075492ad055e3d68445925/numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5", size = 18252005, upload-time = "2024-02-05T23:53:15.637Z" },
+    { url = "https://files.pythonhosted.org/packages/09/bf/2b1aaf8f525f2923ff6cfcf134ae5e750e279ac65ebf386c75a0cf6da06a/numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a", size = 13885297, upload-time = "2024-02-05T23:53:42.16Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a0/4e0f14d847cfc2a633a1c8621d00724f3206cfeddeb66d35698c4e2cf3d2/numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a", size = 18093567, upload-time = "2024-02-05T23:54:11.696Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b7/a734c733286e10a7f1a8ad1ae8c90f2d33bf604a96548e0a4a3a6739b468/numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20", size = 5968812, upload-time = "2024-02-05T23:54:26.453Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/6b/5610004206cf7f8e7ad91c5a85a8c71b2f2f8051a0c0c4d5916b76d6cbb2/numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2", size = 15811913, upload-time = "2024-02-05T23:54:53.933Z" },
+    { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" },
+    { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868, upload-time = "2024-02-05T23:55:56.28Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109, upload-time = "2024-02-05T23:56:20.368Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172, upload-time = "2024-02-05T23:57:21.56Z" },
+    { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" },
+    { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803, upload-time = "2024-02-05T23:58:08.963Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
+    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" },
+    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" },
+    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" },
+    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" },
+    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" },
+    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" },
+    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" },
+    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.11.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
+    { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
+    { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
+    { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
+    { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
+    { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+    { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+    { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+    { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+    { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+    { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
+    { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.5.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" },
+    { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" },
+    { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" },
+    { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" },
+    { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" },
+    { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" },
+    { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" },
+]
+
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.6.4.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/eb/ff4b8c503fa1f1796679dce648854d58751982426e4e4b37d6fce49d259c/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb", size = 393138322, upload-time = "2024-11-20T17:40:25.65Z" },
+    { url = "https://files.pythonhosted.org/packages/97/0d/f1f0cadbf69d5b9ef2e4f744c9466cb0a850741d08350736dfdb4aa89569/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668", size = 390794615, upload-time = "2024-11-20T17:39:52.715Z" },
+    { url = "https://files.pythonhosted.org/packages/84/f7/985e9bdbe3e0ac9298fcc8cfa51a392862a46a0ffaccbbd56939b62a9c83/nvidia_cublas_cu12-12.6.4.1-py3-none-win_amd64.whl", hash = "sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8", size = 434535301, upload-time = "2024-11-20T17:50:41.681Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.6.80"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/8b/2f6230cb715646c3a9425636e513227ce5c93c4d65823a734f4bb86d43c3/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc", size = 8236764, upload-time = "2024-11-20T17:35:41.03Z" },
+    { url = "https://files.pythonhosted.org/packages/25/0f/acb326ac8fd26e13c799e0b4f3b2751543e1834f04d62e729485872198d4/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.whl", hash = "sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4", size = 8236756, upload-time = "2024-10-01T16:57:45.507Z" },
+    { url = "https://files.pythonhosted.org/packages/49/60/7b6497946d74bcf1de852a21824d63baad12cd417db4195fc1bfe59db953/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132", size = 8917980, upload-time = "2024-11-20T17:36:04.019Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/24/120ee57b218d9952c379d1e026c4479c9ece9997a4fb46303611ee48f038/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73", size = 8917972, upload-time = "2024-10-01T16:58:06.036Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/81/7796f096afaf726796b1b648f3bc80cafc61fe7f77f44a483c89e6c5ef34/nvidia_cuda_cupti_cu12-12.6.80-py3-none-win_amd64.whl", hash = "sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a", size = 5724175, upload-time = "2024-10-01T17:09:47.955Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.6.77"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/2f/72df534873235983cc0a5371c3661bebef7c4682760c275590b972c7b0f9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13", size = 23162955, upload-time = "2024-10-01T16:59:50.922Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2e/46030320b5a80661e88039f59060d1790298b4718944a65a7f2aeda3d9e9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53", size = 23650380, upload-time = "2024-10-01T17:00:14.643Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/46/d3a1cdda8bb113c80f43a0a6f3a853356d487b830f3483f92d49ce87fa55/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a", size = 39026742, upload-time = "2024-10-01T17:10:49.058Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.6.77"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/ea/590b2ac00d772a8abd1c387a92b46486d2679ca6622fd25c18ff76265663/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd", size = 908052, upload-time = "2024-11-20T17:35:19.905Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/3d/159023799677126e20c8fd580cca09eeb28d5c5a624adc7f793b9aa8bbfa/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e", size = 908040, upload-time = "2024-10-01T16:57:22.221Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/23/e717c5ac26d26cf39a27fbc076240fad2e3b817e5889d671b67f4f9f49c5/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7", size = 897690, upload-time = "2024-11-20T17:35:30.697Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/62/65c05e161eeddbafeca24dc461f47de550d9fa8a7e04eb213e32b55cfd99/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8", size = 897678, upload-time = "2024-10-01T16:57:33.821Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/76/4c80fa138333cc975743fd0687a745fccb30d167f906f13c1c7f9a85e5ea/nvidia_cuda_runtime_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f", size = 891773, upload-time = "2024-10-01T17:09:26.362Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.5.1.17"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/93/a201a12d3ec1caa8c6ac34c1c2f9eeb696b886f0c36ff23c638b46603bd0/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def", size = 570523509, upload-time = "2024-10-25T19:53:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/78/4535c9c7f859a64781e43c969a3a7e84c54634e319a996d43ef32ce46f83/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2", size = 570988386, upload-time = "2024-10-25T19:54:26.39Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/b2/3f60d15f037fa5419d9d7f788b100ef33ea913ae5315c87ca6d6fa606c35/nvidia_cudnn_cu12-9.5.1.17-py3-none-win_amd64.whl", hash = "sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8", size = 565440743, upload-time = "2024-10-25T19:55:49.74Z" },
+]
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.3.0.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/37/c50d2b2f2c07e146776389e3080f4faf70bcc4fa6e19d65bb54ca174ebc3/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6", size = 200164144, upload-time = "2024-11-20T17:40:58.288Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/f5/188566814b7339e893f8d210d3a5332352b1409815908dad6a363dcceac1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb", size = 200164135, upload-time = "2024-10-01T17:03:24.212Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/16/73727675941ab8e6ffd86ca3a4b7b47065edcca7a997920b831f8147c99d/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5", size = 200221632, upload-time = "2024-11-20T17:41:32.357Z" },
+    { url = "https://files.pythonhosted.org/packages/60/de/99ec247a07ea40c969d904fc14f3a356b3e2a704121675b75c366b694ee1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.whl", hash = "sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca", size = 200221622, upload-time = "2024-10-01T17:03:58.79Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/38/36fd800cec8f6e89b7c1576edaaf8076e69ec631644cdbc1b5f2e2b5a9df/nvidia_cufft_cu12-11.3.0.4-py3-none-win_amd64.whl", hash = "sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464", size = 199356881, upload-time = "2024-10-01T17:13:01.861Z" },
+]
+
+[[package]]
+name = "nvidia-cufile-cu12"
+version = "1.11.1.6"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/66/cc9876340ac68ae71b15c743ddb13f8b30d5244af344ec8322b449e35426/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159", size = 1142103, upload-time = "2024-11-20T17:42:11.83Z" },
+    { url = "https://files.pythonhosted.org/packages/17/bf/cc834147263b929229ce4aadd62869f0b195e98569d4c28b23edc72b85d9/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db", size = 1066155, upload-time = "2024-11-20T17:41:49.376Z" },
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.7.77"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/ac/36543605358a355632f1a6faa3e2d5dfb91eab1e4bc7d552040e0383c335/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8", size = 56289881, upload-time = "2024-10-01T17:04:18.981Z" },
+    { url = "https://files.pythonhosted.org/packages/73/1b/44a01c4e70933637c93e6e1a8063d1e998b50213a6b65ac5a9169c47e98e/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf", size = 56279010, upload-time = "2024-11-20T17:42:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/aa/2c7ff0b5ee02eaef890c0ce7d4f74bc30901871c5e45dee1ae6d0083cd80/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117", size = 56279000, upload-time = "2024-10-01T17:04:45.274Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/5362a9396f23f7de1dd8a64369e87c85ffff8216fc8194ace0fa45ba27a5/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e", size = 56289882, upload-time = "2024-11-20T17:42:25.222Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/a8/0cd0cec757bd4b4b4ef150fca62ec064db7d08a291dced835a0be7d2c147/nvidia_curand_cu12-10.3.7.77-py3-none-win_amd64.whl", hash = "sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905", size = 55783873, upload-time = "2024-10-01T17:13:30.377Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12" },
+    { name = "nvidia-cusparse-cu12" },
+    { name = "nvidia-nvjitlink-cu12" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/17/dbe1aa865e4fdc7b6d4d0dd308fdd5aaab60f939abfc0ea1954eac4fb113/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0", size = 157833628, upload-time = "2024-10-01T17:05:05.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/6e/c2cf12c9ff8b872e92b4a5740701e51ff17689c4d726fca91875b07f655d/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c", size = 158229790, upload-time = "2024-11-20T17:43:43.211Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/baba53585da791d043c10084cf9553e074548408e04ae884cfe9193bd484/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6", size = 158229780, upload-time = "2024-10-01T17:05:39.875Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/5f/07d0ba3b7f19be5a5ec32a8679fc9384cfd9fc6c869825e93be9f28d6690/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e", size = 157833630, upload-time = "2024-11-20T17:43:16.77Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/53/fff50a0808df7113d77e3bbc7c2b7eaed6f57d5eb80fbe93ead2aea1e09a/nvidia_cusolver_cu12-11.7.1.2-py3-none-win_amd64.whl", hash = "sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7", size = 149287877, upload-time = "2024-10-01T17:13:49.804Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/eb/6681efd0aa7df96b4f8067b3ce7246833dd36830bb4cec8896182773db7d/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887", size = 216451147, upload-time = "2024-11-20T17:44:18.055Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/56/3af21e43014eb40134dea004e8d0f1ef19d9596a39e4d497d5a7de01669f/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1", size = 216451135, upload-time = "2024-10-01T17:06:03.826Z" },
+    { url = "https://files.pythonhosted.org/packages/06/1e/b8b7c2f4099a37b96af5c9bb158632ea9e5d9d27d7391d7eb8fc45236674/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73", size = 216561367, upload-time = "2024-11-20T17:44:54.824Z" },
+    { url = "https://files.pythonhosted.org/packages/43/ac/64c4316ba163e8217a99680c7605f779accffc6a4bcd0c778c12948d3707/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f", size = 216561357, upload-time = "2024-10-01T17:06:29.861Z" },
+    { url = "https://files.pythonhosted.org/packages/45/ef/876ad8e4260e1128e6d4aac803d9d51baf3791ebdb4a9b8d9b8db032b4b0/nvidia_cusparse_cu12-12.5.4.2-py3-none-win_amd64.whl", hash = "sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20", size = 213712630, upload-time = "2024-10-01T17:14:23.779Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu12"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/da/4de092c61c6dea1fc9c936e69308a02531d122e12f1f649825934ad651b5/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1", size = 156402859, upload-time = "2024-10-16T02:23:17.184Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/9a/72ef35b399b0e183bc2e8f6f558036922d453c4d8237dab26c666a04244b/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46", size = 156785796, upload-time = "2024-10-15T21:29:17.709Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3e/9e1e394a02a06f694be2c97bbe47288bb7c90ea84c7e9cf88f7b28afe165/nvidia_cusparselt_cu12-0.6.3-py3-none-win_amd64.whl", hash = "sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7", size = 155595972, upload-time = "2024-10-15T22:58:35.426Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.26.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/5b/ca2f213f637305633814ae8c36b153220e40a07ea001966dcd87391f3acb/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522", size = 291671495, upload-time = "2025-03-13T00:30:07.805Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ca/f42388aed0fddd64ade7493dbba36e1f534d4e6fdbdd355c6a90030ae028/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6", size = 201319755, upload-time = "2025-03-13T00:29:55.296Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.6.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/d7/c5383e47c7e9bf1c99d5bd2a8c935af2b6d705ad831a7ec5c97db4d82f4f/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a", size = 19744971, upload-time = "2024-11-20T17:46:53.366Z" },
+    { url = "https://files.pythonhosted.org/packages/31/db/dc71113d441f208cdfe7ae10d4983884e13f464a6252450693365e166dcf/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41", size = 19270338, upload-time = "2024-11-20T17:46:29.758Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/93c1467b1387387440a4d25102d86b7794535449b689f8e2dc22c1c8ff7f/nvidia_nvjitlink_cu12-12.6.85-py3-none-win_amd64.whl", hash = "sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c", size = 161908572, upload-time = "2024-11-20T17:52:40.124Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx-cu12"
+version = "12.6.77"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/93/80f8a520375af9d7ee44571a6544653a176e53c2b8ccce85b97b83c2491b/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b", size = 90549, upload-time = "2024-11-20T17:38:17.387Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/53/36e2fd6c7068997169b49ffc8c12d5af5e5ff209df6e1a2c4d373b3a638f/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059", size = 90539, upload-time = "2024-10-01T17:00:27.179Z" },
+    { url = "https://files.pythonhosted.org/packages/56/9a/fff8376f8e3d084cd1530e1ef7b879bb7d6d265620c95c1b322725c694f4/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2", size = 89276, upload-time = "2024-11-20T17:38:27.621Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4e/0d0c945463719429b7bd21dece907ad0bde437a2ff12b9b12fee94722ab0/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1", size = 89265, upload-time = "2024-10-01T17:00:38.172Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/cd/98a447919d4ed14d407ac82b14b0a0c9c1dbfe81099934b1fc3bfd1e6316/nvidia_nvtx_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0", size = 56434, upload-time = "2024-10-01T17:11:13.124Z" },
+]
+
+[[package]]
+name = "objectbox"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "flatbuffers" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/b9/09f6521a35842542fe889a357722a35ff81ddcbed48ac9c086d996bec50b/objectbox-4.0.0-py3-none-any.whl", hash = "sha256:eb1281660ede3923501c47a68c6ad97e551c44061828530731525c7b271cfb2f", size = 4015576, upload-time = "2024-05-28T10:57:40.771Z" },
+]
+
+[[package]]
+name = "onnx"
+version = "1.18.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+]
+dependencies = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "protobuf", marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "typing-extensions", marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/60/e56e8ec44ed34006e6d4a73c92a04d9eea6163cc12440e35045aec069175/onnx-1.18.0.tar.gz", hash = "sha256:3d8dbf9e996629131ba3aa1afd1d8239b660d1f830c6688dd7e03157cccd6b9c", size = 12563009, upload-time = "2025-05-12T22:03:09.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/e3/ab8a09c0af43373e0422de461956a1737581325260659aeffae22a7dad18/onnx-1.18.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:4a3b50d94620e2c7c1404d1d59bc53e665883ae3fecbd856cc86da0639fd0fc3", size = 18280145, upload-time = "2025-05-12T22:01:49.875Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5b/3cfd183961a0a872fe29c95f8d07264890ec65c75c94b99a4dabc950df29/onnx-1.18.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e189652dad6e70a0465035c55cc565c27aa38803dd4f4e74e4b952ee1c2de94b", size = 17422721, upload-time = "2025-05-12T22:01:52.841Z" },
+    { url = "https://files.pythonhosted.org/packages/58/52/fa649429016c5790f68c614cdebfbefd3e72ba1c458966305297d540f713/onnx-1.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfb1f271b1523b29f324bfd223f6a4cfbdc5a2f2f16e73563671932d33663365", size = 17584220, upload-time = "2025-05-12T22:01:56.458Z" },
+    { url = "https://files.pythonhosted.org/packages/42/52/dc166de41a5f72738b0bdfb2a19e0ebe4743cf3ecc9ae381ea3425bcb332/onnx-1.18.0-cp310-cp310-win32.whl", hash = "sha256:e03071041efd82e0317b3c45433b2f28146385b80f26f82039bc68048ac1a7a0", size = 15734494, upload-time = "2025-05-12T22:01:59.704Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/f9/e766a3b85b7651ddfc5f9648e0e9dc24e88b7e88ea7f8c23187530e818ea/onnx-1.18.0-cp310-cp310-win_amd64.whl", hash = "sha256:9235b3493951e11e75465d56f4cd97e3e9247f096160dd3466bfabe4cbc938bc", size = 15848421, upload-time = "2025-05-12T22:02:03.01Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/3a/a336dac4db1eddba2bf577191e5b7d3e4c26fcee5ec518a5a5b11d13540d/onnx-1.18.0-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:735e06d8d0cf250dc498f54038831401063c655a8d6e5975b2527a4e7d24be3e", size = 18281831, upload-time = "2025-05-12T22:02:06.429Z" },
+    { url = "https://files.pythonhosted.org/packages/02/3a/56475a111120d1e5d11939acbcbb17c92198c8e64a205cd68e00bdfd8a1f/onnx-1.18.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:73160799472e1a86083f786fecdf864cf43d55325492a9b5a1cfa64d8a523ecc", size = 17424359, upload-time = "2025-05-12T22:02:09.866Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/03/5eb5e9ef446ed9e78c4627faf3c1bc25e0f707116dd00e9811de232a8df5/onnx-1.18.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6acafb3823238bbe8f4340c7ac32fb218689442e074d797bee1c5c9a02fdae75", size = 17586006, upload-time = "2025-05-12T22:02:13.217Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/4e/70943125729ce453271a6e46bb847b4a612496f64db6cbc6cb1f49f41ce1/onnx-1.18.0-cp311-cp311-win32.whl", hash = "sha256:4c8c4bbda760c654e65eaffddb1a7de71ec02e60092d33f9000521f897c99be9", size = 15734988, upload-time = "2025-05-12T22:02:16.561Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b0/435fd764011911e8f599e3361f0f33425b1004662c1ea33a0ad22e43db2d/onnx-1.18.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5810194f0f6be2e58c8d6dedc6119510df7a14280dd07ed5f0f0a85bd74816a", size = 15849576, upload-time = "2025-05-12T22:02:19.569Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f0/9e31f4b4626d60f1c034f71b411810bc9fafe31f4e7dd3598effd1b50e05/onnx-1.18.0-cp311-cp311-win_arm64.whl", hash = "sha256:aa1b7483fac6cdec26922174fc4433f8f5c2f239b1133c5625063bb3b35957d0", size = 15822961, upload-time = "2025-05-12T22:02:22.735Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fe/16228aca685392a7114625b89aae98b2dc4058a47f0f467a376745efe8d0/onnx-1.18.0-cp312-cp312-macosx_12_0_universal2.whl", hash = "sha256:521bac578448667cbb37c50bf05b53c301243ede8233029555239930996a625b", size = 18285770, upload-time = "2025-05-12T22:02:26.116Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/77/ba50a903a9b5e6f9be0fa50f59eb2fca4a26ee653375408fbc72c3acbf9f/onnx-1.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4da451bf1c5ae381f32d430004a89f0405bc57a8471b0bddb6325a5b334aa40", size = 17421291, upload-time = "2025-05-12T22:02:29.645Z" },
+    { url = "https://files.pythonhosted.org/packages/11/23/25ec2ba723ac62b99e8fed6d7b59094dadb15e38d4c007331cc9ae3dfa5f/onnx-1.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99afac90b4cdb1471432203c3c1f74e16549c526df27056d39f41a9a47cfb4af", size = 17584084, upload-time = "2025-05-12T22:02:32.789Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/4d/2c253a36070fb43f340ff1d2c450df6a9ef50b938adcd105693fee43c4ee/onnx-1.18.0-cp312-cp312-win32.whl", hash = "sha256:ee159b41a3ae58d9c7341cf432fc74b96aaf50bd7bb1160029f657b40dc69715", size = 15734892, upload-time = "2025-05-12T22:02:35.527Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/92/048ba8fafe6b2b9a268ec2fb80def7e66c0b32ab2cae74de886981f05a27/onnx-1.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:102c04edc76b16e9dfeda5a64c1fccd7d3d2913b1544750c01d38f1ac3c04e05", size = 15850336, upload-time = "2025-05-12T22:02:38.545Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/66/bbc4ffedd44165dcc407a51ea4c592802a5391ce3dc94aa5045350f64635/onnx-1.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:911b37d724a5d97396f3c2ef9ea25361c55cbc9aa18d75b12a52b620b67145af", size = 15823802, upload-time = "2025-05-12T22:02:42.037Z" },
+    { url = "https://files.pythonhosted.org/packages/45/da/9fb8824513fae836239276870bfcc433fa2298d34ed282c3a47d3962561b/onnx-1.18.0-cp313-cp313-macosx_12_0_universal2.whl", hash = "sha256:030d9f5f878c5f4c0ff70a4545b90d7812cd6bfe511de2f3e469d3669c8cff95", size = 18285906, upload-time = "2025-05-12T22:02:45.01Z" },
+    { url = "https://files.pythonhosted.org/packages/05/e8/762b5fb5ed1a2b8e9a4bc5e668c82723b1b789c23b74e6b5a3356731ae4e/onnx-1.18.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8521544987d713941ee1e591520044d35e702f73dc87e91e6d4b15a064ae813d", size = 17421486, upload-time = "2025-05-12T22:02:48.467Z" },
+    { url = "https://files.pythonhosted.org/packages/12/bb/471da68df0364f22296456c7f6becebe0a3da1ba435cdb371099f516da6e/onnx-1.18.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c137eecf6bc618c2f9398bcc381474b55c817237992b169dfe728e169549e8f", size = 17583581, upload-time = "2025-05-12T22:02:51.784Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0d/01a95edc2cef6ad916e04e8e1267a9286f15b55c90cce5d3cdeb359d75d6/onnx-1.18.0-cp313-cp313-win32.whl", hash = "sha256:6c093ffc593e07f7e33862824eab9225f86aa189c048dd43ffde207d7041a55f", size = 15734621, upload-time = "2025-05-12T22:02:54.62Z" },
+    { url = "https://files.pythonhosted.org/packages/64/95/253451a751be32b6173a648b68f407188009afa45cd6388780c330ff5d5d/onnx-1.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:230b0fb615e5b798dc4a3718999ec1828360bc71274abd14f915135eab0255f1", size = 15850472, upload-time = "2025-05-12T22:02:57.54Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b1/6fd41b026836df480a21687076e0f559bc3ceeac90f2be8c64b4a7a1f332/onnx-1.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:6f91930c1a284135db0f891695a263fc876466bf2afbd2215834ac08f600cfca", size = 15823808, upload-time = "2025-05-12T22:03:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f3/499e53dd41fa7302f914dd18543da01e0786a58b9a9d347497231192001f/onnx-1.18.0-cp313-cp313t-macosx_12_0_universal2.whl", hash = "sha256:2f4d37b0b5c96a873887652d1cbf3f3c70821b8c66302d84b0f0d89dd6e47653", size = 18316526, upload-time = "2025-05-12T22:03:03.691Z" },
+    { url = "https://files.pythonhosted.org/packages/84/dd/6abe5d7bd23f5ed3ade8352abf30dff1c7a9e97fc1b0a17b5d7c726e98a9/onnx-1.18.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a69afd0baa372162948b52c13f3aa2730123381edf926d7ef3f68ca7cec6d0d0", size = 15865055, upload-time = "2025-05-12T22:03:06.663Z" },
+]
+
+[[package]]
+name = "onnx"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "ml-dtypes", marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "protobuf", marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "typing-extensions", marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/19/8ea73a64b368b75fe339771a20a02bc61ea1f551484c9e3d9d0bfbd0450f/onnx-1.22.0.tar.gz", hash = "sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0", size = 12024721, upload-time = "2026-06-15T12:50:05.354Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/04/471f234e2716c83f17a26e1b50cd64c39428373e91dd018aafb3d499c108/onnx-1.22.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4", size = 20167110, upload-time = "2026-06-15T12:48:59.152Z" },
+    { url = "https://files.pythonhosted.org/packages/99/40/540a2fe3c49ce1709ff2015de20d9a351264fb442f8998f92cf0ba7e279e/onnx-1.22.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc", size = 18892738, upload-time = "2026-06-15T12:49:02.139Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/0c/f41d5b89c38fb2ec410ab23c24fa110af786093b140644f7f953e436743b/onnx-1.22.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573", size = 19110354, upload-time = "2026-06-15T12:49:05.031Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8e/9f41d132855e93c2808cdd4afab1b5af67bd5e82e4a4fa9248006e4df87e/onnx-1.22.0-cp310-cp310-win32.whl", hash = "sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec", size = 17083595, upload-time = "2026-06-15T12:49:08.599Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/52/86caff81786a5428485795c79175ae2b12a630795bcb267b84e5f9e98450/onnx-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b", size = 17215270, upload-time = "2026-06-15T12:49:11.483Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/55/30825c02c92a0380ce84c3feeeec95d329fa77548ba58cb10ad4bbfd83c6/onnx-1.22.0-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914", size = 20167891, upload-time = "2026-06-15T12:49:14.212Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/24/cd4ab52ecaf41c3fbed674772ccbfe39041cb257b8471a47a37e48bff3f8/onnx-1.22.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6", size = 18892720, upload-time = "2026-06-15T12:49:16.904Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/a0/c9d9d56ceadb1c0a90a7cbec5a0510520ab6538938944fa84548e4b5b054/onnx-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5", size = 19110720, upload-time = "2026-06-15T12:49:19.812Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/e43e5a68d9cadde55df75310027f87127333a77e5ddcea14c73e96a10cac/onnx-1.22.0-cp311-cp311-win32.whl", hash = "sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c", size = 17083746, upload-time = "2026-06-15T12:49:22.935Z" },
+    { url = "https://files.pythonhosted.org/packages/54/57/cc0a9f2cf4522e42829d089927b4b75924d32f50dca237482e7b741df003/onnx-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da", size = 17215684, upload-time = "2026-06-15T12:49:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/99/0f049f9eaa06c8383060c5f0a338e3a6caac8822e6e326c9162f05abf95a/onnx-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58", size = 17210398, upload-time = "2026-06-15T12:49:29.091Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/6a/481561f1093834376ed493e4ca42a73e5be0d50031f2969c86593bdc7c96/onnx-1.22.0-cp312-abi3-macosx_12_0_universal2.whl", hash = "sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103", size = 20167081, upload-time = "2026-06-15T12:49:32.078Z" },
+    { url = "https://files.pythonhosted.org/packages/84/55/b34fc2aa30aa54b4a775402d24c4082242c720283a274fe976ac8eb94480/onnx-1.22.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16", size = 18889249, upload-time = "2026-06-15T12:49:34.7Z" },
+    { url = "https://files.pythonhosted.org/packages/09/a6/bd32357e6cc1ecb473afd78193d7231724f284435d2db25696ecfaaa1503/onnx-1.22.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b", size = 19106514, upload-time = "2026-06-15T12:49:37.424Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9d/3af461ac6c714b8b369cb71499659932f4f12cfb066250b62f7567c3d530/onnx-1.22.0-cp312-abi3-pyemscripten_2025_0_wasm32.whl", hash = "sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c", size = 16966387, upload-time = "2026-06-15T12:49:40.918Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/f0/68195b5e5a53e333faf2660f5352ee43738d0e42fc5216cc6b1871a9fbfb/onnx-1.22.0-cp312-abi3-win32.whl", hash = "sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016", size = 17081568, upload-time = "2026-06-15T12:49:43.398Z" },
+    { url = "https://files.pythonhosted.org/packages/13/a8/734725bb703c5fabb687f79c79e51249475212b3eb37771ac4a4ac9b487f/onnx-1.22.0-cp312-abi3-win_amd64.whl", hash = "sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a", size = 17213290, upload-time = "2026-06-15T12:49:45.933Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2a/8ce48d8ae26a8761ad4e5dc771961b155c5c3c7c8540ec7f2f2d71b69af0/onnx-1.22.0-cp312-abi3-win_arm64.whl", hash = "sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f", size = 17207030, upload-time = "2026-06-15T12:49:48.635Z" },
+]
+
+[[package]]
+name = "onnx-ir"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "sympy" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/35/e6/672fefb2f108d077f58181a7babf4c0f8d1182a30353ffc9c79c63afc5ee/onnx_ir-0.2.1.tar.gz", hash = "sha256:8b8b10a93f43e65962104de6070c43c5dacb0e3cdfefc7c8059dd83c9db64f35", size = 144279, upload-time = "2026-04-20T20:21:47.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/aa/f7a53321c60b9ad9ee184b6018292ed6b5389947592a2c8c09c736bb7f9e/onnx_ir-0.2.1-py3-none-any.whl", hash = "sha256:c7285da889312f91882de2092e298a9eeeefbfc1d1951c49d983992967eb09a7", size = 166792, upload-time = "2026-04-20T20:21:46.357Z" },
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.24.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "flatbuffers", marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "packaging", marker = "python_full_version < '3.11'" },
+    { name = "protobuf", marker = "python_full_version < '3.11'" },
+    { name = "sympy", marker = "python_full_version < '3.11'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/41/3253db975a90c3ce1d475e2a230773a21cd7998537f0657947df6fb79861/onnxruntime-1.24.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3e6456801c66b095c5cd68e690ca25db970ea5202bd0c5b84a2c3ef7731c5a3c", size = 17332766, upload-time = "2026-03-05T17:18:59.714Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/c5/3af6b325f1492d691b23844d88ed26844c1164620860c5efe95c0e22782d/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b2ebc54c6d8281dccff78d4b06e47d4cf07535937584ab759448390a70f4978", size = 15130330, upload-time = "2026-03-05T16:34:53.831Z" },
+    { url = "https://files.pythonhosted.org/packages/03/4b/f96b46c1866a293ed23ca2cf5e5a63d413ad3a951da60dd877e3c56cbbca/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb56575d7794bf0781156955610c9e651c9504c64d42ec880784b6106244882d", size = 17213247, upload-time = "2026-03-05T17:17:59.812Z" },
+    { url = "https://files.pythonhosted.org/packages/36/13/27cf4d8df2578747584e8758aeb0b673b60274048510257f1f084b15e80e/onnxruntime-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:c958222ef9eff54018332beecd32d5d94a3ab079d8821937b333811bf4da0d39", size = 12595530, upload-time = "2026-03-05T17:18:49.356Z" },
+    { url = "https://files.pythonhosted.org/packages/19/8c/6d9f31e6bae72a8079be12ed8ba36c4126a571fad38ded0a1b96f60f6896/onnxruntime-1.24.3-cp311-cp311-win_arm64.whl", hash = "sha256:a8f761857ebaf58a85b9e42422d03207f1d39e6bb8fecfdbf613bac5b9710723", size = 12261715, upload-time = "2026-03-05T17:18:39.699Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7f/dfdc4e52600fde4c02d59bfe98c4b057931c1114b701e175aee311a9bc11/onnxruntime-1.24.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:0d244227dc5e00a9ae15a7ac1eba4c4460d7876dfecafe73fb00db9f1d914d91", size = 17342578, upload-time = "2026-03-05T17:19:02.403Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/dc/1f5489f7b21817d4ad352bf7a92a252bd5b438bcbaa7ad20ea50814edc79/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a9847b870b6cb462652b547bc98c49e0efb67553410a082fde1918a38707452", size = 15150105, upload-time = "2026-03-05T16:34:56.897Z" },
+    { url = "https://files.pythonhosted.org/packages/28/7c/fd253da53594ab8efbefdc85b3638620ab1a6aab6eb7028a513c853559ce/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b354afce3333f2859c7e8706d84b6c552beac39233bcd3141ce7ab77b4cabb5d", size = 17237101, upload-time = "2026-03-05T17:18:02.561Z" },
+    { url = "https://files.pythonhosted.org/packages/71/5f/eaabc5699eeed6a9188c5c055ac1948ae50138697a0428d562ac970d7db5/onnxruntime-1.24.3-cp312-cp312-win_amd64.whl", hash = "sha256:44ea708c34965439170d811267c51281d3897ecfc4aa0087fa25d4a4c3eb2e4a", size = 12597638, upload-time = "2026-03-05T17:18:52.141Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/5c/d8066c320b90610dbeb489a483b132c3b3879b2f93f949fb5d30cfa9b119/onnxruntime-1.24.3-cp312-cp312-win_arm64.whl", hash = "sha256:48d1092b44ca2ba6f9543892e7c422c15a568481403c10440945685faf27a8d8", size = 12270943, upload-time = "2026-03-05T17:18:42.006Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8d/487ece554119e2991242d4de55de7019ac6e47ee8dfafa69fcf41d37f8ed/onnxruntime-1.24.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:34a0ea5ff191d8420d9c1332355644148b1bf1a0d10c411af890a63a9f662aa7", size = 17342706, upload-time = "2026-03-05T16:35:10.813Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/25/8b444f463c1ac6106b889f6235c84f01eec001eaf689c3eff8c69cf48fae/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fd2ec7bb0fabe42f55e8337cfc9b1969d0d14622711aac73d69b4bd5abb5ed7", size = 15149956, upload-time = "2026-03-05T16:34:59.264Z" },
+    { url = "https://files.pythonhosted.org/packages/34/fc/c9182a3e1ab46940dd4f30e61071f59eee8804c1f641f37ce6e173633fb6/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df8e70e732fe26346faaeec9147fa38bef35d232d2495d27e93dd221a2d473a9", size = 17237370, upload-time = "2026-03-05T17:18:05.258Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7e/3b549e1f4538514118bff98a1bcd6481dd9a17067f8c9af77151621c9a5c/onnxruntime-1.24.3-cp313-cp313-win_amd64.whl", hash = "sha256:2d3706719be6ad41d38a2250998b1d87758a20f6ea4546962e21dc79f1f1fd2b", size = 12597939, upload-time = "2026-03-05T17:18:54.772Z" },
+    { url = "https://files.pythonhosted.org/packages/80/41/9696a5c4631a0caa75cc8bc4efd30938fd483694aa614898d087c3ee6d29/onnxruntime-1.24.3-cp313-cp313-win_arm64.whl", hash = "sha256:b082f3ba9519f0a1a1e754556bc7e635c7526ef81b98b3f78da4455d25f0437b", size = 12270705, upload-time = "2026-03-05T17:18:44.774Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/65/a26c5e59e3b210852ee04248cf8843c81fe7d40d94cf95343b66efe7eec9/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72f956634bc2e4bd2e8b006bef111849bd42c42dea37bd0a4c728404fdaf4d34", size = 15161796, upload-time = "2026-03-05T16:35:02.871Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/25/2035b4aa2ccb5be6acf139397731ec507c5f09e199ab39d3262b22ffa1ac/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78d1f25eed4ab9959db70a626ed50ee24cf497e60774f59f1207ac8556399c4d", size = 17240936, upload-time = "2026-03-05T17:18:09.534Z" },
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.27.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "flatbuffers", marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.11.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.11.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and extra == 'extra-18-mobiletransformers-export') or (python_full_version >= '3.12' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version >= '3.12' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging", marker = "python_full_version >= '3.11'" },
+    { name = "protobuf", marker = "python_full_version >= '3.11'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/e4/5353d7e09ced4a8f473f843223fc75d726b2b5519dcefc12f22a6c92852d/onnxruntime-1.27.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:8ba14a38c570087f3cdb8cfba33f7a38a1e826c1e5b29e17c28ceda0cc910016", size = 18416484, upload-time = "2026-06-15T22:43:43.894Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1f/a2117aa3f144fce88774efa37440d0ca72d0c9144854dfc0961f2b04c6fc/onnxruntime-1.27.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2eb083321af8a236a84c7c140a7f4cecbfa2a987a18c07c78db471c20cd390ef", size = 16419330, upload-time = "2026-06-15T22:42:37.58Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/cd/74bb804170ceb622fda9111df31a07b3024f7491472256d3a90b5391a4d2/onnxruntime-1.27.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e4f7b0e90d2d212e2c2deaa6c8291616183ab815d3ec558ea12d3ac8b26d36f4", size = 18636930, upload-time = "2026-06-15T22:43:01.584Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/8f/5b8e2b85e81735696887175dbaf6409f215683f5ca9d4928fbb038211d32/onnxruntime-1.27.0-cp311-cp311-win_amd64.whl", hash = "sha256:ff050e4f6bf7f12918fa14dcb047c0b02e295f35e86d42532552be4b3d54e977", size = 13356110, upload-time = "2026-06-15T22:43:32.172Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3a/4f568de678126b6a371a93862f015a82138359decd97fcac61fc84b5b774/onnxruntime-1.27.0-cp311-cp311-win_arm64.whl", hash = "sha256:75fbc1e1fb43a39a856c8209c544cca7817b5de7ac16b15b1bdf55d1cc67b9df", size = 13098635, upload-time = "2026-06-15T22:43:19.607Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/b7/dd3a524ed93a820dff1af902d0412957ab12499953333e9daa01af5bc480/onnxruntime-1.27.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a14c2ce45312def86b77aea651f46565e45960cf5f0721bfdff449165086ab76", size = 18433506, upload-time = "2026-06-15T22:43:47.026Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/c3b6b17745a1997d784dadc9bd88d713d2e6721139a5a0e885b28cfb79b1/onnxruntime-1.27.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fddce0539a4898c7bef35b052ffd37935b2190e35488eab99ce91887743ea1", size = 16438140, upload-time = "2026-06-15T22:42:40.666Z" },
+    { url = "https://files.pythonhosted.org/packages/26/81/24dd9b31b0fb912ee19ca53ac1c9764bfd79d58a2ccef564eb693be831a5/onnxruntime-1.27.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c65a7438632d55dfbc8a02ee60bd6cf7dd9d1ba05a43d4b851452f32338e194", size = 18658316, upload-time = "2026-06-15T22:43:04.012Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/88/8ec9db1a4d126bb8b758992beb40d1249df171917d75f44a327eb5f20dda/onnxruntime-1.27.0-cp312-cp312-win_amd64.whl", hash = "sha256:20c321cf187ba496e648acf6b4cf90b4d398b0d17c2a77fdaeba365b908cc1c1", size = 13358769, upload-time = "2026-06-15T22:43:34.581Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/9f/fdad359dfcba7e7cd8815569b304a596531d4efa77a75d77f8b4981891a2/onnxruntime-1.27.0-cp312-cp312-win_arm64.whl", hash = "sha256:d0d1f68868e2ef30ef70998ba9bbbc5c305e9b17041e3936751c1b8aa6aade06", size = 13104440, upload-time = "2026-06-15T22:43:22.893Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/2b/54208fd03ad410480bc17edf4869376362da8bbf46fe186ddf4cb5cc20fe/onnxruntime-1.27.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:b3e5b58b8c89c2b20e086e890aa9527377e5c240dc3ecc1640d18e07705eeb1c", size = 18432958, upload-time = "2026-06-15T22:42:53.105Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/24fc51fcbb126da6d032372314e47b55c3faad58f2aa78c0e199ccd20b9c/onnxruntime-1.27.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48b3d87eb560ff6a772240506f3c78d6d27c63cafedd5c775672e1194f968cfd", size = 16438180, upload-time = "2026-06-15T22:42:43.093Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/19/14929c3c2fe0b79b41cce24463062bf3afa4cdd3c19dccf00319caa92bff/onnxruntime-1.27.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6872443f236a554921cda6f318c900e2d0c226792cf3534d00e5057c6926e5d2", size = 18658445, upload-time = "2026-06-15T22:43:08.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/76/59ed932b0244acd7bbbd6449480053a6d958ea66357f022f932872e19287/onnxruntime-1.27.0-cp313-cp313-win_amd64.whl", hash = "sha256:760021bca514d64a811837820d351a08a41741f16f8b4c26450da708fecf14e6", size = 13357856, upload-time = "2026-06-15T22:43:37.315Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/d1ec60ec7b1e2ae2d7340ba52b8a13529140039cd4407ba8dddbbc046582/onnxruntime-1.27.0-cp313-cp313-win_arm64.whl", hash = "sha256:2fdfa9df40a0ded0028ce6f9cd863264237f3970559dea2b81456e9ac4622b94", size = 13104412, upload-time = "2026-06-15T22:43:27.457Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/7d/e6bb1c6445c94f708c38cd8fbb7bf0264108c33498b9445c93e60fe6d329/onnxruntime-1.27.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54c0c4e9202c36c4ecdb1f3443f5dfbfd5ee3b54d1362c4b4c6134110e74fb32", size = 16443331, upload-time = "2026-06-15T22:42:45.649Z" },
+    { url = "https://files.pythonhosted.org/packages/72/1b/b18b31e806eabc41077810199fbbb36fbc2d5f19912416e5ccfbf73053d1/onnxruntime-1.27.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1b215aa662c8f983f7d6dedafe65a9be72c26e5338e0fe98b3e0422c32c85428", size = 18670967, upload-time = "2026-06-15T22:43:10.621Z" },
+]
+
+[[package]]
+name = "onnxruntime-genai"
+version = "0.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.11.*' and extra != 'extra-18-mobiletransformers-export' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version >= '3.12' and extra != 'extra-18-mobiletransformers-export' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnxruntime", version = "1.27.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/4c/d7d6a6c6170d69c75c8ff59e7f8e8b0fafc7fda233af5625a761cf82928f/onnxruntime_genai-0.14.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0a075530fc8b501cfcefc8c2ba13c17dc7ae74580f6369a7d1295ba7c5f6470b", size = 3809272, upload-time = "2026-06-02T20:36:12.256Z" },
+    { url = "https://files.pythonhosted.org/packages/64/99/edb08bcade709157bcf1bfdbe624569aba8a69c0539065bd7dc303efc65f/onnxruntime_genai-0.14.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bf8f8d05ff2d4b5eee7de98f3f3a0fb16d7db456bc37bf9cb72231b4e9645775", size = 57971171, upload-time = "2026-06-02T20:36:15.353Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/b2c1f59a01c99b91ed6f5bd77d0665ba2313a5dac617e23e905507d5226a/onnxruntime_genai-0.14.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cd8d6413124cca69c66f1dc347596a69f84e0cd5ad6dbd69de6ae524208990ac", size = 58598918, upload-time = "2026-06-02T20:36:19.329Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ee/9197abbbf981d0d7845d1ff0b1d8fdb8043073633ef52f84f910bcc8a7ce/onnxruntime_genai-0.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:79595bb8336c5b3bb7e753d4cd6c7f2682d74cb5d30975fb59cd448551d5a853", size = 2749013, upload-time = "2026-06-02T20:36:22.247Z" },
+    { url = "https://files.pythonhosted.org/packages/03/25/e7756ad05e81fbb333cb6c93050f8d49ab390194b0f777ff9d6c616883f5/onnxruntime_genai-0.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:42e51ce6469db477d05513afb0669386dbca8adcecff88e0c41840f147561806", size = 2669703, upload-time = "2026-06-02T20:36:23.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/624358619fb0ab2c220589983b52d32ae5fd2631d7e22581cd0bc232ff74/onnxruntime_genai-0.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c3a636ed7523ca9ead852ed183de1ed82eeba08e73e613f7f7ceb3a9f184b051", size = 3809847, upload-time = "2026-06-02T20:36:25.065Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/3c/d0c8938399f2ea13696ad85ad99a019f926edb683044eac0e3afd69bc18a/onnxruntime_genai-0.14.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:09053361be024625df60cdb1349a3287f3d51b312ad3e41d3473016acf7b1db8", size = 57938740, upload-time = "2026-06-02T20:36:27.792Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/71/dc72d6301a5e2693689c33d1db214d5ce492bfd1320b7e018ba49900eab9/onnxruntime_genai-0.14.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:cd8b4e9dd59c389168c68e7144e4c0c1ed8f7784491150ab53f17db0f72259ed", size = 58585801, upload-time = "2026-06-02T20:36:31.826Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/be/b1607f976d926a57bc59587cbb0d93342ef4e22ff36131d818f9a1fe5100/onnxruntime_genai-0.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8387b9124f9bc9d179d747c61679cae084c3fd4ae1c061fd7714fac8f45f1f62", size = 2749895, upload-time = "2026-06-02T20:36:34.536Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dd/c3fd09db178198950cfe12d599137f306ea72858c27001c5c8eb20108539/onnxruntime_genai-0.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:624a657e19f3c02292daf832450fdbd540ed1c124c78b088e019ef31c7c5f70b", size = 2669826, upload-time = "2026-06-02T20:36:36.242Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/db/c5a33b1d96446482234a3d74fb17652851fa27ec9fdcb2108d575895429d/onnxruntime_genai-0.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:d9cbb344da8e17248fadd7ea7e6c6061c60ad9b16135b4ea0ecb82b70ca926af", size = 3809777, upload-time = "2026-06-02T20:36:37.645Z" },
+    { url = "https://files.pythonhosted.org/packages/42/c7/d65fee722b5399c8f3028c2db2fde12901409c0f7bf8bab7b8ab631d2687/onnxruntime_genai-0.14.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:55e4b9daf003408ead259bd4a2d018b5ddfdb54377e8edff27ed64b8af35cb15", size = 57939465, upload-time = "2026-06-02T20:36:40.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/80/72305fc33a8e472f6efbb3d918c792a3ce5b14bcf0ef9c2a4edd0d3c1431/onnxruntime_genai-0.14.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5a92c551772a6ccec15dbec7b05a4edf13514e5ad4de9321e16dba28897cb3b3", size = 58586127, upload-time = "2026-06-02T20:36:44.055Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a1/67a29edee5c6203a0bd0b9e0e26f70145ff4745aa99694cd1a508eabe4ae/onnxruntime_genai-0.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:022a3ac8dd2f3074c28299b52ce211366f439012c74e203d946a49773082791a", size = 2749913, upload-time = "2026-06-02T20:36:46.67Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/26/ae2090036e4f98673f16092544aeadb4268e9aea78ffe5bc5f6455c4864f/onnxruntime_genai-0.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:57e0229d7506937222584897d5d714d9da24acec4a23337f301eb5a32d8b5162", size = 2669808, upload-time = "2026-06-02T20:36:48.092Z" },
+]
+
+[[package]]
+name = "onnxruntime-training"
+version = "1.23.0+cpu"
+source = { path = "third_party/wheels/onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl" }
+dependencies = [
+    { name = "cerberus", marker = "python_full_version == '3.12.*'" },
+    { name = "flatbuffers", marker = "python_full_version == '3.12.*'" },
+    { name = "h5py", marker = "python_full_version == '3.12.*'" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.12.*'" },
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.12.*'" },
+    { name = "packaging", marker = "python_full_version == '3.12.*'" },
+    { name = "protobuf", marker = "python_full_version == '3.12.*'" },
+    { name = "setuptools", marker = "python_full_version == '3.12.*'" },
+    { name = "sympy", marker = "python_full_version == '3.12.*'" },
+]
+wheels = [
+    { filename = "onnxruntime_training-1.23.0+cpu-cp312-cp312-linux_x86_64.whl", hash = "sha256:87e6f3c661b0a4c6bcaa347c3abcb9ebe05943e2b44cae04701fca89bd14c65d" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "cerberus" },
+    { name = "flatbuffers" },
+    { name = "h5py" },
+    { name = "numpy", specifier = ">=1.16.6" },
+    { name = "onnx" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "setuptools", specifier = ">=61.0.0" },
+    { name = "sympy" },
+]
+
+[[package]]
+name = "onnxscript"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version != '3.12.*' or extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "onnx-ir" },
+    { name = "packaging" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/3a/4d79bce3f460e0df7fed54a92ce80827f25da66511da368bb00783ad8d20/onnxscript-0.7.1.tar.gz", hash = "sha256:309fb86484b11fa4ded90dba580e0d63f1a0827588e521cecaf2eeddb46d6e86", size = 618160, upload-time = "2026-06-29T23:33:21.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/bd/a0c8e737b6afda10e42a597787d53d5b66e00268df6f59184701eeae37d9/onnxscript-0.7.1-py3-none-any.whl", hash = "sha256:544763b7fdef49940cdd9412ff5135cbae96d59ac6bc1921457f21280f40f4b7", size = 721970, upload-time = "2026-06-29T23:33:23.298Z" },
+]
+
+[[package]]
+name = "openai"
+version = "2.45.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/60/d4219875289b11d2c2f7da93c36283da224a2e55865ed865ab64e0ce9217/openai-2.45.0.tar.gz", hash = "sha256:10d34ca9c5643bce775852fddbfc172505cb1d4de1ccd101696c3ecff358765d", size = 1109653, upload-time = "2026-07-09T18:02:44.091Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/b0/2291689e3ec4723fbf5bbf3b54afcd7b160f9ddc98ca7aedfd0132af5677/openai-2.45.0-py3-none-any.whl", hash = "sha256:5df105f5f8c9b711fcb9d06d2d3888cebc82506db216484c14a4e53cdf651777", size = 1629470, upload-time = "2026-07-09T18:02:42.21Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.43.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/cc/e4c9584181f86494df0f6bdec1a4f3280c50db44704dc2a407e994fc87bb/opentelemetry_api-1.43.0.tar.gz", hash = "sha256:107d0d03857ea8fc7c5fcbbbd83f800c281f0d560553d61c1d675fccfd1761c1", size = 73476, upload-time = "2026-06-24T15:19:55.323Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/83/6dba32b85f31868400440dc7ad2ca1eab94cbbf3a7b0459ed39f8311a9e2/opentelemetry_api-1.43.0-py3-none-any.whl", hash = "sha256:20acf45e9b21851926835292e4045d290acade1edd2ff3de86d2f069687ba1fd", size = 61912, upload-time = "2026-06-24T15:19:35.434Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.43.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3e/eb/5041074274ac0956b03637cc039d434569112468e875eddfcc9a0674ce06/opentelemetry_sdk-1.43.0.tar.gz", hash = "sha256:d8187c81c162df9913e4003dd6485f7390d9a24fc17026ec7387b8b8218b08e9", size = 254744, upload-time = "2026-06-24T15:20:08.467Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/e3/b17be23af124201c9f52eececd4cc8ddfed1597d37b4ee771895d325805c/opentelemetry_sdk-1.43.0-py3-none-any.whl", hash = "sha256:d1323a547c1ce69d6a069a17a44b7da82bb8b332051ecb074041f87642c86823", size = 178852, upload-time = "2026-06-24T15:19:52.169Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.64b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5a/30/5f26df29509eccd86b99b481ac9ffa39da49ba9577cc69071c552ae30447/opentelemetry_semantic_conventions-0.64b0.tar.gz", hash = "sha256:72f76fb2d1582d9d033dd1fcd84532e961e6ff3d90d24ba6fabc72975a83864c", size = 148340, upload-time = "2026-06-24T15:20:09.267Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/ca/23ba87a221b574a7c5a99d48849d80bfe8b047624681357e2b002e566187/opentelemetry_semantic_conventions-0.64b0-py3-none-any.whl", hash = "sha256:ea77e85e354b8f604ddbe5f3d9135216f982fa4d77e5859ac30f6d8a50505aa6", size = 203713, upload-time = "2026-06-24T15:19:53.339Z" },
+]
+
+[[package]]
+name = "optimum"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export') or (python_full_version < '3.11' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.11.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version >= '3.13' and extra == 'extra-18-mobiletransformers-export') or (python_full_version >= '3.13' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging" },
+    { name = "torch" },
+    { name = "transformers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f0/69/e1e9fe4d54f6b1b90cc278d6da74dd90eb4d9fd9228882886d7c275712e2/optimum-2.1.0.tar.gz", hash = "sha256:0a2a13f91500e41d34863ffdb08fcb886b3ce68a84a386e59653e3064a45dd4b", size = 125896, upload-time = "2025-12-19T10:47:18.571Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/98/c409ed937331839fdadc03cef6ebd19982bf3834711134db8898eeb31585/optimum-2.1.0-py3-none-any.whl", hash = "sha256:bc3af32e1236a9b2c2ca1d27ed9d3ab1b6591e24c6bcd47f9671a8198a30ea88", size = 161231, upload-time = "2025-12-19T10:47:17.054Z" },
+]
+
+[[package]]
+name = "optimum-onnx"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "onnx", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnx", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version != '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or extra == 'extra-18-mobiletransformers-export' or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "optimum" },
+    { name = "transformers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/da/3a0073af8f436d72c1e4d9c655c00628b857bd1d9ccc101d35301d5bb2df/optimum_onnx-0.1.0.tar.gz", hash = "sha256:182c54b25eddaded1618af7b58516da34749393a987ec7111f74677f249676f9", size = 165531, upload-time = "2025-12-23T14:20:18.97Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/89/4be9d226bc74fd0eb405d1efea62e86d6f0f31841dae9c5898ee12eb482f/optimum_onnx-0.1.0-py3-none-any.whl", hash = "sha256:0301ec7a6ec5c77a57581e9970d380a6dc104bdb8f15b282e05af40d829c2eda", size = 194155, upload-time = "2025-12-23T14:20:17.741Z" },
+]
+
+[package.optional-dependencies]
+onnxruntime = [
+    { name = "onnxruntime", version = "1.24.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "onnxruntime", version = "1.27.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-18-mobiletransformers-export') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/0c/964746fcafbd16f8ff53219ad9f6b412b34f345c75f384ad434ceaadb538/orjson-3.11.9.tar.gz", hash = "sha256:4fef17e1f8722c11587a6ef18e35902450221da0028e65dbaaa543619e68e48f", size = 5599163, upload-time = "2026-05-06T15:11:08.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/5d/b95ca542a001135cc250a49370f282f578c8f4e46cc8617d73775297eea8/orjson-3.11.9-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:135869ef917b8704ea0a94e01620e0c05021c15c52036e4663baffe75e72f8ce", size = 228986, upload-time = "2026-05-06T15:09:14.765Z" },
+    { url = "https://files.pythonhosted.org/packages/80/01/be33fbff646e22f93398429ea645f20d2097aea1a6cdc1e6628e70125f83/orjson-3.11.9-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115ab5f5f4a0f203cc2a5f0fb09aee503a3f771aa08392949ab5ca230c4fbdbd", size = 132558, upload-time = "2026-05-06T15:09:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/61/73d49333bba660a075daccca10970dc6409ce1cf42ae4046646a19468aad/orjson-3.11.9-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4da3c38a2083ca4aaf9c2a36776cce3e9328e6647b10d118948f3cfb4913ffe4", size = 128213, upload-time = "2026-05-06T15:09:18.719Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/7d/30e844b3dac3f74aed66b1f984daf9db3c98c0328c03d965a9e8dc06449e/orjson-3.11.9-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53b50b0e14084b8f7e29c5ce84c5af0f1160169b30d8a6914231d97d2fe297d4", size = 135430, upload-time = "2026-05-06T15:09:20.257Z" },
+    { url = "https://files.pythonhosted.org/packages/16/64/bd815f5c610b3facc204f26ba94e87a9eb49b0d83de3d5fc1eee2402d91b/orjson-3.11.9-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:231742b4a11dad8d5380a435962c57e91b7c37b79be858f4ef1c0df1a259897e", size = 146178, upload-time = "2026-05-06T15:09:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/35/e744fd36c79b339d27beb06068b5a08a8882ef5418804d0ce545a31f718d/orjson-3.11.9-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:34fd2317602587321faab75ab76c623a0117e80841a6413654f04e47f339a8fb", size = 133068, upload-time = "2026-05-06T15:09:23.228Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/56/d54152b67b63a0b3e556cfc549d6ce84f74d7f425ddeadc6c8a74d913da7/orjson-3.11.9-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71f3db16e69b667b132e0f305a833d5497da302d801508cbb051ed9a9819da47", size = 134217, upload-time = "2026-05-06T15:09:24.847Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ee/66154baf69f71c7164a268a5e888908aec5a0819d13c81d5e2755a257758/orjson-3.11.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0b34789fa0da61cf7bef0546b09c738fb195331e017e477096d129e9105ab03d", size = 141917, upload-time = "2026-05-06T15:09:26.647Z" },
+    { url = "https://files.pythonhosted.org/packages/09/d3/c5824260ca8b9d7ba82648d042a3f8f4815d18c15bb98a1f30edd1bb2d83/orjson-3.11.9-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:87e4d4ab280b0c87424d47695bec2182caf8cfc17879ea78dab76680194abc13", size = 415356, upload-time = "2026-05-06T15:09:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/64/cb/509c2e816fe4df641d93dc92f6a89adc8df3ada8ebdee2bd44aba3264c3c/orjson-3.11.9-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ace6c58523302d3b97b6ac5c38a5298a54b473762b6be82726b4265c41029f92", size = 148112, upload-time = "2026-05-06T15:09:29.783Z" },
+    { url = "https://files.pythonhosted.org/packages/db/b5/3ceae56d2e4962979eedb023ba6a46a4bb65f333960379be0ca470686220/orjson-3.11.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:97d0d932803c1b164fde11cb542a9efcb1e0f63b184537cca65887147906ff48", size = 137112, upload-time = "2026-05-06T15:09:31.432Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/7a/81fa3f2c7bef79b04cf2ab7838e5ac74b1f12511ceab979759b0275d6bb4/orjson-3.11.9-cp310-cp310-win32.whl", hash = "sha256:b3afcf569c15577a9fe64627292daa3e6b3a70f4fb77a5df246a87ec21681b94", size = 131706, upload-time = "2026-05-06T15:09:32.707Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/b64600f9083c7f151ad39717a5877fccbeb0ef6d7efcb55f971ce00b6bee/orjson-3.11.9-cp310-cp310-win_amd64.whl", hash = "sha256:8697ab6a080a5c46edaad50e2bc5bd8c7ca5c66442d24104fa44ec74910a8244", size = 127282, upload-time = "2026-05-06T15:09:33.955Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/51/3fb9e65ae76ee97bd611869a503fa3fc0a6e81dd8b737cf3003f682df7ff/orjson-3.11.9-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:f01c4818b3fc9b0da8e096722a84318071eaa118df35f6ed2344da0e73a5444f", size = 228522, upload-time = "2026-05-06T15:09:35.362Z" },
+    { url = "https://files.pythonhosted.org/packages/16/fa/9d54b07cb3f3b0bfd57841478e42d7a0ece4a9f49f9907eecf5a45461687/orjson-3.11.9-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:3ebca4179031ee716ed076ffadc29428e900512f6fccee8614c9983157fcf19c", size = 128463, upload-time = "2026-05-06T15:09:37.063Z" },
+    { url = "https://files.pythonhosted.org/packages/88/b1/6ceafc2eefd0a553e3be77ce6c49d107e772485d9568629376171c50e634/orjson-3.11.9-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48ee05097750de0ff69ed5b7bbcf0732182fd57a24043dcc2a1da780a5ead3a5", size = 132306, upload-time = "2026-05-06T15:09:38.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/f11311285324a40aab1e3031385c50b635a7cd0734fdaf60c7e89a696f60/orjson-3.11.9-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6082706765a95a6680d812e1daf1c0cfe8adec7831b3ff3b625693f3b461b1c", size = 127988, upload-time = "2026-05-06T15:09:39.597Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/85/0ef63bcf1337f44031ce9b91b1919563f62a37527b3ea4368bb15a22e5d7/orjson-3.11.9-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:277fefe9d76ee17eb14debf399e3533d4d63b5f677a4d3719eb763536af1f4bd", size = 135188, upload-time = "2026-05-06T15:09:40.957Z" },
+    { url = "https://files.pythonhosted.org/packages/05/94/b0d27090ea8a2095db3c2bd1b1c96f96f19bbb494d7fef33130e846e613d/orjson-3.11.9-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:03db380e3780fa0015ed776a90f20e8e20bb11dde13b216ce19e5718e3dfba62", size = 145937, upload-time = "2026-05-06T15:09:42.249Z" },
+    { url = "https://files.pythonhosted.org/packages/09/eb/75d50c29c05b8054013e221e598820a365c8e64065312e75e202ed880709/orjson-3.11.9-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33d7d766701847dc6729846362dc27895d2f2d2251264f9d10e7cb9878194877", size = 132758, upload-time = "2026-05-06T15:09:43.945Z" },
+    { url = "https://files.pythonhosted.org/packages/49/bd/360686f39348aa88827cb6fbf7dc606fd41c831a35235e1abf1db8e3a9e6/orjson-3.11.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:147302878da387104b66bb4a8b0227d1d487e976ce41a8501916161072ed87b1", size = 133971, upload-time = "2026-05-06T15:09:45.239Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/30/3178eb16f3221aeef068b6f1f1ebe05f656ea5c6dffe9f6c917329fe17a3/orjson-3.11.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3513550321f8c8c811a7c3297b8a630e82dc08e4c10216d07703c997776236cd", size = 141685, upload-time = "2026-05-06T15:09:46.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f1/ff2f19ed0225f9680fafa42febca3570dd59444ebf190980738d376214c2/orjson-3.11.9-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c5d001196b89fa9cf0a4ab79766cd835b991a166e4b621ba95089edc50c429ff", size = 415167, upload-time = "2026-05-06T15:09:48.312Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/61/863bddf0da6e9e586765414debd54b4e58db05f560902b6d00658cb88636/orjson-3.11.9-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:16969c9d369c98eb084889c6e4d2d39b77c7eb38ceccf8da2a9fff62ae908980", size = 147913, upload-time = "2026-05-06T15:09:49.733Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4081492586d75b073d60c5271a8d0f05a0955cabf1e34c8473f6fcd84235/orjson-3.11.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:63e0efbc991250c0b3143488fa57d95affcabbfc63c99c48d625dd37779aafe2", size = 136959, upload-time = "2026-05-06T15:09:51.311Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bd/70b6ab193594d7abb875320c0a7c8335e846f28968c432c31042409c3c8d/orjson-3.11.9-cp311-cp311-win32.whl", hash = "sha256:14ed654580c1ed2bc217352ec82f91b047aef82951aa71c7f64e0dcb03c0e180", size = 131533, upload-time = "2026-05-06T15:09:52.637Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/17/1a1a228183d62d1b77e2c30d210f47dd4768b310ebe1607c63e3c0e3a71e/orjson-3.11.9-cp311-cp311-win_amd64.whl", hash = "sha256:57ea77fb70a448ce87d18fca050193202a3da5e54598f6501ca5476fb66cfe02", size = 127106, upload-time = "2026-05-06T15:09:54.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/95/285de5fa296d09681ee9c546cd4a8aeb773b701cf343dc125994f4d52953/orjson-3.11.9-cp311-cp311-win_arm64.whl", hash = "sha256:19b72ed11572a2ee51a67a903afbe5af504f84ed6f529c0fe44b0ab3fb5cc697", size = 126848, upload-time = "2026-05-06T15:09:55.551Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6d/11867a3ffa3a3608d84a4de51ef4dd0896d6b5cc9132fbe1daf593e677bc/orjson-3.11.9-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9ef6fe90aadef185c7b128859f40beb24720b4ecea95379fc9000931179c3a49", size = 228515, upload-time = "2026-05-06T15:09:57.265Z" },
+    { url = "https://files.pythonhosted.org/packages/24/75/05912954c8b288f34fcf5cd4b9b071cb4f6e77b9961e175e56ebb258089f/orjson-3.11.9-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:e5c9b8f28e726e97d97696c826bc7bea5d71cecd63576dba92924a32c1961291", size = 128409, upload-time = "2026-05-06T15:09:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/86/1c3a47df3bc8191ea9ac51603bbb872a95167a364320c269f2557911f406/orjson-3.11.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a473dbb4162108b27901492546f83c76fdcea3d0eadff00ae7a07e18dcce09", size = 132106, upload-time = "2026-05-06T15:10:00.798Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/cf/b33b5f3e695ae7d63feef9d915c37cc3b8f465493dcd4f8e0b4c697a2366/orjson-3.11.9-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:011382e2a60fda9d46f1cdee31068cfc52ffe952b587d683ec0463002802a0f4", size = 127864, upload-time = "2026-05-06T15:10:02.15Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6a/6cf69385a58208024fcb8c014e2141b8ce838aba6492b589f8acfff97fab/orjson-3.11.9-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2d3dc759490128c5c1711a53eeaa8ee1d437fd0038ffd2b6008abf46db3f882", size = 135213, upload-time = "2026-05-06T15:10:03.515Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/f8/0b1bd3e8f2efcdd376af5c8cfd79eaf13f018080c0089c80ebd724e3c7fb/orjson-3.11.9-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d8ea516b3726d190e1b4297e6f4e7a8650347ae053868a18163b4dd3641d1fff", size = 145994, upload-time = "2026-05-06T15:10:05.083Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/59/dab79f61044c529d2c81aecdc589b1f833a1c8dec11ba3b1c2498a02ca7e/orjson-3.11.9-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:380cdce7ba24989af81d0a7013d0aaec5d0e2a21734c0e2681b1bc4f141957fe", size = 132744, upload-time = "2026-05-06T15:10:06.853Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/a4/82b7a2fe5d8a67a59ed831b24d59a3d46ea7d207b66e1602d376541d94a6/orjson-3.11.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be4fa4f0af7fa18951f7ab3fc2148e223af211bf03f59e1c6034ec3f97f21d61", size = 134014, upload-time = "2026-05-06T15:10:08.213Z" },
+    { url = "https://files.pythonhosted.org/packages/50/c7/375e83a76851b73b2e39f3bcf0e5a19e2b89bad13e5bca97d0b293d27f24/orjson-3.11.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a8f5f8bc7ce7d59f08d9f99fa510c06496164a24cb5f3d34537dbd9ca30132e2", size = 141509, upload-time = "2026-05-06T15:10:09.595Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/7c/49d5d82a3d3097f641f094f552131f1e2723b0b8cb0fa2874ab65ecfffa6/orjson-3.11.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4d7fde5501b944f83b3e665e1b31343ff6e154b15560a16b7130ea1e594a4206", size = 415127, upload-time = "2026-05-06T15:10:11.049Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/dc/7446c538590d55f455647e5f3c61fc33f7108714e7afcffa6a2a033f8350/orjson-3.11.9-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cde1a448023ba7d5bb4c01c5afb48894380b5e4956e0627266526587ef4e535f", size = 148025, upload-time = "2026-05-06T15:10:12.842Z" },
+    { url = "https://files.pythonhosted.org/packages/df/e5/4d2d8af06f788329b4f78f8cc3679bb395392fcaa1e4d8d3c33e85308fa4/orjson-3.11.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:71e63adb0e1f1ed5d9e168f50a91ceb93ae6420731d222dc7da5c69409aa47aa", size = 136943, upload-time = "2026-05-06T15:10:14.405Z" },
+    { url = "https://files.pythonhosted.org/packages/06/69/850264ccf6d80f6b174620d30a87f65c9b1490aba33fe6b62798e618cad3/orjson-3.11.9-cp312-cp312-win32.whl", hash = "sha256:2d057a602cdd19a0ad680417527c45b6961a095081c0f46fe0e03e304aac6470", size = 131606, upload-time = "2026-05-06T15:10:15.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/d5/973a43fc9c55e20f2051e9830997649f669be0cb3ca52192087c0143f118/orjson-3.11.9-cp312-cp312-win_amd64.whl", hash = "sha256:59e403b1cc5a676da8eaf31f6254801b7341b3e29efa85f92b48d272637e77be", size = 127101, upload-time = "2026-05-06T15:10:17.129Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/ae/495470f0e4a18f73fa10b7f6b84b464ec4cc5291c4e0c7c2a6c400bef006/orjson-3.11.9-cp312-cp312-win_arm64.whl", hash = "sha256:9af678d6488357948f1f84c6cd1c1d397c014e1ae2f98ae082a44eb48f602624", size = 126736, upload-time = "2026-05-06T15:10:18.645Z" },
+    { url = "https://files.pythonhosted.org/packages/32/33/93fcc25907235c344ae73122f8a4e01d2d393ef062b4af7d2e2487a32c37/orjson-3.11.9-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4bab1b2d6141fe7b32ae71dac905666ece4f94936efbfb13d55bb7739a3a6021", size = 228458, upload-time = "2026-05-06T15:10:20.079Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/27/b1e6dadb3c080313c03fdd8067b85e6a0460c7d8d6a1c3984ef77b904e4d/orjson-3.11.9-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:844417969855fc7a41be124aafe83dc424592a7f77cd4501900c67307122b92c", size = 128368, upload-time = "2026-05-06T15:10:21.549Z" },
+    { url = "https://files.pythonhosted.org/packages/21/0f/c9ede0bf052f6b4051e64a7d4fa91b725cccf8321a6a786e86eb03519f00/orjson-3.11.9-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffe02797b5e9f3a9d8292ddcd289b474ad13e81ad83cd1891a240811f1d2cb81", size = 132070, upload-time = "2026-05-06T15:10:23.371Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/26/d398e28048dc18205bbe812f2c88cb9b40313db2470778e25964796458fe/orjson-3.11.9-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e4eed3b200023042814d2fc8a5d2e880f13b52e1ed2485e83da4f3962f7dc1a", size = 127892, upload-time = "2026-05-06T15:10:24.714Z" },
+    { url = "https://files.pythonhosted.org/packages/66/60/52b0054c4c700d5aa7fc5b7ca96917400d8f061307778578e67a10e25852/orjson-3.11.9-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aff7da9952a5ad1cef8e68017724d96c7b9a66e99e91d6252e1b133d67a7b10", size = 135217, upload-time = "2026-05-06T15:10:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/97/1e3dc2b2a28b7b2528f403d2fc1d79ec5f39af3bc143ab65d3ec26426385/orjson-3.11.9-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d4e98d6f3b8afed8bc8cd9718ec0cdf46661826beefb53fe8eafb37f2bf0362", size = 145980, upload-time = "2026-05-06T15:10:28.062Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/31fbfe7850f2de32dee7e7e5c09f26d403ab01e440ac96001c6b01ad3c99/orjson-3.11.9-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a81d52442a7c99b3662333235b3adf96a1715864658b35bb797212be7bddb97", size = 132738, upload-time = "2026-05-06T15:10:29.727Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/08/dca0082dd2a194acb93e5457e73455388e2e2ca464a2672449a9ddbb679d/orjson-3.11.9-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e39364e726a8fff737309aff059ff67d8a8c8d5b677be7bb49a8b3e84b7e218", size = 134033, upload-time = "2026-05-06T15:10:31.152Z" },
+    { url = "https://files.pythonhosted.org/packages/11/d4/5bdb0626801230139987385554c5d4c42255218ac906525bf4347f22cd95/orjson-3.11.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4fd66214623f1b17501df9f0543bef0b833979ab5b6ded1e1d123222866aa8c9", size = 141492, upload-time = "2026-05-06T15:10:32.641Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/88/a21fb53b3ede6703aede6dce4710ed4111e5b201cfa6bbff5e544f9d47d7/orjson-3.11.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:8ecc30f10465fa1e0ce13fd01d9e22c316e5053a719a8d915d4545a09a5ff677", size = 415087, upload-time = "2026-05-06T15:10:34.438Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/57/1b30daf70f0d8180e9a73cefbfbdd99e4bf19eb020466502b01fba7e0e50/orjson-3.11.9-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:97db4c94a7db398a5bd636273324f0b3fd58b350bbbac8bb380ceb825a9b40f4", size = 148031, upload-time = "2026-05-06T15:10:36.358Z" },
+    { url = "https://files.pythonhosted.org/packages/04/83/45fbb6d962e260807f99441db9613cee868ceda4baceda59b3720a563f97/orjson-3.11.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f78cf8fec5bd627f4082b8dfeac7871b43d7f3274904492a43dab39f18a19a0", size = 136915, upload-time = "2026-05-06T15:10:38.013Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/cc/2d10025f9056d376e4127ec05a5808b218d46f035fdc08178a5411b34250/orjson-3.11.9-cp313-cp313-win32.whl", hash = "sha256:d4087e5c0209a0a8efe4de3303c234b9c44d1174161dcd851e8eea07c7560b32", size = 131613, upload-time = "2026-05-06T15:10:39.569Z" },
+    { url = "https://files.pythonhosted.org/packages/67/bd/2775ff28bfe883b9aa1ff348300542eb2ef1ee18d8ae0e3a49846817a865/orjson-3.11.9-cp313-cp313-win_amd64.whl", hash = "sha256:051b102c93b4f634e89f3866b07b9a9a98915ada541f4ec30f177067b2694979", size = 127086, upload-time = "2026-05-06T15:10:41.262Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2b/d26799e580939e32a7da9a39531bc9e58e15ca32ffaa6a8cb3e9bb0d22cd/orjson-3.11.9-cp313-cp313-win_arm64.whl", hash = "sha256:cce9127885941bd28f080cecf1f1d288336b7e0d812c345b08be88b572796254", size = 126696, upload-time = "2026-05-06T15:10:42.651Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "paginate"
+version = "0.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
+]
+
+[[package]]
+name = "peft"
+version = "0.13.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "accelerate", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "huggingface-hub", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.13' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "psutil", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pyyaml", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "safetensors", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "torch", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "tqdm", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "transformers", marker = "(extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/97/e1/aab80b861b4c18e85482940d504b3a7ee525bdf6ed93a1a2871881a180f1/peft-0.13.2.tar.gz", hash = "sha256:0e0cbd40ebdf5fe4ea79f255880d02f96712d18899509369a2cc5768ad46d672", size = 350390, upload-time = "2024-10-11T11:42:21.874Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/9d/5f95bfb298c8d3b4e3a107701f9a4e7774a0d4d1f8eb0c9d5420b80f7c9d/peft-0.13.2-py3-none-any.whl", hash = "sha256:d4e0951ec78eac11c45a051801c569913436888c578d48e5ce86996b715bc6ef", size = 320731, upload-time = "2024-10-11T11:42:18.905Z" },
+]
+
+[[package]]
+name = "peft"
+version = "0.19.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "accelerate", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "huggingface-hub", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export') or (python_full_version < '3.11' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.11' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.11.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.11.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and extra == 'extra-18-mobiletransformers-export') or (python_full_version >= '3.12' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version >= '3.12' and extra != 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "psutil", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "pyyaml", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "safetensors", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "torch", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "tqdm", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+    { name = "transformers", marker = "extra == 'extra-18-mobiletransformers-export' or extra == 'group-18-mobiletransformers-genai-smoke' or extra != 'group-18-mobiletransformers-ort-training-local'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", hash = "sha256:0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40", size = 763738, upload-time = "2026-04-16T15:46:45.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", hash = "sha256:2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356", size = 680692, upload-time = "2026-04-16T15:46:42.886Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/c2/669d88644cddb1485bd9534e63e8cf476c8e51cb3c3a1297677023505c0e/pillow-12.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6c0016e7b354317c4e9e525b937ac8596c38d2d232b419529b9cd7a1cd46e39a", size = 5392418, upload-time = "2026-07-01T11:53:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ba/3762f376a2948e3036488d773a146e0ae6ecc2ca03ac20e2615bd0b2ba02/pillow-12.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bcc33feacfaefce60c12fd500a277533bdc02b10a19f7f6d348763d8140bbba7", size = 4785287, upload-time = "2026-07-01T11:53:29.761Z" },
+    { url = "https://files.pythonhosted.org/packages/07/50/b5d688cc9c52d4482f3d5bcab6ce20bc2a74a85d2343841c907444a3be2c/pillow-12.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5594fc43d548a7ed94949d139aa1341b270f1863f11cfd37f5a6c8b778a6b67f", size = 6253754, upload-time = "2026-07-01T11:53:32.298Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/89/36f4cd76cf4baf05c50ababb976249153f18c959171c7f6ba09a6f217260/pillow-12.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0606c8bf2cdefea14a43530f7657cbbb7ecf1c4222512492ef4a4434a9501ec", size = 6925605, upload-time = "2026-07-01T11:53:34.487Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c0/4de58cf6633b9e3a6061ef4be6fb91fc3c90b812ece886f531e3c523d777/pillow-12.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:85f998ea1848bc6757289e739cfbdda3a04adfd58b02fc018ce54d754a5ce468", size = 6327788, upload-time = "2026-07-01T11:53:36.433Z" },
+    { url = "https://files.pythonhosted.org/packages/87/3c/14d53682a19550dbbaf3b598f807d5457646c510805a44c7d7891cd1cd1a/pillow-12.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:25b9b82bb22e6e2b3cd07b39c68b7b862001226cb3dff7130d1cb914121b39ed", size = 7036288, upload-time = "2026-07-01T11:53:38.712Z" },
+    { url = "https://files.pythonhosted.org/packages/38/1d/36279e3c77efe034e4cc2b0393ee74ffdb5a62391dacbf9b916154f5f0b8/pillow-12.3.0-cp310-cp310-win32.whl", hash = "sha256:37dc8f7bbb66efe481bb60defacef820c950c24713fb44962ed6aa2a50966de1", size = 6472396, upload-time = "2026-07-01T11:53:40.781Z" },
+    { url = "https://files.pythonhosted.org/packages/48/7c/8fa0039574c476d7c6fa57dd7c32a130436877c6ec1e5ce1cc8ec44878c1/pillow-12.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:300557495eb45ebb8aec96c2da9c4be642fbf7cd937278b4013ba894ea8eb0eb", size = 7226887, upload-time = "2026-07-01T11:53:42.764Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/17/e324be141d173c1c919428066c3259f21c1b8982e564e01a4a81e96dbdcf/pillow-12.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:514435a37670e3e5e08f3945b68718b6ed329bb84367777e16f9f4dfe1e61a0f", size = 2568039, upload-time = "2026-07-01T11:53:45.372Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" },
+    { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" },
+    { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" },
+    { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" },
+    { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" },
+    { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" },
+    { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" },
+    { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" },
+    { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" },
+    { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" },
+    { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" },
+    { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" },
+    { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" },
+    { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" },
+    { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" },
+    { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "portalocker"
+version = "3.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pywin32", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/77/65b857a69ed876e1951e88aaba60f5ce6120c33703f7cb61a3c894b8c1b6/portalocker-3.2.0.tar.gz", hash = "sha256:1f3002956a54a8c3730586c5c77bf18fae4149e07eaf1c29fc3faf4d5a3f89ac", size = 95644, upload-time = "2025-06-14T13:20:40.03Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/a6/38c8e2f318bf67d338f4d629e93b0b4b9af331f455f0390ea8ce4a099b26/portalocker-3.2.0-py3-none-any.whl", hash = "sha256:3cdc5f565312224bc570c49337bd21428bba0ef363bbcf58b9ef4a9f11779968", size = 22424, upload-time = "2025-06-14T13:20:38.083Z" },
+]
+
+[[package]]
+name = "posthog"
+version = "7.22.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "backoff" },
+    { name = "distro" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/00/4d/a4920cfd08dd376d5faf214665c33b311eafeb92e5410a2a42054adca395/posthog-7.22.2.tar.gz", hash = "sha256:2e7bffa28b0032622f4661be6600f2555aff34da0f2a1cd62f72ec490b574519", size = 330350, upload-time = "2026-07-13T09:01:06.827Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/2e/b6af5e03abf34855e8f2bebf801ea2ac8411772f7479db5f219b66e0d480/posthog-7.22.2-py3-none-any.whl", hash = "sha256:8b1cf21ace6f3a077841a7a900fcfd25c2986b52c2f68eaa98710dcea9f54fd6", size = 396053, upload-time = "2026-07-13T09:01:05.272Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/56/030b7b4719d53085722893e0009dffb9236aa10bca1b12121bdc5626ef16/propcache-0.5.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d5a81be28596d6559f6131ef33e10200de6e17643b3c74ce03f9eb103be6ae8b", size = 93417, upload-time = "2026-05-08T20:59:15.597Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/55/1140a8e067b8ec093a18a4ae7bb0045d9db65da38a08618ddc5e2f1994aa/propcache-0.5.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29cbaac5ea0212663e6845e04b5e188d5a6ae6dd919810ac835bf1d3b42c3f4c", size = 53847, upload-time = "2026-05-08T20:59:17.096Z" },
+    { url = "https://files.pythonhosted.org/packages/20/42/0e7443c90310498561addf346e7d57fe3c6ba1914e1ba938b5464c7bbfd2/propcache-0.5.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6bf3be92233808fcd338eba0fb4d0b59ec5772af4f4ecfcec450d1bfc0f8b5eb", size = 53512, upload-time = "2026-05-08T20:59:18.64Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/db/cf51a71bab2009517d1a7f0ee07657e3bd446c4d69f67e6966cf17bcf956/propcache-0.5.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f8ea531c794b9d6274acd4e8d2c2ebcac590a4361d27482edd3010b79f1325e", size = 58068, upload-time = "2026-05-08T20:59:20.683Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/43/39b6bdee9699fa1e1641c519feeb64a67e2a9f93bb465c70776b37a7333f/propcache-0.5.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:decfca4c79dd53ebab484b00cc4b6717d8c369f86e74aa4ca395a64ac651495e", size = 61020, upload-time = "2026-05-08T20:59:22.112Z" },
+    { url = "https://files.pythonhosted.org/packages/26/0b/843726fbb0a29a8c5684fdb25971823638399f31e52e9d1f06a02dc9aa6b/propcache-0.5.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4621064bbf28fa77ff64dd5d94367c04684c67d3a5bf1dff25f0cd0d98a38f3b", size = 62732, upload-time = "2026-05-08T20:59:23.805Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6e/899fed76dc1942b8a64193a4f059d7f1a2c7ef65085e8a9366ed8ec0d199/propcache-0.5.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b96db7141a592cbc968daf1feea83a118e6ab378af4abbc72b248c895414c22d", size = 60140, upload-time = "2026-05-08T20:59:25.389Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/09/3da4be9b5b879219ad234aa535b3dd4a080ed1ad48d3a73ca07a9e798f22/propcache-0.5.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1ca071adabaab6e9219924bbe00af821f1ee7de113a9eca1cdc292de3d120f4d", size = 60400, upload-time = "2026-05-08T20:59:27.238Z" },
+    { url = "https://files.pythonhosted.org/packages/60/2f/09b72b874a9aa0044faf52a69807a6ed618e267ceaa9ec4a63195fa5b504/propcache-0.5.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e4294d04a94dcab1b3bccd8b66d962dcad411a1d19414b2a41d1445f1de32ad0", size = 58155, upload-time = "2026-05-08T20:59:28.48Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/37/97489848c54c95578045473954f10956d619ce6a09e7ac137b71cdcb698b/propcache-0.5.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:a0e399a2eccb91ed18721f86aa85757727400b6865c89e88934781deb9c8498b", size = 57037, upload-time = "2026-05-08T20:59:30.146Z" },
+    { url = "https://files.pythonhosted.org/packages/22/db/6c695285ccfc49012743ee9c98212b8c5dd0aed7b63cfd816d4a0f7a1601/propcache-0.5.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:823581fd5cb08b12a48bfa11fe962a7916766b6170c17b028fbdf762b85eb9bf", size = 61103, upload-time = "2026-05-08T20:59:31.626Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a9/1e500401ca593b0bdb6bf75a70bc2d723835fd53360edff6af70692c7546/propcache-0.5.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:949c91d1a990cf3b2e8188dfcfb25005e0b834a06c63fa4ef9f360878ce21ecf", size = 60394, upload-time = "2026-05-08T20:59:32.829Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/87/f638b6e375eae0f30a1a2325d8b34fd85fdc785bb9960cf805f3bf1ec69a/propcache-0.5.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:cc1177027eda740fdb152706bd215a3f124e3eea15afc39f2cb9fe351b50619e", size = 63084, upload-time = "2026-05-08T20:59:35.964Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/18/884573f5d97b6d9eba68de759a82c901b7e39d7904d30f7b8d58d42d2a12/propcache-0.5.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b05d643f944a8c3c4bd86d65ffd87bf3264b617f87791940302bc474d2ff5274", size = 60999, upload-time = "2026-05-08T20:59:38.481Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/1a/c3915eb059ceec9e758a56e4cfd955292bc0f201be2176a46b76d94b303a/propcache-0.5.2-cp310-cp310-win32.whl", hash = "sha256:8114f28879e0904748e831c3a7774261bd9e75f49be089f389a76f959dcd13fe", size = 39036, upload-time = "2026-05-08T20:59:40.323Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/1dfd5607501a602d19c1c449d2d193b7d1c611f9246b4059026a1189a80e/propcache-0.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:5fcb98e7598b1ee0addab320d90f65b530297a867dbfe9de52ea838077e16e3d", size = 42190, upload-time = "2026-05-08T20:59:42.232Z" },
+    { url = "https://files.pythonhosted.org/packages/57/93/f71588ad08b3e6f4b555b5ef215808a3c02b042d0151ad82fa6f15be677a/propcache-0.5.2-cp310-cp310-win_arm64.whl", hash = "sha256:04dc2390d9edbbaef7461f33322555976ffddf0b650a038649d026358714e6c5", size = 38545, upload-time = "2026-05-08T20:59:44.087Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/f1/8a8cc1c2c7e7934ab77e0163414f736fadbc0f5e8dd9673b952355ac175b/propcache-0.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:74b70780220e2dd89175ca24b81b68b67c83db499ae611e7f2313cb329801c78", size = 90744, upload-time = "2026-05-08T20:59:45.799Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f4/651b1225e976bd1a2ba5cfba0c29d096581c2636b437e3a9a7ab6276270a/propcache-0.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a4840ab0ae0216d952f4b53dc6d0b992bfc2bedbfe360bdd9b548bc184c08959", size = 52033, upload-time = "2026-05-08T20:59:47.408Z" },
+    { url = "https://files.pythonhosted.org/packages/15/a8/8ede85d6aa1f79fc7dc2f8fd2c8d65920b8272c3892903c8a1affde48cfb/propcache-0.5.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c6844ba6364fb12f403928a82cfd295ab103a2b315c77c747b2dbe4a41894ea7", size = 52754, upload-time = "2026-05-08T20:59:49.202Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/fe/b3551b41bbc2f5b5bb088fc6920567cd43101253e68fbaa261339eb96fe1/propcache-0.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2293949b855ce597f2826452d17c2d545fb5622379c4ea6fdf525e9b8e8a2511", size = 57573, upload-time = "2026-05-08T20:59:50.778Z" },
+    { url = "https://files.pythonhosted.org/packages/83/27/ab851ebd1b7172e3e161f5f8d39e315d54a91bea246f01f4d872d3376aef/propcache-0.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0fd59b5af35f74da48d905dcbad55449ba13be91823cb05a9bd590bbf5b61660", size = 60645, upload-time = "2026-05-08T20:59:52.227Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7d/466b3d18022e9897cbda9c735c493c5bd747d7a4c6f5ea1480b4cec434b6/propcache-0.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29f9309a2e42b0d273be006fdb4be2d6c39a47f6f57d8fb1cf9f81481df81b66", size = 61563, upload-time = "2026-05-08T20:59:53.866Z" },
+    { url = "https://files.pythonhosted.org/packages/27/1b/16ab7f2cf2041da2f60d156ba64c2484eadf9168075b4ff43c3ef60045af/propcache-0.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5aaa2b923c1944ac8febd6609cb373540a5563e7cbcb0fd770f75dace2eb817b", size = 58888, upload-time = "2026-05-08T20:59:55.457Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/67/bb777ffd907633563bf35fd859c4ce97b0512c32f4633cf5d1eb7c33512b/propcache-0.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66ea454f095ddf5b6b14f56c064c0941c4788be11e18d2464cf643bf7203ff67", size = 59253, upload-time = "2026-05-08T20:59:57.075Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/42/64f8d90b73fd9cdc1499b48057ff6d9cd2a98a25734c9bb62ecf07e87061/propcache-0.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:95f1e3f4760d404b13c9976c0229b2b49a3c8e2c62a9ce92efdd2b11ada75e3f", size = 57558, upload-time = "2026-05-08T20:59:58.602Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/02/dba5bc03c9041f2092ea55a449caf5dfe68352c6654511b29ba0654ddb69/propcache-0.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:85341b12b9d55bad0bded24cac341bb34289469e03a11f3f583ea1cc1db0326c", size = 55007, upload-time = "2026-05-08T20:59:59.837Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c0/43f649c7aa2a77a3b100d84e9dea3a483120ecb608bfe36ce49eaff517fe/propcache-0.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:26a4dca084132874e639895c3135dfad5eb20bae209f62d1aeb31b03e601c3c0", size = 60355, upload-time = "2026-05-08T21:00:01.144Z" },
+    { url = "https://files.pythonhosted.org/packages/83/c0/435dafd27f1cb4a495381dae60e25883ccfe4020bb72818e8184c1678092/propcache-0.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3b199b9b2b3d6a7edf3183ba8a9a137a22b97f7df525feb5ae1eccf026d2a9c6", size = 59057, upload-time = "2026-05-08T21:00:02.401Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ae/6e292df9135d659944e96cb3389258e4a663e5b2b5f6c217ef0ddc8d2f73/propcache-0.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e59bc9e66329185b93dab73f210f1a37f81cb40f321501db8017c9aea15dba27", size = 61938, upload-time = "2026-05-08T21:00:03.638Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/42/314ebc50d8159055411fd6b0bda322ff510e4b1f7d2e4927940ad0f6af20/propcache-0.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:552ffadf6ad409844bc5919c42a0a83d88314cedddaea0e41e80a8b8fffe881f", size = 59731, upload-time = "2026-05-08T21:00:04.881Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/9b/2da6dee38871c3c8772fabc2758325a5c9077d6d18c597737dc04dd884cd/propcache-0.5.2-cp311-cp311-win32.whl", hash = "sha256:cd416c1de191973c52ff1a12a57446bfc7642797b282d7caf2162d7d1b8aa9a0", size = 38966, upload-time = "2026-05-08T21:00:06.511Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4e/f17363fb58c0afe05b067361cb6d86ed2d29de6506779a27547c4d183075/propcache-0.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:44e488ef40dbb452700b2b1f8188934121f6648f52c295055662d2191959ff82", size = 42135, upload-time = "2026-05-08T21:00:08.088Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/eb/6af6685077d22e8b33358d3c548e3282706a0b3cd85044ffba4e5dd08e3b/propcache-0.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:54adaa85a22078d1e306304a40984dc5be99d599bf3dc0a24dc98f7daeab89ab", size = 38381, upload-time = "2026-05-08T21:00:09.692Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" },
+    { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" },
+    { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" },
+    { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" },
+    { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" },
+    { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" },
+    { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" },
+    { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" },
+    { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" },
+    { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.35.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/01/9ef0afd7999eb9badb3a768b4aedd78c86d4c65cfaf1958ab276199e76b4/protobuf-7.35.1.tar.gz", hash = "sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a", size = 458717, upload-time = "2026-06-11T21:55:40.257Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/03/8aeeb7458d22546bf64b5250ca1daeb5ff757d900e8e4a7476c6f0db843e/protobuf-7.35.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6", size = 433226, upload-time = "2026-06-11T21:55:31.719Z" },
+    { url = "https://files.pythonhosted.org/packages/37/4b/dfb89eb0e652a1ff073c39a59fb5e3a83cfe9b57a2c83fa6d78270101767/protobuf-7.35.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799", size = 328847, upload-time = "2026-06-11T21:55:34.035Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/58/dc12f2cd484951524af6e3382c785869b9b3fb5e52ee95ae23add53ee8f9/protobuf-7.35.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4", size = 344030, upload-time = "2026-06-11T21:55:34.941Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/be/5b3cfe508bfab6761414ff944e3366eb13be4fd71efcd69450f89ba39f43/protobuf-7.35.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4", size = 327130, upload-time = "2026-06-11T21:55:35.921Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/bc/6d6c7ba8709c85f8f2c390b2b118d6fb08a783676a572271851bf45a7d22/protobuf-7.35.1-cp310-abi3-win32.whl", hash = "sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30", size = 428945, upload-time = "2026-06-11T21:55:37.034Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/19/8d0cb6f20a1ef7b18f1c8986ad5783f22f84cce39c6ce9a6e645ea55192e/protobuf-7.35.1-cp310-abi3-win_amd64.whl", hash = "sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87", size = 439996, upload-time = "2026-06-11T21:55:38.123Z" },
+    { url = "https://files.pythonhosted.org/packages/19/c7/5f7c636ec43e0c545e28d1f1db71990108306f7bdcb89f069ba97e428e7f/protobuf-7.35.1-py3-none-any.whl", hash = "sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9", size = 171659, upload-time = "2026-06-11T21:55:39.155Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/08/f1ba952f1c8ae5581c70fa9c6da89f247b83e3dd8c09c035d5d7931fc23d/pydantic_core-2.46.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4", size = 2113146, upload-time = "2026-05-06T13:37:36.537Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c6/65f646c7ff09bd257f660434adb45c4dfcbbcebcc030562fecf6f5bf887d/pydantic_core-2.46.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5", size = 1949769, upload-time = "2026-05-06T13:37:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ba/bfb1d928fd5b49e1258935ff104ae356e9fd89384a55bf9f847e9193ad40/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba", size = 1974958, upload-time = "2026-05-06T13:37:28.611Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/74/76223bfb117b64af743c9b6670d1364516f5c0604f96b48f3272f6af6cc6/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b", size = 2042118, upload-time = "2026-05-06T13:36:55.216Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/7b/848732968bc8f48f3187542f08358b9d842db564147b256669426ebb1652/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c", size = 2222876, upload-time = "2026-05-06T13:38:25.455Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/e90b63ee2e14bd8d3db8f705a6d75d64e6ee1b7c2c8833747ce706e1e0ce/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50", size = 2286703, upload-time = "2026-05-06T13:37:53.304Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/1e/acc4d70f88a0a277e4a1fa77ebb985ceabaf900430f875bf9338e11c9420/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd", size = 2092042, upload-time = "2026-05-06T13:38:46.981Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/da/0a422b57bf8504102bf3c4ccea9c41bab5a5cee6a54650acf8faf67f5a24/pydantic_core-2.46.4-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01", size = 2117231, upload-time = "2026-05-06T13:39:23.146Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2a/2ac13c3af305843e23c5078c53d135656b3f05a2fd78cb7bbbb12e97b473/pydantic_core-2.46.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d", size = 2168388, upload-time = "2026-05-06T13:40:08.06Z" },
+    { url = "https://files.pythonhosted.org/packages/72/04/2beacf7e1607e93eefe4aed1b4709f079b905fb77530179d4f7c71745f22/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4", size = 2184769, upload-time = "2026-05-06T13:38:13.901Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/29/d2b9fd9f539133548eaf622c06a4ce176cb46ac59f32d0359c4abc0de047/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f", size = 2319312, upload-time = "2026-05-06T13:39:08.24Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/af/0f7a5b85fec6075bea96e3ef9187de38fccced0de92c1e7feda8d5cc7bb9/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39", size = 2361817, upload-time = "2026-05-06T13:38:43.2Z" },
+    { url = "https://files.pythonhosted.org/packages/25/a4/73363fec545fd3ec025490bdda2743c56d0dd5b6266b1a53bbe9e4265375/pydantic_core-2.46.4-cp310-cp310-win32.whl", hash = "sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d", size = 1987085, upload-time = "2026-05-06T13:39:25.497Z" },
+    { url = "https://files.pythonhosted.org/packages/01/aa/62f082da2c91fac1c234bc9ee0066257ce83f0604abd72e4c9d5991f2d84/pydantic_core-2.46.4-cp310-cp310-win_amd64.whl", hash = "sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf", size = 2074311, upload-time = "2026-05-06T13:39:59.922Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/fa/6d7708d2cfc1a832acb6aeb0cd16e801902df8a0f583bb3b4b527fde022e/pydantic_core-2.46.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594", size = 2111872, upload-time = "2026-05-06T13:40:27.596Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6f/aa064a3e74b5745afbdf250594f38e7ead05e2d651bcb35994b9417a0d4d/pydantic_core-2.46.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c", size = 1948255, upload-time = "2026-05-06T13:39:12.574Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3a/41114a9f7569b84b4d84e7a018c57c56347dac30c0d4a872946ec4e36c46/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826", size = 1972827, upload-time = "2026-05-06T13:38:19.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/25/1ab42e8048fe551934d9884e8d64daa7e990ad386f310a15981aeb6a5b08/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04", size = 2041051, upload-time = "2026-05-06T13:38:10.447Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c2/1a934597ddf08da410385b3b7aae91956a5a76c635effef456074fad7e88/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e", size = 2221314, upload-time = "2026-05-06T13:40:13.089Z" },
+    { url = "https://files.pythonhosted.org/packages/02/6d/9e8ad178c9c4df27ad3c8f25d1fe2a7ab0d2ba0559fad4aee5d3d1f16771/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3", size = 2285146, upload-time = "2026-05-06T13:38:59.224Z" },
+    { url = "https://files.pythonhosted.org/packages/80/50/540cd3aeefc041beb111125c4bff779831a2111fc6b15a9138cda277d32c/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4", size = 2089685, upload-time = "2026-05-06T13:38:17.762Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/a4/b440ad35f05f6a38f89fa0f149accb3f0e02be94ca5e15f3c449a61b4bc9/pydantic_core-2.46.4-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398", size = 2115420, upload-time = "2026-05-06T13:37:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/99/61/de4f55db8dfd57bfdfa9a12ec90fe1b57c4f41062f7ca86f08586b3e0ac0/pydantic_core-2.46.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3", size = 2165122, upload-time = "2026-05-06T13:37:01.167Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/52/7c529d7bdb2d1068bd52f51fe32572c8301f9a4febf1948f10639f1436f5/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848", size = 2182573, upload-time = "2026-05-06T13:38:45.04Z" },
+    { url = "https://files.pythonhosted.org/packages/37/b3/7c40325848ba78247f2812dcf9c7274e38cd801820ca6dd9fe63bcfb0eb4/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3", size = 2317139, upload-time = "2026-05-06T13:37:15.539Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/37/f913f81a657c865b75da6c0dbed79876073c2a43b5bd9edbe8da785e4d49/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109", size = 2360433, upload-time = "2026-05-06T13:37:30.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/67/6acaa1be2567f9256b056d8477158cac7240813956ce86e49deae8e173b4/pydantic_core-2.46.4-cp311-cp311-win32.whl", hash = "sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda", size = 1985513, upload-time = "2026-05-06T13:38:15.669Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/e6/c505f83dfeda9a2e5c995cfd872949e4d05e12f7feb3dca72f633daefa94/pydantic_core-2.46.4-cp311-cp311-win_amd64.whl", hash = "sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33", size = 2071114, upload-time = "2026-05-06T13:40:35.416Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/da/7a263a96d965d9d0df5e8de8a475f33495451117035b09acb110288c381f/pydantic_core-2.46.4-cp311-cp311-win_arm64.whl", hash = "sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d", size = 2044298, upload-time = "2026-05-06T13:38:29.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+    { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" },
+    { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/a4/73995fd4ebbb46ba0ee51e6fa049b8f02c40daebb762208feda8a6b7894d/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c", size = 2111589, upload-time = "2026-05-06T13:37:10.817Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7f/f37d3a5e8bfcc2e403f5c57a730f2d815693fb42119e8ea48b3789335af1/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b", size = 1944552, upload-time = "2026-05-06T13:36:56.717Z" },
+    { url = "https://files.pythonhosted.org/packages/15/3c/d7eb777b3ff43e8433a4efb39a17aa8fd98a4ee8561a24a67ef5db07b2d6/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b", size = 1982984, upload-time = "2026-05-06T13:39:06.207Z" },
+    { url = "https://files.pythonhosted.org/packages/63/87/70b9f40170a81afd55ca26c9b2acb25c20d64bcfbf888fafecb3ba077d4c/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea", size = 2138417, upload-time = "2026-05-06T13:39:45.476Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+    { url = "https://files.pythonhosted.org/packages/11/cb/428de0385b6c8d44b716feba566abfacfbd23ee3c4439faa789a1456242f/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0", size = 2112782, upload-time = "2026-05-06T13:37:04.016Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b5/6a17bdadd0fc1f170adfd05a20d37c832f52b117b4d9131da1f41bb097ce/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7", size = 1952146, upload-time = "2026-05-06T13:39:43.092Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/dc/03734d80e362cd43ef65428e9de77c730ce7f2f11c60d2b1e1b39f0fbf99/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2", size = 2134492, upload-time = "2026-05-06T13:36:58.124Z" },
+    { url = "https://files.pythonhosted.org/packages/de/df/5e5ffc085ed07cc22d298134d3d911c63e91f6a0eb91fe646750a3209910/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9", size = 2156604, upload-time = "2026-05-06T13:37:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/81/44/6e112a4253e56f5705467cbab7ab5e91ee7398ba3d56d358635958893d3e/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf", size = 2183828, upload-time = "2026-05-06T13:37:43.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/5565071e937d8e752842ac241463944c9eb14c87e2d269f2658a5bd05e98/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30", size = 2310000, upload-time = "2026-05-06T13:37:56.694Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c3/66883a5cec183e7fba4d024b4cbbe61851a63750ef606b0afecc46d1f2bf/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc", size = 2361286, upload-time = "2026-05-06T13:40:05.667Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.14.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" },
+]
+
+[[package]]
+name = "pyfiglet"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/e3/0a86276ad2c383ce08d76110a8eec2fe22e7051c4b8ba3fa163a0b08c428/pyfiglet-1.0.4.tar.gz", hash = "sha256:db9c9940ed1bf3048deff534ed52ff2dafbbc2cd7610b17bb5eca1df6d4278ef", size = 1560615, upload-time = "2025-08-15T18:32:47.302Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/5c/fe9f95abd5eaedfa69f31e450f7e2768bef121dbdf25bcddee2cd3087a16/pyfiglet-1.0.4-py3-none-any.whl", hash = "sha256:65b57b7a8e1dff8a67dc8e940a117238661d5e14c3e49121032bd404d9b2b39f", size = 1806118, upload-time = "2025-08-15T18:32:45.556Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pymdown-extensions"
+version = "11.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/21/a9/5f0c535ba3b08fe09270c16808e053a968868242ecbd5676d4e3a488bf28/pymdown_extensions-11.0.1.tar.gz", hash = "sha256:dd2905ae6fc5b75582fafb139a1266ffc754705efa902aa50067fa7ff4f94ec0", size = 857113, upload-time = "2026-07-02T17:59:22.955Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/54/da572c98c0b77626a91b5d3b89f0231d8bff5125c225420908632f8b342d/pymdown_extensions-11.0.1-py3-none-any.whl", hash = "sha256:db3943a62bab7e03af1364f0c4083e64b91fb097675a4b6cceccfbe9a77e5eb2", size = 269455, upload-time = "2026-07-02T17:59:21.271Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
+[[package]]
+name = "pytest-repeat"
+version = "0.9.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/80/d4/69e9dbb9b8266df0b157c72be32083403c412990af15c7c15f7a3fd1b142/pytest_repeat-0.9.4.tar.gz", hash = "sha256:d92ac14dfaa6ffcfe6917e5d16f0c9bc82380c135b03c2a5f412d2637f224485", size = 6488, upload-time = "2025-04-07T14:59:53.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/d4/8b706b81b07b43081bd68a2c0359fe895b74bf664b20aca8005d2bb3be71/pytest_repeat-0.9.4-py3-none-any.whl", hash = "sha256:c1738b4e412a6f3b3b9e0b8b29fcd7a423e50f87381ad9307ef6f5a8601139f3", size = 4180, upload-time = "2025-04-07T14:59:51.492Z" },
+]
+
+[[package]]
+name = "pytest-rerunfailures"
+version = "16.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/47/60/a90ca1cc6cffcb97b4260ed0ad2b7934b999d7c48abe4ea0840344862a3b/pytest_rerunfailures-16.4.tar.gz", hash = "sha256:8222d17c37eb7b9e4d6fc96a3c724ff4e1a5c97a5cc7cbb2c19e9282cfd21a11", size = 36635, upload-time = "2026-07-01T06:30:56.813Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/93/3cdcc4033444e822e01b573414b03fd37fd5533070c750477b8f5fa5224b/pytest_rerunfailures-16.4-py3-none-any.whl", hash = "sha256:f69b5beb39622c90d1e44bd945d826eff6db545dcf0b68f52b7e4ad15eaf6d6c", size = 16955, upload-time = "2026-07-01T06:30:55.333Z" },
+]
+
+[[package]]
+name = "pytest-xdist"
+version = "3.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "execnet" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "312"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/1b/9cfdeac80ee45bebbbcb31f1b7b99a0d81a1c72de48d837be984e0e88b1d/pywin32-312-cp310-cp310-win32.whl", hash = "sha256:772235332b5d1024c696f11cea1ae4be7930f0a8b894bb43db14e3f435f1ff7e", size = 6361387, upload-time = "2026-06-04T07:49:14.329Z" },
+    { url = "https://files.pythonhosted.org/packages/33/b1/7afc96d041d982c27bc2df6f853d43f01fd273e3d39d04be3647ddeb533d/pywin32-312-cp310-cp310-win_amd64.whl", hash = "sha256:5dbc35d2b5320dc07f25fa31269cfb767471002b17de5eb067d03da68c7cb2db", size = 6926780, upload-time = "2026-06-04T07:49:16.881Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/4140da9ad54108e517f4a16b2d83da3033e08662144623e1239587cb7db6/pywin32-312-cp310-cp310-win_arm64.whl", hash = "sha256:3020656e34f1cf7faeb7bccd2b84653a607c6ff0c55ada85e6487d61716deabd", size = 4307203, upload-time = "2026-06-04T07:49:18.993Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f5/10a6e845a00fc5e7afd0a988b744f403d4d57162a28d160a093c4d9322f0/pywin32-312-cp311-cp311-win32.whl", hash = "sha256:17948aeadbdb091f0ced6ef0841620794e68327b94ee415571c1203594b7215c", size = 6362659, upload-time = "2026-06-04T07:49:21.349Z" },
+    { url = "https://files.pythonhosted.org/packages/35/c4/dcd2d62b5944b6d5db53413a5899016ccd57ffcb7278f3f81655d25d2027/pywin32-312-cp311-cp311-win_amd64.whl", hash = "sha256:d11417d84412f859b722fad0841b3614459ed0047f7542d8362e77884f6b6e8a", size = 6928825, upload-time = "2026-06-04T07:49:23.934Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/56/3cbb433fe4501cdba2eb9040f56a4e1a8243faa4186b25295564d1a7a79d/pywin32-312-cp311-cp311-win_arm64.whl", hash = "sha256:b2200a054ca6d6625c4842fc56a4976a4b47f96b73dbe5538c3f813a80359f47", size = 6721875, upload-time = "2026-06-04T07:49:26.416Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" },
+    { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+]
+
+[[package]]
+name = "pyyaml-env-tag"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
+]
+
+[[package]]
+name = "questionary"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prompt-toolkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/45/eafb0bba0f9988f6a2520f9ca2df2c82ddfa8d67c95d6625452e97b204a5/questionary-2.1.1.tar.gz", hash = "sha256:3d7e980292bb0107abaa79c68dd3eee3c561b83a0f89ae482860b181c8bd412d", size = 25845, upload-time = "2025-08-28T19:00:20.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/26/1062c7ec1b053db9e499b4d2d5bc231743201b74051c973dadeac80a8f43/questionary-2.1.1-py3-none-any.whl", hash = "sha256:a51af13f345f1cdea62347589fbb6df3b290306ab8930713bfae4d475a7d4a59", size = 36753, upload-time = "2025-08-28T19:00:19.56Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.7.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/37/451aaddbf50922f34d744ad5ca919ae1fcfac112123885d9728f52a484b3/regex-2026.7.10.tar.gz", hash = "sha256:1050fedf0a8a92e843971120c2f57c3a99bea86c0dfa1d63a9fac053fe54b135", size = 416282, upload-time = "2026-07-10T19:49:46.267Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/69/62bb7d63f26698949c905cb7ebe29c7b0659e2a7f2a50c35cc29640b0852/regex-2026.7.10-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:799a369bdab91dcf0eb424ebd7aa9650897025ce22f729248d8f2c72002c4daa", size = 494652, upload-time = "2026-07-10T19:46:28.394Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/f2/eed2ce38cc38def9c366d060ec739ff5f235a33647ceb73ae6be37306d39/regex-2026.7.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f0192e5f1cfc70e3cb35347135dd02e7497b3e7d83e378aa226d8b3e53a93f19", size = 295920, upload-time = "2026-07-10T19:46:30.342Z" },
+    { url = "https://files.pythonhosted.org/packages/36/57/4d724eeb1c440d71ccd6400d33b62b911bb62ca05385fe1961556e628319/regex-2026.7.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:221f2771cb780186b94bbf125a151bbeb242fa1a971da6ad59d7b0370f19de9a", size = 290696, upload-time = "2026-07-10T19:46:31.953Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/9d/76c6779e424c64740d2a564b7ecb389a62c77b6294127d34f52008c91ea7/regex-2026.7.10-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab2fb1f7a2deb4ca3ddebbae6b93905d21480a3b4e11de28d79d9fb0d316fcf8", size = 784833, upload-time = "2026-07-10T19:46:33.145Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ec/f777841d88f0c9d46699daf16f86a8086e077e506603be212de2c4584f85/regex-2026.7.10-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2f98ef73a13791a387d5c841416ad7f52040ae5caf10bcf46fa12bd2b3d63745", size = 852182, upload-time = "2026-07-10T19:46:34.368Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/de/5ba208a0826117851f6c12af9ae7fae5838ccfde69b999b26c5fdc1cedc3/regex-2026.7.10-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9a094ed44a22f9da497453137c3118b531fd783866ab524b0b0fc146e7395e1d", size = 899571, upload-time = "2026-07-10T19:46:35.564Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/46/602b7b81d26a53113d3cec6dd845fd664d7b854b0ea45245bfdd6b9dc9ef/regex-2026.7.10-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53bbbd6c610489700f7110db1d85f3623924c3f7c760f987eca033867360788a", size = 794164, upload-time = "2026-07-10T19:46:36.972Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cc/c21ebc520c3e17d93e495eb2de2b1c5ae5f6780ccdb298b2d8ce1e940820/regex-2026.7.10-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:87b776cf2890e356e4ab104b9df846e169da3eb5b0f110975547091f4e51854e", size = 786304, upload-time = "2026-07-10T19:46:38.238Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d8/69ec8c062bbba8d4d153f9eb70ab43564f591035b81fc4ea7eb059fdf71c/regex-2026.7.10-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ab39d2c967aae3b48a412bff9cdbe7cd7559cd1e277599aceaeada7bc82b7200", size = 769958, upload-time = "2026-07-10T19:46:39.541Z" },
+    { url = "https://files.pythonhosted.org/packages/af/82/c56db326ac5f852865bd78d49a275757cc367e8114b13bc1015ed2491db1/regex-2026.7.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b56416091bfd7a429f958f69aaf6823c517be9a49cb5bf1daa3767ce8bf8095e", size = 775056, upload-time = "2026-07-10T19:46:40.808Z" },
+    { url = "https://files.pythonhosted.org/packages/af/2a/1ba62462f679eb598d7325ff20798a264ddb9aa34a3f5d2ac388d54c6e4b/regex-2026.7.10-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:617e8f10472e34a8477931f978ff3a88d46ae2ba0e41927e580b933361f60948", size = 848857, upload-time = "2026-07-10T19:46:42.02Z" },
+    { url = "https://files.pythonhosted.org/packages/84/5b/37bf2e2fe810540ca90bbfe457a2f61088721c95d442eee8bb1257165ad7/regex-2026.7.10-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:31fa17378b29519bfd0a1b8ba4e9c10cf0baf1cf4099b39b0689429e7dc2c795", size = 757747, upload-time = "2026-07-10T19:46:43.282Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/c5/131dd41f73f766af6b08492073b5f28bc4f907b5571230c9f9e895e88302/regex-2026.7.10-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5c363de7c0339d39341b6181839ed32509820b85ef506deafcf2e7e43baadab4", size = 837183, upload-time = "2026-07-10T19:46:44.91Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ee/00b9332c3c5d7460639f2c10fdc7197a64de6eaafff69478ec3332815335/regex-2026.7.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ed7c886a2fcbf14493ceaf9579394b33521730c161ebb8dad7db9c3e9fcab1a8", size = 782151, upload-time = "2026-07-10T19:46:46.385Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/a7/31ce26ec6465c12e7136ea9efcc716f5c55cac616f7958c33f0bf171781e/regex-2026.7.10-cp310-cp310-win32.whl", hash = "sha256:b04583e8867136ae66353fa274f45121ab3ec3166dc45aaff3655a5db90d9f0e", size = 266770, upload-time = "2026-07-10T19:46:47.608Z" },
+    { url = "https://files.pythonhosted.org/packages/71/00/22a554bb83203eef88a40ec2fe7cf9a6e5df8765d57f7a96ebe1af5d60c3/regex-2026.7.10-cp310-cp310-win_amd64.whl", hash = "sha256:e21e888a6b471b2bb1cdd4247e8d86632672232f29be583e7eafaa5f4634d34c", size = 277941, upload-time = "2026-07-10T19:46:48.915Z" },
+    { url = "https://files.pythonhosted.org/packages/76/46/596a7084918ddf18cea6fb0cc047af1f00cec8790962e8f2edee9b6ec749/regex-2026.7.10-cp310-cp310-win_arm64.whl", hash = "sha256:081acf191b4d614d573a56cab69f948b6864daa5e3cc69f209ee92e26e454c2f", size = 276923, upload-time = "2026-07-10T19:46:50.829Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/bfd13770be1acd1c05506b93fc6be15c759d6417595d1ba334d355efbf26/regex-2026.7.10-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:66d2c35587cd601c95965d5c0415058ba5cfd6ffbab7624ce198bd967102b341", size = 494639, upload-time = "2026-07-10T19:46:52.207Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b4/0086215709f0f705661f13ba81516287538886ef0d589c545c12b0484669/regex-2026.7.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:28a0973eeffff4292f5a7ee498ab65d5e94ee8cc9cea364239251eb4a260a0f1", size = 295920, upload-time = "2026-07-10T19:46:53.63Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9e/8e07d0eea46d2cf36bf4d3794634bb0a820f016d31bc349dfef008d96b02/regex-2026.7.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8331484450b3894298bef8abecce532171ff6ac60b71f999eed10f2c01941a8a", size = 290673, upload-time = "2026-07-10T19:46:54.863Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/56/d83c446de21c70ff49d2f1b2ff2196ac79a4ac6373d2cfe496011a250600/regex-2026.7.10-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0639b2488b775a0109f55a5a2172deebdedb4b6c5ab0d48c90b43cbf5de58d17", size = 792378, upload-time = "2026-07-10T19:46:56.116Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/0e/d265e0cc6da47aea97e90eb896be2d2e8f92d16add13bac04fa46a0fd972/regex-2026.7.10-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:be4223af640d0aa04c05db81d5d96ada3ead9c09187d892fd37f4f97829480be", size = 861790, upload-time = "2026-07-10T19:46:57.611Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a5/62655f6208d1170a3e9188d6a45d4af0a5ae3b9da8b87d474818ac5ff016/regex-2026.7.10-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d3c75d57a00109255e60bc9c623b6ececaf7905eaab845c79f036670ed4750a2", size = 906530, upload-time = "2026-07-10T19:46:59.142Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b7/d65aa2e9ffb18677cd0afbcf5990da8519a4e50778deb1bca49f043c5174/regex-2026.7.10-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:724ee9379568658ec06362cf24325c5315cc5a67f61dfe585bfeff58300a355b", size = 799912, upload-time = "2026-07-10T19:47:00.534Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/19/3a5ce23ea2eb1fe36306aef49c79746ce297e4b434aeb981b525c661413a/regex-2026.7.10-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:732c19e5828eb287d01edb83b2eb87f283ba8e5fc3441c732709d3e8cbd14aaa", size = 773675, upload-time = "2026-07-10T19:47:01.999Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/76/3c0eaa426700dd2ba14f2335f2b700a4e1484202254192ae440b83b8352a/regex-2026.7.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:982d07727c809b42a3968785354f11c3728414e4e90af0754345b431b2c32561", size = 781711, upload-time = "2026-07-10T19:47:03.425Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a8/a5a3fad84f9a7f897619f0f8e0a2c64946e9709044a186a8f869fb5c332f/regex-2026.7.10-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4574feca202f8c470bf678aed8b5d89df04aaf8dc677f3b83d92825051301c0f", size = 854539, upload-time = "2026-07-10T19:47:04.999Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/c7/47e9b8c8ee77723b9eda74f517b6b25d2f555cf276c063a9eeea35bd86d5/regex-2026.7.10-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:80151ca5bfc6c4524186b3e08b499e97319b2001fc265ed2d4fc12c0d5692cdf", size = 763378, upload-time = "2026-07-10T19:47:06.845Z" },
+    { url = "https://files.pythonhosted.org/packages/36/09/e27e42d9d42edf71205c7e6f5b2902bc874ea03c557c80da03b8ed16c9bf/regex-2026.7.10-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bb52e10e453b5493afe1f7702a2973bc10f4dd8901c0f2ed869ffaa3f8319296", size = 844663, upload-time = "2026-07-10T19:47:08.923Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/b5/2423acb98362184ad9c8eebabafa15188d6a177daab919add8f2120fc6cd/regex-2026.7.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e37aba1994d73b4944053ab65a15f313bd5c28c885dd7f0d494a11749d89db6e", size = 789236, upload-time = "2026-07-10T19:47:10.303Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ed/b387e84c8a3d6aa115dfb56865437a3fbaf28f4a6fb3b76cc6cce38ced70/regex-2026.7.10-cp311-cp311-win32.whl", hash = "sha256:6cbedeb5112f59dbd169385459b9943310bdd241c6966c19c5f6e2295055c93a", size = 266774, upload-time = "2026-07-10T19:47:11.904Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/64/f30a163a65ed1f07ad12c53af00a6bd2a7251a5329fba5a08adc6f9e81a3/regex-2026.7.10-cp311-cp311-win_amd64.whl", hash = "sha256:b1963ec5ba4d52788fb0eac6aca6eb8040e8e318c7e47ebbdfc09440c802919c", size = 277959, upload-time = "2026-07-10T19:47:13.231Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/de/61c8174171134cebb834ca9f8fe2ff8f49d8a3dd43453b48b537d0fbb49b/regex-2026.7.10-cp311-cp311-win_arm64.whl", hash = "sha256:3750c42d47712e362158a04d0fd80131f73a55e8c715b2885442a0ff6f9fc3fc", size = 276918, upload-time = "2026-07-10T19:47:14.693Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9c/2503d4ccf3452dc323f8baa3cf3ee10406037d52735c76cfced81423f183/regex-2026.7.10-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7252b48b0c60100095088fbeb281fca9a4fcf678a4e04b1c520c3f8613c952c4", size = 497114, upload-time = "2026-07-10T19:47:16.22Z" },
+    { url = "https://files.pythonhosted.org/packages/91/eb/04534f4263a4f658cd20a511e9d6124350044f2214eb24fee2db96acf318/regex-2026.7.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:da6ef4cb8d457aab0482b50120136ae94238aaa421863eaa7d599759742c72d6", size = 297422, upload-time = "2026-07-10T19:47:17.794Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2d/35809de392ab66ba439b58c3187ae3b8b53c883233f284b59961e5725c99/regex-2026.7.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fe7ff456c22725c9d9017f7a2a7df2b51af6df77314176760b22e2d05278e181", size = 292110, upload-time = "2026-07-10T19:47:19.188Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1e/5ce0fbe9aab071893ce2b7df020d0f561f7b411ec334124302468d587884/regex-2026.7.10-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3463a5f26be513a49e4d497debcf1b252a2db7b92c77d89621aa90b83d2dd38", size = 796800, upload-time = "2026-07-10T19:47:20.639Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/67/c1ccbada395c10e334763b583e1039b1660b142303ebb941d4269130b22f/regex-2026.7.10-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:948dfc62683a6947b9b486c4598d8f6e3ecc542478b6767b87d52be68aeb55c6", size = 865509, upload-time = "2026-07-10T19:47:22.135Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/06/f0b31afc16c1208f945b66290eb2a9936ab8becdfb23bbcedb91cc5f9d9b/regex-2026.7.10-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c2cbd385d82f63bb35edb60b09b08abad3619bd0a4a492ae59e55afaf98e1b9d", size = 912395, upload-time = "2026-07-10T19:47:24.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1c/8687de3a6c3220f4f872a9bf4bcd8dc249f2a96e7dddfa93de8bd4d16399/regex-2026.7.10-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6222cafe00e072bb2b8f14142cd969637411fbc4dd3b1d73a90a3b817fa046f", size = 801308, upload-time = "2026-07-10T19:47:25.696Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e3/60a40ec02a2315d826414a125640aceb6f30450574c530c8f352110ece0e/regex-2026.7.10-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:65ee5d1ac3cd541325f5ac92625b1c1505f4d171520dd931bda7952895c5321a", size = 777120, upload-time = "2026-07-10T19:47:27.158Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9a/ec579b4f840ac59bc7c192b56e66abd4cbf385615300d59f7c94bf6863ae/regex-2026.7.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa34473fbcc108fea403074f3f45091461b18b2047d136f16ffaa4c65ad46a68", size = 785164, upload-time = "2026-07-10T19:47:28.732Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1c/60d88afd5f98d4b0fb1f8b8969270628140dc01c7ff93a939f2aa83f31a6/regex-2026.7.10-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d028d189d8f38d7ff292f22187c0df37f2317f554d2ed9a2908ada330af57c0", size = 860161, upload-time = "2026-07-10T19:47:30.605Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/40/08ae3ba45fe79e48c9a888a3389a7ee7e2d8c580d2d996da5ece02dfdcb9/regex-2026.7.10-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:396ea70e4ea1f19571940add3bad9fd3eb6a19dc610d0d01f692bc1ba0c10cb4", size = 765829, upload-time = "2026-07-10T19:47:32.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/e6/e613c6755d19aca9d977cdc3418a1991ffc8f386779752dd8fdfa888ea89/regex-2026.7.10-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:ebbf0d83ed5271991d666e54bb6c90ac2c55fb2ef3a88740c6af85dc85de2402", size = 852170, upload-time = "2026-07-10T19:47:33.567Z" },
+    { url = "https://files.pythonhosted.org/packages/03/33/89072f2060e6b844b4916d5bc40ef01e973640c703025707869264ec75ab/regex-2026.7.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:58a4571b2a093f6f6ee4fd281faa8ebf645abcf575f758173ea2605c7a1e1ecb", size = 789550, upload-time = "2026-07-10T19:47:35.395Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/3c/4bc8be9a155035e63780ccac1da101f36194946fdc3f6fce90c7179fc6df/regex-2026.7.10-cp312-cp312-win32.whl", hash = "sha256:eac1207936555aa691ce32df1432b478f2729d54e6d93a1f4db9215bcd8eb47d", size = 267151, upload-time = "2026-07-10T19:47:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/9f5aade65bb98cc6e99c336e45a49a658300720c16721f3e687f8d754fec/regex-2026.7.10-cp312-cp312-win_amd64.whl", hash = "sha256:ecae626449d00db8c08f8f1fc00047a32d6d7eb5402b3976f5c3fda2b80a7a4f", size = 277751, upload-time = "2026-07-10T19:47:38.488Z" },
+    { url = "https://files.pythonhosted.org/packages/36/6f/d069dd12872ea1d50e17319d342f89e2072cae4b62f4245009a1108c74d8/regex-2026.7.10-cp312-cp312-win_arm64.whl", hash = "sha256:87794549a3f5c1c2bdfba2380c1bf87b931e375f4133d929da44f95e396bf5fe", size = 277063, upload-time = "2026-07-10T19:47:40.023Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/88/0c977b9f3ba9b08645516eca236388c340f56f7a87054d41a187a04e134c/regex-2026.7.10-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4db009b4fc533d79af3e841d6c8538730423f82ea8508e353a3713725de7901c", size = 496868, upload-time = "2026-07-10T19:47:41.675Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/51/600882cd5d9a3cf083fd66a4064f5b7f243ba2a7de2437d42823e286edaf/regex-2026.7.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b96341cb29a3faa5db05aff29c77d141d827414f145330e5d8846892119351c1", size = 297306, upload-time = "2026-07-10T19:47:43.521Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6f/48a912054ffcb756e374207bb8f4430c5c3e0ffa9627b3c7b6661844b30a/regex-2026.7.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:14d27f6bd04beb01f6a25a1153d73e58c290fd45d92ba56af1bb44199fd1010d", size = 291950, upload-time = "2026-07-10T19:47:45.267Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/c8/8e1c3c86ebcee7effccbd1f7fc54fe3af22aa0e9204503e2baea4a6ff001/regex-2026.7.10-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6b6a11bf898cca3ce7bfaa17b646901107f3975677fbd5097f36e5eb5641983", size = 796817, upload-time = "2026-07-10T19:47:48.054Z" },
+    { url = "https://files.pythonhosted.org/packages/65/39/3e49d9ff0e0737eb8180a00569b47aabb59b84611f48392eba4d998d91a0/regex-2026.7.10-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:234f8e0d65cf1df9becadae98648f74030ee85a8f12edcb5eb0f60a22a602197", size = 865513, upload-time = "2026-07-10T19:47:49.855Z" },
+    { url = "https://files.pythonhosted.org/packages/70/57/6511ad809bb3122c65bbeeffa5b750652bb03d273d29f3acb0754109b183/regex-2026.7.10-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:91b916d495db3e1b473c7c8e68733beec4dce8e487442db61764fff94f59740e", size = 912391, upload-time = "2026-07-10T19:47:51.776Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/29/a1b0c109c9e878cb04b931bfe4c54332d692b93c322e127b5ae9f25b0d9e/regex-2026.7.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f0d4ccf70b1d13711242de0ba78967db5c35d12ac408378c70e06295c3f6644", size = 801338, upload-time = "2026-07-10T19:47:53.38Z" },
+    { url = "https://files.pythonhosted.org/packages/33/be/171c3dad4d77000e1befeff2883ca88734696dfd97b2951e5e074f32e4dd/regex-2026.7.10-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c622f4c638a725c39abcb2e680b1bd592663c83b672a4ed350a17f806d75618e", size = 777149, upload-time = "2026-07-10T19:47:54.944Z" },
+    { url = "https://files.pythonhosted.org/packages/33/61/41ab0de0e4574da1071c151f67d1eb9db3d92c43e31d64d2e6863c3d89bf/regex-2026.7.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41a47c2b28d9421e2509a4583a22510dc31d83212fcf38e1508a7013140f71a8", size = 785216, upload-time = "2026-07-10T19:47:56.56Z" },
+    { url = "https://files.pythonhosted.org/packages/66/28/372859ea693736f07cf7023247c7eca8f221d9c6df8697ff9f93371cca08/regex-2026.7.10-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:13fba679fe035037e9d5286620f88bbfd105df4d5fcd975942edd282ab986775", size = 860229, upload-time = "2026-07-10T19:47:58.278Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b1/e1d32cd944b599534ae655d35e8640d0ec790c0fa12e1fb29bf434d50f55/regex-2026.7.10-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8e26a075fa9945b9e44a3d02cc83d776c3b76bb1ff4b133bbfa620d5650131da", size = 765797, upload-time = "2026-07-10T19:48:00.291Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/79a2cd9556a3329351e370929743ef4f0ccc0aaff6b3dc414ae5fa4a1302/regex-2026.7.10-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d0834c84ae8750ae1c4cede59b0afd4d2f775be958e11b18a3eea24ed9d0d9f1", size = 852130, upload-time = "2026-07-10T19:48:01.972Z" },
+    { url = "https://files.pythonhosted.org/packages/66/58/76fec29898cf5d359ab63face50f9d4f7135cc2eca3477139227b1d09952/regex-2026.7.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64722a5031aeace7f6c8d5ea9a9b22d9368af0d6e8fa532585da8158549ea963", size = 789644, upload-time = "2026-07-10T19:48:03.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/06/3c7cec7817bda293e13c8f88aed227bbcf8b37e5990936ff6442a8fdf11a/regex-2026.7.10-cp313-cp313-win32.whl", hash = "sha256:74ae61d8573ecd51b5eeee7be2218e4c56e99c14fa8fcf97cf7519611d4be92e", size = 267130, upload-time = "2026-07-10T19:48:05.677Z" },
+    { url = "https://files.pythonhosted.org/packages/88/6c/e2a6f9a6a905f923cfc912298a5949737e9504b1ca24f29eda8d04d05ece/regex-2026.7.10-cp313-cp313-win_amd64.whl", hash = "sha256:5e792367e5f9b4ffb8cad93f1beaa91837056b94da98aa5c65a0db0c1b474927", size = 277722, upload-time = "2026-07-10T19:48:07.318Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a6/9d8935aaa940c388496aa1a0c82669cc4b5d06291c2712d595e3f0cf16d3/regex-2026.7.10-cp313-cp313-win_arm64.whl", hash = "sha256:82ab8330e7e2e416c2d42fcec67f02c242393b8681014750d4b70b3f158e1f08", size = 277059, upload-time = "2026-07-10T19:48:08.977Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/e9/26decfd3e85c09e42ff7b0d23a6f51085ca4c268db15f084928ca33459c6/regex-2026.7.10-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:2b93eafd92c4128bab2f93500e8912cc9ecb3d3765f6685b902c6820d0909b6b", size = 501508, upload-time = "2026-07-10T19:48:10.668Z" },
+    { url = "https://files.pythonhosted.org/packages/38/a5/5b167cebde101945690219bf34361481c9f07e858a4f46d9996b80ec1490/regex-2026.7.10-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3f03b92fb6ec739df042e45b06423fc717ecf0063e07ffe2897f7b2d5735e1e8", size = 299705, upload-time = "2026-07-10T19:48:12.544Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/20/7909be4b9f449f8c282c14b6762d59aa722aeaeebe7ee4f9bb623eeaa5e0/regex-2026.7.10-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:bb5aab464a0c5e03a97abad5bdf54517061ebbf72340d576e99ff661a42575cc", size = 294605, upload-time = "2026-07-10T19:48:14.495Z" },
+    { url = "https://files.pythonhosted.org/packages/82/88/e52550185d6fda68f549b01239698697de47320fd599f5e880b1986b7673/regex-2026.7.10-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fadb07dbe36a541283ff454b1a268afd54b077d917043f2e1e5615372cb5f200", size = 811747, upload-time = "2026-07-10T19:48:16.197Z" },
+    { url = "https://files.pythonhosted.org/packages/06/98/16c255c909714de1ee04da6ae30f3ee04170f300cdc0dcf57a314ee4816a/regex-2026.7.10-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:21150500b970b12202879dfd82e7fd809d8e853140fff84d08e57a90cf1e154e", size = 871203, upload-time = "2026-07-10T19:48:18.12Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/32/423ed27c9bae2092a453e853da2b6628a658d08bb5a6117db8d591183d85/regex-2026.7.10-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a68b637451d64ba30ed8ae125c973fa834cc2d37dfa7f154c2b479015d477ba8", size = 917334, upload-time = "2026-07-10T19:48:19.952Z" },
+    { url = "https://files.pythonhosted.org/packages/73/87/74dac8efb500db31cb000fda6bae2be45fc2fbf1fa9412f445fbb8acbe37/regex-2026.7.10-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e23458d8903e33e7d27196d7a311523dc4e2f4137a5f34e4dbd30c8d37ff33e", size = 816379, upload-time = "2026-07-10T19:48:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/9f/1859403654e3e030b288f06d49233c6a4f889d62b84c4ef3f3a28653173d/regex-2026.7.10-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cae27622c094558e519abf3242cf4272db961d12c5c9a9ffb7a1b44b2627d5c6", size = 785563, upload-time = "2026-07-10T19:48:23.643Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d8/35d30d6bdf1ef6a5430e8982607b3a6db4df1ddedbe001e43435585d88ba/regex-2026.7.10-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ee877b6d78f9dff1da94fef51ae8cf9cce0967e043fdcc864c40b85cf293c192", size = 801415, upload-time = "2026-07-10T19:48:25.499Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/22/630f31f5ea4826167b2b064d9cac2093a5b3222af380aa432cfe1a5dabcd/regex-2026.7.10-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:2c66a8a1969cfd506d1e203c0005fd0fc3fe6efc83c945606566b6f9611d4851", size = 866560, upload-time = "2026-07-10T19:48:27.789Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/14/f5914a6d9c5bc63b9bed8c9a1169fb0be35dbe05cdc460e17d953031a366/regex-2026.7.10-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:2bc350e1c5fa250f30ab0c3e38e5cfdffcd82cb8af224df69955cab4e3003812", size = 772877, upload-time = "2026-07-10T19:48:29.563Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/0f/7c13999eef3e4186f7c79d4950fa56f041bf4de107682fb82c80db605ff9/regex-2026.7.10-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:53f54993b462f3f91fea0f2076b46deb6619a5f45d70dbd1f543f789d8b900ef", size = 856648, upload-time = "2026-07-10T19:48:31.282Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/71/a48e43909b6450fb48fa94e783bef2d9a37179258bc32ef2283955df7be7/regex-2026.7.10-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cfcec18f7da682c4e2d82112829ce906569cb8d69fa6c26f3a50dfbed5ceb682", size = 803520, upload-time = "2026-07-10T19:48:33.275Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/b8/f037d1bf2c133cb24ceb6e7d81d08417080390eddab6ddfd701aa7091874/regex-2026.7.10-cp313-cp313t-win32.whl", hash = "sha256:a2d6d30be35ddd70ce0f8ee259a4c25f24d6d689a45a5ac440f03e6bcc5a21d1", size = 269168, upload-time = "2026-07-10T19:48:35.353Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/9c/eaac34f8452a838956e7e89852ad049678cdc1af5d14f72d3b3b658b1ea5/regex-2026.7.10-cp313-cp313t-win_amd64.whl", hash = "sha256:c57b6ad3f7a1bdd101b2966f29dc161adf49727b1e8d3e1e89db2eda8a75c344", size = 280004, upload-time = "2026-07-10T19:48:37.106Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/a9/e22e997587bc1d588b0b2cd0572027d39dd3a006216e40bbf0361688c51c/regex-2026.7.10-cp313-cp313t-win_arm64.whl", hash = "sha256:3d8ef9df02c8083c7b4b855e3cb87c8e0ebbcfea088d98c7a886aaefdf88d837", size = 279308, upload-time = "2026-07-10T19:48:38.907Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/67/cae617f1351490c25a4b8ac3b8b63a4dda609295d8222bad12242dfdc629/rich-14.3.4.tar.gz", hash = "sha256:817e02727f2b25b40ef56f5aa2217f400c8489f79ca8f46ea2b70dd5e14558a9", size = 230524, upload-time = "2026-04-11T02:57:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/76/6d163cfac87b632216f71879e6b2cf17163f773ff59c00b5ff4900a80fa3/rich-14.3.4-py3-none-any.whl", hash = "sha256:07e7adb4690f68864777b1450859253bed81a99a31ac321ac1817b2313558952", size = 310480, upload-time = "2026-04-11T02:57:47.484Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/36/6f65aa9989acdec45d417192d8f4e7921931d8a6cf87ac74bce3eed98a8e/ruff-0.15.21.tar.gz", hash = "sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500", size = 4769401, upload-time = "2026-07-09T20:01:34.005Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/c6/ede15cac6839f3dbce52565c8f5164a8210e669c7bc4decb03e5bdf47d0d/ruff-0.15.21-py3-none-linux_armv6l.whl", hash = "sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d", size = 10854342, upload-time = "2026-07-09T20:00:53.998Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9d/d825b07ee7ea9e2d61df92a860033c94e06e7300d50a1c2653aac27d24fe/ruff-0.15.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd", size = 11139539, upload-time = "2026-07-09T20:00:57.809Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/de/3b107712e642f063c7a9e0887c427b22cb44097de5aab36c05f2e280670c/ruff-0.15.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646", size = 10595437, upload-time = "2026-07-09T20:01:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/6f/b4523cc90ba239ede441447a19d0c968846a3012e5a0b0c5b62831a3d5e3/ruff-0.15.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be", size = 10990053, upload-time = "2026-07-09T20:01:02.187Z" },
+    { url = "https://files.pythonhosted.org/packages/92/cc/c6a9872a5375f0628875481cf2f66b13d7d865bf3ca2e57f91c7e762d976/ruff-0.15.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd", size = 10666096, upload-time = "2026-07-09T20:01:04.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/97/c621f7a17e097f1790fa3af6374138823b330b2d03fc38337945daca212c/ruff-0.15.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41", size = 11537011, upload-time = "2026-07-09T20:01:06.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/51/d928727e476e25ccc57c6f449ffd80241a651a973ad949d39cfb2a771d28/ruff-0.15.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86", size = 12347101, upload-time = "2026-07-09T20:01:08.859Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/88/8cd62026802b16018ad06931d87997cf795ba2a6239ab659606c87d96bf0/ruff-0.15.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67", size = 11572001, upload-time = "2026-07-09T20:01:11.092Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/97/f63084cf55444fc110e8cb985ebfcc592af47f597d44453d778cb81bc156/ruff-0.15.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8", size = 11549239, upload-time = "2026-07-09T20:01:13.27Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/77/f107da4a2874b7715914b03f09ba9c54424de3ff8a1cc5d015d3ee2ce0ac/ruff-0.15.21-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075", size = 11535340, upload-time = "2026-07-09T20:01:15.206Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e9/601deb322d3303a7bf212b0100ead6f2ee3f6a044d89c30f2f92bf83c731/ruff-0.15.21-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341", size = 10964048, upload-time = "2026-07-09T20:01:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/2e/0f2176d1e99c15192caea19c8c3a0a955246b4cb4de795042eeb616345cd/ruff-0.15.21-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d", size = 10667055, upload-time = "2026-07-09T20:01:19.73Z" },
+    { url = "https://files.pythonhosted.org/packages/48/60/abd74a02e0c4214f12a68becfd30af7165cfdcb0e661ecdc60bbb949c09a/ruff-0.15.21-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233", size = 11242043, upload-time = "2026-07-09T20:01:21.947Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c6/583075d8ccabb4b229345edcaf1545eb3d8d6be90f686a479d7e94088bbf/ruff-0.15.21-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f", size = 11648064, upload-time = "2026-07-09T20:01:24.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3c/37d0ecb729a7cc2d393ea7dce316fc585680f35d93b8d62139d7d0a3700c/ruff-0.15.21-py3-none-win32.whl", hash = "sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd", size = 10896555, upload-time = "2026-07-09T20:01:26.941Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b8/e43466b2a6067ce91e669068f6e28d6c719a920f014b070d5c8731725de3/ruff-0.15.21-py3-none-win_amd64.whl", hash = "sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3", size = 12038772, upload-time = "2026-07-09T20:01:29.497Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/75/e90ab9aeece218a9fc5a5bc3ec97d0ee6bb3c4ff95869463c1de58e29a1c/ruff-0.15.21-py3-none-win_arm64.whl", hash = "sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8", size = 11375265, upload-time = "2026-07-09T20:01:31.772Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/a0/f718cda65b05407d228f97602cf60dca269c979867aa5beb25410de26cd3/safetensors-0.8.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0", size = 473568, upload-time = "2026-06-09T07:52:18.829Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b1/fa7c600e7dceae12e9606c7578cbc9ff1e1ed55844883ee5c92205e86226/safetensors-0.8.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25", size = 484562, upload-time = "2026-06-09T07:52:17.518Z" },
+    { url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235", size = 502844, upload-time = "2026-06-09T07:52:07.624Z" },
+    { url = "https://files.pythonhosted.org/packages/91/4f/3175c9d75634e0e0dda0082794193521035edd7c70a6f212bf33ca06ddf4/safetensors-0.8.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0", size = 511823, upload-time = "2026-06-09T07:52:09.565Z" },
+    { url = "https://files.pythonhosted.org/packages/20/87/846c289e7aa2299eff406335717cf43ce8777194ece8aad75772e0411615/safetensors-0.8.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98", size = 633461, upload-time = "2026-06-09T07:52:11.128Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/8d64d9df2c45d5ded401df889d0ad90882804ca172d79ec4f0df8f727fe0/safetensors-0.8.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358", size = 545148, upload-time = "2026-06-09T07:52:13.603Z" },
+    { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" },
+    { url = "https://files.pythonhosted.org/packages/46/fb/cdaed17ceb2948784fd9c36b6fd3e951b608547cea81a48e8ee6f8cfdfcb/safetensors-0.8.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78", size = 513832, upload-time = "2026-06-09T07:52:12.37Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/49/1e15de264dcc3b77943d2d0c56a95809956883b1c2d6d585c792523f180b/safetensors-0.8.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca", size = 559930, upload-time = "2026-06-09T07:52:14.743Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/43/bf38443278eab4b1be1fce2931e2b012ad9cb7df52ada751d0aab8f7659a/safetensors-0.8.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4", size = 678670, upload-time = "2026-06-09T07:52:20.032Z" },
+    { url = "https://files.pythonhosted.org/packages/72/e3/68cd3fa5b48488e84add63e04cb12f3bc28ae4638c06d4508c6e88823d0e/safetensors-0.8.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc", size = 786679, upload-time = "2026-06-09T07:52:21.322Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4b/1c19c509d56e01f4fbb3d0a2e597450f6cc04d1d56cf52defb0a62dfd715/safetensors-0.8.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d", size = 765683, upload-time = "2026-06-09T07:52:22.594Z" },
+    { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/3f/73ccf82579412b4a71c4ca673f10b5f1f888d7cf5af7fe24f27d30307be4/safetensors-0.8.0-cp310-abi3-win32.whl", hash = "sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d", size = 342401, upload-time = "2026-06-09T07:52:28.895Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl", hash = "sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f", size = 355540, upload-time = "2026-06-09T07:52:27.832Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fc/7eedc3510d97878876e32774eebbeb61c43f148a96e915c84229a3e967aa/safetensors-0.8.0-cp310-abi3-win_arm64.whl", hash = "sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452", size = 340500, upload-time = "2026-06-09T07:52:26.745Z" },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "joblib", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "threadpoolctl", marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/3e/daed796fd69cce768b8788401cc464ea90b306fb196ae1ffed0b98182859/scikit_learn-1.7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b33579c10a3081d076ab403df4a4190da4f4432d443521674637677dc91e61f", size = 9336221, upload-time = "2025-09-09T08:20:19.328Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/ce/af9d99533b24c55ff4e18d9b7b4d9919bbc6cd8f22fe7a7be01519a347d5/scikit_learn-1.7.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:36749fb62b3d961b1ce4fedf08fa57a1986cd409eff2d783bca5d4b9b5fce51c", size = 8653834, upload-time = "2025-09-09T08:20:22.073Z" },
+    { url = "https://files.pythonhosted.org/packages/58/0e/8c2a03d518fb6bd0b6b0d4b114c63d5f1db01ff0f9925d8eb10960d01c01/scikit_learn-1.7.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7a58814265dfc52b3295b1900cfb5701589d30a8bb026c7540f1e9d3499d5ec8", size = 9660938, upload-time = "2025-09-09T08:20:24.327Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/75/4311605069b5d220e7cf5adabb38535bd96f0079313cdbb04b291479b22a/scikit_learn-1.7.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a847fea807e278f821a0406ca01e387f97653e284ecbd9750e3ee7c90347f18", size = 9477818, upload-time = "2025-09-09T08:20:26.845Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/9b/87961813c34adbca21a6b3f6b2bea344c43b30217a6d24cc437c6147f3e8/scikit_learn-1.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:ca250e6836d10e6f402436d6463d6c0e4d8e0234cfb6a9a47835bd392b852ce5", size = 8886969, upload-time = "2025-09-09T08:20:29.329Z" },
+    { url = "https://files.pythonhosted.org/packages/43/83/564e141eef908a5863a54da8ca342a137f45a0bfb71d1d79704c9894c9d1/scikit_learn-1.7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e", size = 9331967, upload-time = "2025-09-09T08:20:32.421Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d6/ba863a4171ac9d7314c4d3fc251f015704a2caeee41ced89f321c049ed83/scikit_learn-1.7.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1", size = 8648645, upload-time = "2025-09-09T08:20:34.436Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/0e/97dbca66347b8cf0ea8b529e6bb9367e337ba2e8be0ef5c1a545232abfde/scikit_learn-1.7.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d", size = 9715424, upload-time = "2025-09-09T08:20:36.776Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/32/1f3b22e3207e1d2c883a7e09abb956362e7d1bd2f14458c7de258a26ac15/scikit_learn-1.7.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1", size = 9509234, upload-time = "2025-09-09T08:20:38.957Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/71/34ddbd21f1da67c7a768146968b4d0220ee6831e4bcbad3e03dd3eae88b6/scikit_learn-1.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1", size = 8894244, upload-time = "2025-09-09T08:20:41.166Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/aa/3996e2196075689afb9fce0410ebdb4a09099d7964d061d7213700204409/scikit_learn-1.7.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8d91a97fa2b706943822398ab943cde71858a50245e31bc71dba62aab1d60a96", size = 9259818, upload-time = "2025-09-09T08:20:43.19Z" },
+    { url = "https://files.pythonhosted.org/packages/43/5d/779320063e88af9c4a7c2cf463ff11c21ac9c8bd730c4a294b0000b666c9/scikit_learn-1.7.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:acbc0f5fd2edd3432a22c69bed78e837c70cf896cd7993d71d51ba6708507476", size = 8636997, upload-time = "2025-09-09T08:20:45.468Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/d0/0c577d9325b05594fdd33aa970bf53fb673f051a45496842caee13cfd7fe/scikit_learn-1.7.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e5bf3d930aee75a65478df91ac1225ff89cd28e9ac7bd1196853a9229b6adb0b", size = 9478381, upload-time = "2025-09-09T08:20:47.982Z" },
+    { url = "https://files.pythonhosted.org/packages/82/70/8bf44b933837ba8494ca0fc9a9ab60f1c13b062ad0197f60a56e2fc4c43e/scikit_learn-1.7.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d6e9deed1a47aca9fe2f267ab8e8fe82ee20b4526b2c0cd9e135cea10feb44", size = 9300296, upload-time = "2025-09-09T08:20:50.366Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/99/ed35197a158f1fdc2fe7c3680e9c70d0128f662e1fee4ed495f4b5e13db0/scikit_learn-1.7.2-cp312-cp312-win_amd64.whl", hash = "sha256:6088aa475f0785e01bcf8529f55280a3d7d298679f50c0bb70a2364a82d0b290", size = 8731256, upload-time = "2025-09-09T08:20:52.627Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/93/a3038cb0293037fd335f77f31fe053b89c72f17b1c8908c576c29d953e84/scikit_learn-1.7.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7", size = 9212382, upload-time = "2025-09-09T08:20:54.731Z" },
+    { url = "https://files.pythonhosted.org/packages/40/dd/9a88879b0c1104259136146e4742026b52df8540c39fec21a6383f8292c7/scikit_learn-1.7.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe", size = 8592042, upload-time = "2025-09-09T08:20:57.313Z" },
+    { url = "https://files.pythonhosted.org/packages/46/af/c5e286471b7d10871b811b72ae794ac5fe2989c0a2df07f0ec723030f5f5/scikit_learn-1.7.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f", size = 9434180, upload-time = "2025-09-09T08:20:59.671Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/fd/df59faa53312d585023b2da27e866524ffb8faf87a68516c23896c718320/scikit_learn-1.7.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0", size = 9283660, upload-time = "2025-09-09T08:21:01.71Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/c7/03000262759d7b6f38c836ff9d512f438a70d8a8ddae68ee80de72dcfb63/scikit_learn-1.7.2-cp313-cp313-win_amd64.whl", hash = "sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c", size = 8702057, upload-time = "2025-09-09T08:21:04.234Z" },
+    { url = "https://files.pythonhosted.org/packages/55/87/ef5eb1f267084532c8e4aef98a28b6ffe7425acbfd64b5e2f2e066bc29b3/scikit_learn-1.7.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8", size = 9558731, upload-time = "2025-09-09T08:21:06.381Z" },
+    { url = "https://files.pythonhosted.org/packages/93/f8/6c1e3fc14b10118068d7938878a9f3f4e6d7b74a8ddb1e5bed65159ccda8/scikit_learn-1.7.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a", size = 9038852, upload-time = "2025-09-09T08:21:08.628Z" },
+    { url = "https://files.pythonhosted.org/packages/83/87/066cafc896ee540c34becf95d30375fe5cbe93c3b75a0ee9aa852cd60021/scikit_learn-1.7.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c", size = 9527094, upload-time = "2025-09-09T08:21:11.486Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/2b/4903e1ccafa1f6453b1ab78413938c8800633988c838aa0be386cbb33072/scikit_learn-1.7.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c", size = 9367436, upload-time = "2025-09-09T08:21:13.602Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/aa/8444be3cfb10451617ff9d177b3c190288f4563e6c50ff02728be67ad094/scikit_learn-1.7.2-cp313-cp313t-win_amd64.whl", hash = "sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973", size = 9275749, upload-time = "2025-09-09T08:21:15.96Z" },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "joblib", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "narwhals", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.11' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version >= '3.13' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version >= '3.13' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version >= '3.13' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version == '3.12.*' and extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "threadpoolctl", marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/be/e844fd9586e66540a15b71924d17a6cbc1bb749e81ddd0a796bcdba4c055/scikit_learn-1.9.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9db6f4d34e68c8899e4cab27fdf8eafe6ed21f2ba52ceb25ea250cd237f8e47b", size = 8789686, upload-time = "2026-06-02T11:53:05.439Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e2/ff880f62677a17d035817d543cb0fc8727d01eccbee81c5f7fc733a9d856/scikit_learn-1.9.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f401448645a3e7bc115aa3c094097865155b34bff1cba8101857d9104e99074c", size = 8256782, upload-time = "2026-06-02T11:53:08.904Z" },
+    { url = "https://files.pythonhosted.org/packages/25/64/eb40435e1a508ab1b4e284ce43ae80f6a162e5be5e38ed5a6fab467a9ea4/scikit_learn-1.9.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fd3a8ef0c758555a3b23c03adaa858af32f7736785ded50ad5991f59c4ed03fa", size = 8992419, upload-time = "2026-06-02T11:53:11.551Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/4810a28e473185429e45a57eebcc91fc991b33d889cc0676063e671db03d/scikit_learn-1.9.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7e254636164090da847715a27f8e5478feb98c40a9e0ee90cbd277de9e5ceb8", size = 9281411, upload-time = "2026-06-02T11:53:15.063Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/67/be3d369f40d8178ba3bd86635d132e08cb5329b023e4669d9426d84bc007/scikit_learn-1.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:5dc1818c77575d149e25fce9ef82dd7b7263ae372f03494158668ad632a69759", size = 8272736, upload-time = "2026-06-02T11:53:18.108Z" },
+    { url = "https://files.pythonhosted.org/packages/37/79/a733f02dc2118da7e77a134b34f39f40201a353311b011d20859d2db3556/scikit_learn-1.9.0-cp311-cp311-win_arm64.whl", hash = "sha256:366652351f092b219c248f1e72821e841960a63d8f358f1dcfd54dc1cbdbbc28", size = 7919564, upload-time = "2026-06-02T11:53:21.2Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/20/75f915ff375d6249e6550ac740fdbbd66159a068fd3af1400ff62036b07a/scikit_learn-1.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2bd41b0d201bc81575531b96b713d3eb5e5f50fb0b82101ff0f92294fdc236ac", size = 8741122, upload-time = "2026-06-02T11:53:24.08Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/d5/2b5148f2279196775e1db2aeb85d14b70ac80e7e32b3b28e7ebeafb0901d/scikit_learn-1.9.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:5be45aa4a42a68a533913a6ed736cf309de2226411c79ef8d609a5456f1939b1", size = 8261512, upload-time = "2026-06-02T11:53:27.183Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/ee/5adbc77656b71f9456a2f5a7a9fdb4bcf9207a6b962889f1c2f9323afa4e/scikit_learn-1.9.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e50ed4da51974e86e940690e9a3d82e729b62b5a49f7c9bac534d515d39d86f", size = 8837603, upload-time = "2026-06-02T11:53:30.328Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/c2/63fdda36c56437eeb44aaf9493c8bcd62ce230ab1598924fc626ffbfa943/scikit_learn-1.9.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:056c92bb67ad4c28463c2f2653d9701449201e7e7a9e94e321be0f71c4fef2b8", size = 9132097, upload-time = "2026-06-02T11:53:33.456Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a4/c8e67227c680e2259c8864ae72ff48b06e16a6f51253a22167aa02a8aa4e/scikit_learn-1.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:4306775fad04cc4b472a1b15af1ae9cede1540fbfcc17fbce3767cd8dc7ae283", size = 8211173, upload-time = "2026-06-02T11:53:36.602Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/fd/3c0863792e98e67e9184aa4029288a175935eb65443afcd30d4f143450cf/scikit_learn-1.9.0-cp312-cp312-win_arm64.whl", hash = "sha256:26e22435f63bcdcf396b574273f29f13dd531f5ea035801f5be10ba1540a4e60", size = 7867451, upload-time = "2026-06-02T11:53:39.075Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/01/cf3310626b6d48d3e9be69a1223f9180360b5e6edb045f50fade723ce494/scikit_learn-1.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:80746d63bd4b6eaca54d36fe5feaf4d28bb38dc6f9470f81c7cad7c40155f119", size = 8705188, upload-time = "2026-06-02T11:53:41.964Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/04/5acd7ae280c5f93b6ac5ef6cdec14eef4c8d1cd91d85b3292989c94d96b1/scikit_learn-1.9.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5b934c45c252844a91d69fda3a34cff5e7307e1db10d77cb10a3980312c74713", size = 8228299, upload-time = "2026-06-02T11:53:44.817Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/39/ffe829a5b8ecb40a518724a997794657fdc354ada5e8fe8e64d998c0bac9/scikit_learn-1.9.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:38c3dcb9a1ffb85505ec53d54c7b4aea0cff70050425a7760c2af661ac85df05", size = 8789690, upload-time = "2026-06-02T11:53:47.461Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/88/8dab5de10c638c083772a6be83a3d8106ced492f74a928c8693638e5bb50/scikit_learn-1.9.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da76d09304a4706db7cc1e3ebaa3b6b98a67365cc11d2996c4f1e58ba47df714", size = 9087723, upload-time = "2026-06-02T11:53:50.702Z" },
+    { url = "https://files.pythonhosted.org/packages/20/3f/7917ca72464038f6240ec70c29f94862d08a34a74291ae4d4ec5eb8186a0/scikit_learn-1.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:5808d98f15c6bf6d9d96d2348c1997392a5888ce7097e664105f930c4bca1277", size = 8184330, upload-time = "2026-06-02T11:53:53.396Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c7/15739eb2f61fda3c54639e9942414e5a19ad8a8d1f5a3266afad7cb7df80/scikit_learn-1.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:d77f54c017633791bc0225a43e2f8d03745fdcfe4880268fcc4df15f505dec2e", size = 7840653, upload-time = "2026-06-02T11:53:56.035Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.15.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" },
+    { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload-time = "2025-05-08T16:05:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload-time = "2025-05-08T16:05:20.152Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload-time = "2025-05-08T16:05:24.494Z" },
+    { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload-time = "2025-05-08T16:05:29.313Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload-time = "2025-05-08T16:05:34.699Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload-time = "2025-05-08T16:05:40.762Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload-time = "2025-05-08T16:05:48.119Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload-time = "2025-05-08T16:05:54.22Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload-time = "2025-05-08T16:06:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735, upload-time = "2025-05-08T16:06:06.471Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284, upload-time = "2025-05-08T16:06:11.686Z" },
+    { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958, upload-time = "2025-05-08T16:06:15.97Z" },
+    { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454, upload-time = "2025-05-08T16:06:20.394Z" },
+    { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199, upload-time = "2025-05-08T16:06:26.159Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455, upload-time = "2025-05-08T16:06:32.778Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140, upload-time = "2025-05-08T16:06:39.249Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549, upload-time = "2025-05-08T16:06:45.729Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184, upload-time = "2025-05-08T16:06:52.623Z" },
+    { url = "https://files.pythonhosted.org/packages/73/18/ec27848c9baae6e0d6573eda6e01a602e5649ee72c27c3a8aad673ebecfd/scipy-1.15.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759", size = 38728256, upload-time = "2025-05-08T16:06:58.696Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cd/1aef2184948728b4b6e21267d53b3339762c285a46a274ebb7863c9e4742/scipy-1.15.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62", size = 30109540, upload-time = "2025-05-08T16:07:04.209Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/d8/59e452c0a255ec352bd0a833537a3bc1bfb679944c4938ab375b0a6b3a3e/scipy-1.15.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb", size = 22383115, upload-time = "2025-05-08T16:07:08.998Z" },
+    { url = "https://files.pythonhosted.org/packages/08/f5/456f56bbbfccf696263b47095291040655e3cbaf05d063bdc7c7517f32ac/scipy-1.15.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730", size = 25163884, upload-time = "2025-05-08T16:07:14.091Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/66/a9618b6a435a0f0c0b8a6d0a2efb32d4ec5a85f023c2b79d39512040355b/scipy-1.15.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825", size = 35174018, upload-time = "2025-05-08T16:07:19.427Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/09/c5b6734a50ad4882432b6bb7c02baf757f5b2f256041da5df242e2d7e6b6/scipy-1.15.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7", size = 37269716, upload-time = "2025-05-08T16:07:25.712Z" },
+    { url = "https://files.pythonhosted.org/packages/77/0a/eac00ff741f23bcabd352731ed9b8995a0a60ef57f5fd788d611d43d69a1/scipy-1.15.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11", size = 36872342, upload-time = "2025-05-08T16:07:31.468Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/54/4379be86dd74b6ad81551689107360d9a3e18f24d20767a2d5b9253a3f0a/scipy-1.15.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126", size = 39670869, upload-time = "2025-05-08T16:07:38.002Z" },
+    { url = "https://files.pythonhosted.org/packages/87/2e/892ad2862ba54f084ffe8cc4a22667eaf9c2bcec6d2bff1d15713c6c0703/scipy-1.15.3-cp313-cp313-win_amd64.whl", hash = "sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163", size = 40988851, upload-time = "2025-05-08T16:08:33.671Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/e9/7a879c137f7e55b30d75d90ce3eb468197646bc7b443ac036ae3fe109055/scipy-1.15.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8", size = 38863011, upload-time = "2025-05-08T16:07:44.039Z" },
+    { url = "https://files.pythonhosted.org/packages/51/d1/226a806bbd69f62ce5ef5f3ffadc35286e9fbc802f606a07eb83bf2359de/scipy-1.15.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5", size = 30266407, upload-time = "2025-05-08T16:07:49.891Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/9b/f32d1d6093ab9eeabbd839b0f7619c62e46cc4b7b6dbf05b6e615bbd4400/scipy-1.15.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e", size = 22540030, upload-time = "2025-05-08T16:07:54.121Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/29/c278f699b095c1a884f29fda126340fcc201461ee8bfea5c8bdb1c7c958b/scipy-1.15.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb", size = 25218709, upload-time = "2025-05-08T16:07:58.506Z" },
+    { url = "https://files.pythonhosted.org/packages/24/18/9e5374b617aba742a990581373cd6b68a2945d65cc588482749ef2e64467/scipy-1.15.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723", size = 34809045, upload-time = "2025-05-08T16:08:03.929Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/fe/9c4361e7ba2927074360856db6135ef4904d505e9b3afbbcb073c4008328/scipy-1.15.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb", size = 36703062, upload-time = "2025-05-08T16:08:09.558Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8e/038ccfe29d272b30086b25a4960f757f97122cb2ec42e62b460d02fe98e9/scipy-1.15.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4", size = 36393132, upload-time = "2025-05-08T16:08:15.34Z" },
+    { url = "https://files.pythonhosted.org/packages/10/7e/5c12285452970be5bdbe8352c619250b97ebf7917d7a9a9e96b8a8140f17/scipy-1.15.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5", size = 38979503, upload-time = "2025-05-08T16:08:21.513Z" },
+    { url = "https://files.pythonhosted.org/packages/81/06/0a5e5349474e1cbc5757975b21bd4fad0e72ebf138c5592f191646154e06/scipy-1.15.3-cp313-cp313t-win_amd64.whl", hash = "sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca", size = 40308097, upload-time = "2025-05-08T16:08:27.627Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" },
+    { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" },
+    { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" },
+    { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" },
+    { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" },
+    { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" },
+    { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" },
+    { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" },
+    { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" },
+    { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" },
+    { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" },
+    { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.18.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.12.*'",
+    "python_full_version >= '3.13'",
+]
+dependencies = [
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/19/ca10ead60b0acc80b2b833c2c4a4f2ff753d0f58b811f70d911c7e94a25c/scipy-1.18.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:7bd21faaf5a1a3b2eff922d02db5f191b99a6518db9078a8fb23169f6d22259a", size = 31056519, upload-time = "2026-06-19T14:59:45.203Z" },
+    { url = "https://files.pythonhosted.org/packages/96/72/1e6442a00cd2924d361aa1b642ab6373ec35c6fabf311a760be9f76e0f13/scipy-1.18.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:265915e79107de9f946b855e50d7470d5893ec3f54b342e1aa6201cbdcd8bb6b", size = 28681889, upload-time = "2026-06-19T14:59:48.103Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/2d/11dd93d21e147a73ba22bd75c0b9208d3a2e0ec76d53170ce7d9029b1015/scipy-1.18.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9ab7b758be6940954a713ee466e2043e9f6e2ed965c1fce5c91039f4be3d90a9", size = 20423580, upload-time = "2026-06-19T14:59:50.665Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/01/93552f75e0d2a7dd115a45e59209c51e8d514daff02fc887d2623be06fe1/scipy-1.18.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:97b6cddaaee0a779ef6b5ca83c9604b27cc16b2b8fc22c142652df8793319fb8", size = 23054441, upload-time = "2026-06-19T14:59:53.564Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/23/21f5e703643d66f21faa6b4c73195bfcad70c55efcb4f1ab327cd7c4101a/scipy-1.18.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52a96e21517c7292375c0e27dd796a811f03fcea5fd4d108fdfea8145dcf17ab", size = 33968720, upload-time = "2026-06-19T14:59:56.415Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/aa/1b939f6c67ed68635bb538e6752d3dacc02f66535182e939a89581a44e9c/scipy-1.18.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f55797419e16e7f30cf88ffb3113ce0467f00cfe3f70d5c281730b21769bfc2", size = 35287115, upload-time = "2026-06-19T14:59:59.411Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ff/eec46be7e9234208f801062b53e1983085eddebd693f6c9bfb03b459830d/scipy-1.18.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ad033410e2e0672ffdc1042110cef20e1c46f8fd0616cee1d44d8d58fad8fc11", size = 35577989, upload-time = "2026-06-19T15:00:02.235Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ca/210d4759c7210bb7d269437421959b39a33434e2776b60c5cb8a763bb30a/scipy-1.18.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a55985d54c769c872e64b7f4c8a81cc30ef700cc04296abbbf3705439c126de", size = 37421717, upload-time = "2026-06-19T15:00:05.102Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/9a9edb45345bd6744da5ddfb6628e5d5185920494c6a67ec45b6381004cb/scipy-1.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:71ccc8faa2dd16ac310233203474a8b5cb67f10dedd54a3116d34943f4b19132", size = 36597428, upload-time = "2026-06-19T15:00:08.112Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0e/33f32a2a58987e26aec0f7df252cbbad1e90ae77bdbc76f40dd4ed0cf0ea/scipy-1.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:d88363fd9d8fbd3511bd273f1a49efb2a540773ddf92a91d57498ce7dd7f3e76", size = 24351481, upload-time = "2026-06-19T15:00:11.103Z" },
+    { url = "https://files.pythonhosted.org/packages/05/52/9c0136c2de7ae0779b7b366447766cec6d9f0702c56bb8ffeb04c8fd3af4/scipy-1.18.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:09143f676d157d9f546d663504ef9c1becb819824f1afc018814176411942446", size = 31036107, upload-time = "2026-06-19T15:00:14.03Z" },
+    { url = "https://files.pythonhosted.org/packages/02/73/0291a64843270f4efb86cdcf2ee0f2048631b65ec6b405398b2b4dbf11bf/scipy-1.18.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5efe260f69417b97ddae455bfb5a95e8359f7f66ad7fa9522a60feb66f169520", size = 28663303, upload-time = "2026-06-19T15:00:16.819Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/0f/10ffa0b697a572f4e0d48b92a88895d366422f019f723e7e14a84c050dac/scipy-1.18.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:68363b7eaacd8b5dd426df56d782cc156468ac79a127a1b87ca597d6e2e82197", size = 20404960, upload-time = "2026-06-19T15:00:19.635Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/d2/e896cea21ba8edd6c81d4c55b1ffcc717e79698dcbebf9641b4cfb4c6622/scipy-1.18.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:c5557d8be5da8e41353fcd4d21491fdbab83b062fc579e94dc09a7c8ab4f669b", size = 23034074, upload-time = "2026-06-19T15:00:22.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b2/e83ea34279a52c03374477c74006256ec78df65fc877baa4617d6de1d202/scipy-1.18.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d13bca67c096d89fb95ced0d8921807300fce0275643aef9533cc63a0773468", size = 33942038, upload-time = "2026-06-19T15:00:24.964Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/af/e8fe5fb136f51e2b01678b92cb4106d10d8cd68ec147ead2e7cb0ac75398/scipy-1.18.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a46f9273dbd0eb1cefba61c9b8648b4dfe3cbc14a080176f9a73e44b8336dc7f", size = 35266390, upload-time = "2026-06-19T15:00:28.059Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/49/2c5cbb907b56695fc67517811d1db234dfd83381a84814ec220aded2794d/scipy-1.18.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5aba46108853ddfc77906b6557aac839d2b52e900c1d72a1180adaaab58d265f", size = 35551324, upload-time = "2026-06-19T15:00:31.014Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/73/eda39f7a2d306ff0ffc574afd13c0bbb6d10a603d9a413998ee269487a80/scipy-1.18.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b6f758e35f12757b5d95c00bc6de2438e229c2664b7a92e96f205959d9f2dfa4", size = 37404785, upload-time = "2026-06-19T15:00:34.072Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/d2/ae881ee28d014f38e0ccbfd974a06a919ba9af34f1f74bf42b5301891d63/scipy-1.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:1afac4a847207c7ff8efd321734a50b06d0280b3b2a2c0fc2f413101747ad7c7", size = 36554943, upload-time = "2026-06-19T15:00:36.903Z" },
+    { url = "https://files.pythonhosted.org/packages/70/3a/21154e2d54eb3639c6bf4dbae2e531c68356bfe95990daa30df33b30d556/scipy-1.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:c5dbddf60e58c2312316d097271a8e73d40eaf2eabfa4d95ed7d3695bbf2ce7b", size = 24350911, upload-time = "2026-06-19T15:00:40.062Z" },
+]
+
+[[package]]
+name = "sentence-transformers"
+version = "5.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scikit-learn", version = "1.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scikit-learn", version = "1.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.11' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.11' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version >= '3.13' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version >= '3.13' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version >= '3.13' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version == '3.12.*' and extra != 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "scipy", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "torch" },
+    { name = "tqdm" },
+    { name = "transformers" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f9/56/d2cb00765a6b15c994a7fccf20f9032f16e8193ca49147cb5155166ad744/sentence_transformers-5.6.0.tar.gz", hash = "sha256:0e7164d051e416c1853ade7c274ff52af3f9da0f4be7f0b83d734c27699e1057", size = 453194, upload-time = "2026-06-16T14:01:56.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c1/dc1582b79e9a2eb0cddf9559cd9bcdff084f541d6fe881fdd9d98630dba7/sentence_transformers-5.6.0-py3-none-any.whl", hash = "sha256:d2075b5e687a1611005e20ab04a6846994d51adfcf39610aed066af3c0c0b81f", size = 596411, upload-time = "2026-06-16T14:01:55.103Z" },
+]
+
+[[package]]
+name = "sentry-sdk"
+version = "2.65.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/1f/ed17a390348156ca99fe622b97cd7d2f1969b5f49df89084b0f28e7953e9/sentry_sdk-2.65.0.tar.gz", hash = "sha256:c94dc945d54bad49d4f20448b1e6b217ca2f92f46d05c3e83d41764af685c3d1", size = 932133, upload-time = "2026-07-13T11:33:19.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/3b/326ad4c03b5da89b5124c8890af66e8119c4d2e10abc0619e0d67d9f7c7f/sentry_sdk-2.65.0-py3-none-any.whl", hash = "sha256:3595169677a808e4d0e1ea6ffb89443459549c7a98392ed71c77c847182ab6bf", size = 503869, upload-time = "2026-07-13T11:33:17.71Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "83.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sqlalchemy"
+version = "2.0.51"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/f1/a7a892f18d4d224e6b26f706531eafccc41e37594d37d304786969ee13cb/sqlalchemy-2.0.51.tar.gz", hash = "sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9", size = 9912201, upload-time = "2026-06-15T15:41:20.012Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/76/b3ea1d8842e7b62c718a88d302809003d65ed82011460ca48907dde658c4/sqlalchemy-2.0.51-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e8203d2fbd5c6254692ef0a72c740d75b2f3c7ca345404f4c1a4604813c77c0", size = 2162087, upload-time = "2026-06-15T16:05:15.795Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/22/f19552eb7876774d50cfd025337ef5d67acc10cd8f29adab7716cf47c352/sqlalchemy-2.0.51-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1af05726b3d0cdba1c55284bf408fd3b792e690fe2399bfb8304565551cda652", size = 3244579, upload-time = "2026-06-15T16:10:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/97/e4a2eb5a8ec5cd3c2a0615a2f15f0afca89ac039229599b9ed0c0ed28e5e/sqlalchemy-2.0.51-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e54ff2dd657f2e3e0fbf2b097db1182f7bfea263eca4353f00065bae2a67c3d", size = 3243515, upload-time = "2026-06-15T16:12:22.627Z" },
+    { url = "https://files.pythonhosted.org/packages/74/c6/5900ec624fab3360aa2ec59b99bb2046dd79799e310bb78a0514eaa4038e/sqlalchemy-2.0.51-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1e47b1199c2e832e325eacabc8d32d2487f58c9358f97e9a00f5eb93c5680d84", size = 3195492, upload-time = "2026-06-15T16:10:38.097Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/41/2ee3c4e1ac4fd22309349823fe13f33febeab1a71db1d7e9d60293a07dcb/sqlalchemy-2.0.51-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c68568f3facf8f66fa76c60e0ced69b67666ffa9941d1d0a3756fda196049080", size = 3215782, upload-time = "2026-06-15T16:12:24.051Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/1c/3bd72c341f1cb5faed5a7457ea840228a46be51cfbaf31a9db72fc963f11/sqlalchemy-2.0.51-cp310-cp310-win32.whl", hash = "sha256:0592bdadf86ddcabfd72d9ab66ea8a5d8d2cc6be1cc51fa7e66c03868ac5eac1", size = 2122119, upload-time = "2026-06-15T16:13:26.915Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/63/b6dfdd646abf91c3bedb13727226a5e765e5f8365e898d43818e6672fa46/sqlalchemy-2.0.51-cp310-cp310-win_amd64.whl", hash = "sha256:740cf6f35351b1ac3d82369152acf1d51d37e3dcf85d4dc0a22ca01410eabe2a", size = 2145158, upload-time = "2026-06-15T16:13:28.386Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/69/a67c69e5f28fc9c99d6f7bd60bd50e91f2fed2423e3b30fb228fa00e51f3/sqlalchemy-2.0.51-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1aa10c0daee6705294d181daadaa793221e1a59ed55000a3fab1d42b088ce4ba", size = 2161838, upload-time = "2026-06-15T16:05:17.144Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/c8c22b8438bddc0a030157c6ec0f6ef97b3c38effa444bdab2a27af04090/sqlalchemy-2.0.51-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5b2ed6d828f1f09bd812861f4f59ca3bc3803f9df871f4555187f0faf018604", size = 3319402, upload-time = "2026-06-15T16:10:40.002Z" },
+    { url = "https://files.pythonhosted.org/packages/90/54/44012d32fd77d991256d2ff793ba3807c51d40cb27a85b4796224f6744df/sqlalchemy-2.0.51-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:436728ce18a80f6951a1e11cc6112c2ede9faf20766f1a26195a7c441ca12dbd", size = 3319675, upload-time = "2026-06-15T16:12:25.658Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a5/de0592acaf5906cd7430874392d6f7e8b4a7c8437610953ee2d1501c0b44/sqlalchemy-2.0.51-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dc261707bf5739aea8a541593f3cc1d463c2701fb05fbcbba0ce031b69a21260", size = 3270777, upload-time = "2026-06-15T16:10:42.125Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/14/a44c90739c780b362238e4ac3cb19dd0ca40d13e6ddc5daa112166ddab4f/sqlalchemy-2.0.51-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a6d26094615306d116dd5e4a51b0304c99dd2356fc569eed6922a80a6bd3b265", size = 3293940, upload-time = "2026-06-15T16:12:27.156Z" },
+    { url = "https://files.pythonhosted.org/packages/65/eb/fbd0f206a330e66f8c602a99c37c4e731f107faed62954b41b01f16dd9d9/sqlalchemy-2.0.51-cp311-cp311-win32.whl", hash = "sha256:ca8435d13829b92f4a97362d91975154a4015db3a2634154e1754e9a915e6b86", size = 2121183, upload-time = "2026-06-15T16:13:29.905Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fd/005bf80f3cf6e5c62b5dd68616280f51cd012c60840fa74781b3ed7b1623/sqlalchemy-2.0.51-cp311-cp311-win_amd64.whl", hash = "sha256:4a011ea4510683319ce4ed274b56ee05194b39b6da9d09ca7a39388f0fa84dcc", size = 2145796, upload-time = "2026-06-15T16:13:31.283Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/70/e868bc5412acd101a8280f25c95f10eeae0771c4eb806b02491142810ee8/sqlalchemy-2.0.51-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d78702b26ba1c18b2d0fb2ea940ba7f17a9581b42e8361ff93920ebbee1235a", size = 2160291, upload-time = "2026-06-15T16:08:48.918Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/71ee0f8a6b9d7316a1ccd30430b4c62b6c2e36adc96017a4e3a72dce49d6/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581921d849d6e6f994d560389192955e80e2950e18fcdfe2ccea863e01158e6e", size = 3343835, upload-time = "2026-06-15T16:19:42.613Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/7c/7ab9f9aadc5944fdd06612484ed7918fe376ad871a5f50404dc1536e0194/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d21ce524ab86c23046e992a5b81cb54c21079c6df6e78b8fc77d77cac70a6b9", size = 3358470, upload-time = "2026-06-15T16:26:38.011Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7d/ff77169fee6186de145a7f2b87006c39638391130abbab2b1f63ac6ea583/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c5d98a2709840027f5a347c3af0a7c3d5f6c1ff93af2ca1c54494e23cba8f389", size = 3289874, upload-time = "2026-06-15T16:19:45.212Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/3b/6c505903710d781b55bc3141ee34a062bf9745a6b5bc7333305b9ed63b33/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1181256e0f16479691b5616d36375dc2620ad8332b25978763c3d206ad3f3f1d", size = 3321692, upload-time = "2026-06-15T16:26:39.747Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/b7/c5ffe50aa2f4d947c9250e1519d939260329a07fe6272edfccd784b3d007/sqlalchemy-2.0.51-cp312-cp312-win32.whl", hash = "sha256:9f380393be5abeb6815f68fd39271b95127173511b6706b0a630a9995d53f8f5", size = 2119674, upload-time = "2026-06-15T16:23:09.543Z" },
+    { url = "https://files.pythonhosted.org/packages/25/dc/46a65916af68a06ef6b972c6050ba4c8f97070fe3fb33097d34229d9bef6/sqlalchemy-2.0.51-cp312-cp312-win_amd64.whl", hash = "sha256:2cf39aabdf48e87c1c2c2ed6d20d33ffa0733b3071ce9c5f66357947dd009080", size = 2146670, upload-time = "2026-06-15T16:23:11.048Z" },
+    { url = "https://files.pythonhosted.org/packages/54/fe/a210d52fd1a90ecfae8a78e9d8b27e18d733d60818a8bf250ff690b75120/sqlalchemy-2.0.51-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c2056838b6685b72fdb36c99996cf862753461a62f2e84f4196371d3b2d6a07", size = 2157184, upload-time = "2026-06-15T16:08:50.374Z" },
+    { url = "https://files.pythonhosted.org/packages/17/6b/2dce8369b199cb855110e056032f94a9f66dacc2237d3d39c115a86eac56/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:483b11bd46bf35fc14c52faf338b04300c9e6ce554bce9b11be85bfec3bc3195", size = 3284735, upload-time = "2026-06-15T16:19:46.934Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ff/dbc495b8a14da840faffb353857a72d4190113cac33727906fb997047f0f/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1bed1ee8b01da6088210aa9412023326fb98a599ba502e6118308601dcbef77f", size = 3302756, upload-time = "2026-06-15T16:26:41.336Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/fde8f4dddcf518ee15ab35a7c6a28acc32c8ba548d1d2aa451f96e6dbb0b/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:72ca54c952107ba5cd58854b67a5a6268631289d21651a1235396f3b98b47400", size = 3232055, upload-time = "2026-06-15T16:19:49.286Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d1/43d3a0ac955a58601c24fa23038b1c55ee3a1ec02c0f96ebb1eae2bcf614/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b3e693d15533a45cd5906f0589f9c35090bef6ef45bf1e8195c424aa0ae06a8d", size = 3269850, upload-time = "2026-06-15T16:26:43.017Z" },
+    { url = "https://files.pythonhosted.org/packages/94/df/de669c7054cd47c4439ac34b1b2ee8b804a794791fbb10720e997a2c87c7/sqlalchemy-2.0.51-cp313-cp313-win32.whl", hash = "sha256:b93ab07b5292dbe7e6b8da89475275e7042744283921344b56105f3eeb0f828b", size = 2117721, upload-time = "2026-06-15T16:23:12.36Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/8a/403c51d064196bae20a0bc2476577f83a3f8dd299719a97417086b7f2ec5/sqlalchemy-2.0.51-cp313-cp313-win_amd64.whl", hash = "sha256:0f053118c30e53161857a953e4de667d90e274980dccbe5dd3829bbbeece72a5", size = 2143615, upload-time = "2026-06-15T16:23:13.906Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/22/dbf013a12ec759e54a34a119e9e217435b3f71b2dd5c61a7ade0a25dae87/sqlalchemy-2.0.51-py3-none-any.whl", hash = "sha256:bb024d8b621d0be75f4f44ecc7c950450026e76d66dc8f791bb5331d7fed59d5", size = 1944334, upload-time = "2026-06-15T16:09:22.418Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
+]
+
+[[package]]
+name = "tokenizers"
+version = "0.22.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
+    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
+    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
+    { url = "https://files.pythonhosted.org/packages/84/04/655b79dbcc9b3ac5f1479f18e931a344af67e5b7d3b251d2dcdcd7558592/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4", size = 3282301, upload-time = "2026-01-05T10:40:34.858Z" },
+    { url = "https://files.pythonhosted.org/packages/46/cd/e4851401f3d8f6f45d8480262ab6a5c8cb9c4302a790a35aa14eeed6d2fd/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c", size = 3161308, upload-time = "2026-01-05T10:40:40.737Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/6e/55553992a89982cd12d4a66dddb5e02126c58677ea3931efcbe601d419db/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195", size = 3718964, upload-time = "2026-01-05T10:40:46.56Z" },
+    { url = "https://files.pythonhosted.org/packages/59/8c/b1c87148aa15e099243ec9f0cf9d0e970cc2234c3257d558c25a2c5304e6/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5", size = 3373542, upload-time = "2026-01-05T10:40:52.803Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
+    { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
+    { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "jinja2" },
+    { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cudnn-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cufft-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cufile-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-curand-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cusolver-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-cusparselt-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-nccl-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "nvidia-nvtx-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "setuptools", marker = "python_full_version >= '3.12' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "sympy" },
+    { name = "triton", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (platform_machine != 'x86_64' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (platform_machine != 'x86_64' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (sys_platform != 'linux' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (sys_platform != 'linux' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "typing-extensions" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/27/2e06cb52adf89fe6e020963529d17ed51532fc73c1e6d1b18420ef03338c/torch-2.7.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f", size = 99089441, upload-time = "2025-06-04T17:38:48.268Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/7c/0a5b3aee977596459ec45be2220370fde8e017f651fecc40522fd478cb1e/torch-2.7.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d", size = 821154516, upload-time = "2025-06-04T17:36:28.556Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/91/3d709cfc5e15995fb3fe7a6b564ce42280d3a55676dad672205e94f34ac9/torch-2.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162", size = 216093147, upload-time = "2025-06-04T17:39:38.132Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f6/5da3918414e07da9866ecb9330fe6ffdebe15cb9a4c5ada7d4b6e0a6654d/torch-2.7.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c", size = 68630914, upload-time = "2025-06-04T17:39:31.162Z" },
+    { url = "https://files.pythonhosted.org/packages/11/56/2eae3494e3d375533034a8e8cf0ba163363e996d85f0629441fa9d9843fe/torch-2.7.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2", size = 99093039, upload-time = "2025-06-04T17:39:06.963Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/94/34b80bd172d0072c9979708ccd279c2da2f55c3ef318eceec276ab9544a4/torch-2.7.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1", size = 821174704, upload-time = "2025-06-04T17:37:03.799Z" },
+    { url = "https://files.pythonhosted.org/packages/50/9e/acf04ff375b0b49a45511c55d188bcea5c942da2aaf293096676110086d1/torch-2.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52", size = 216095937, upload-time = "2025-06-04T17:39:24.83Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/2b/d36d57c66ff031f93b4fa432e86802f84991477e522adcdffd314454326b/torch-2.7.1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730", size = 68640034, upload-time = "2025-06-04T17:39:17.989Z" },
+    { url = "https://files.pythonhosted.org/packages/87/93/fb505a5022a2e908d81fe9a5e0aa84c86c0d5f408173be71c6018836f34e/torch-2.7.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa", size = 98948276, upload-time = "2025-06-04T17:39:12.852Z" },
+    { url = "https://files.pythonhosted.org/packages/56/7e/67c3fe2b8c33f40af06326a3d6ae7776b3e3a01daa8f71d125d78594d874/torch-2.7.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc", size = 821025792, upload-time = "2025-06-04T17:34:58.747Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/37/a37495502bc7a23bf34f89584fa5a78e25bae7b8da513bc1b8f97afb7009/torch-2.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b", size = 216050349, upload-time = "2025-06-04T17:38:59.709Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/60/04b77281c730bb13460628e518c52721257814ac6c298acd25757f6a175c/torch-2.7.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb", size = 68645146, upload-time = "2025-06-04T17:38:52.97Z" },
+    { url = "https://files.pythonhosted.org/packages/66/81/e48c9edb655ee8eb8c2a6026abdb6f8d2146abd1f150979ede807bb75dcb/torch-2.7.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:03563603d931e70722dce0e11999d53aa80a375a3d78e6b39b9f6805ea0a8d28", size = 98946649, upload-time = "2025-06-04T17:38:43.031Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/24/efe2f520d75274fc06b695c616415a1e8a1021d87a13c68ff9dce733d088/torch-2.7.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:d632f5417b6980f61404a125b999ca6ebd0b8b4bbdbb5fbbba44374ab619a412", size = 821033192, upload-time = "2025-06-04T17:38:09.146Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d9/9c24d230333ff4e9b6807274f6f8d52a864210b52ec794c5def7925f4495/torch-2.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:23660443e13995ee93e3d844786701ea4ca69f337027b05182f5ba053ce43b38", size = 216055668, upload-time = "2025-06-04T17:38:36.253Z" },
+    { url = "https://files.pythonhosted.org/packages/95/bf/e086ee36ddcef9299f6e708d3b6c8487c1651787bb9ee2939eb2a7f74911/torch-2.7.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:0da4f4dba9f65d0d203794e619fe7ca3247a55ffdcbd17ae8fb83c8b2dc9b585", size = 68925988, upload-time = "2025-06-04T17:38:29.273Z" },
+    { url = "https://files.pythonhosted.org/packages/69/6a/67090dcfe1cf9048448b31555af6efb149f7afa0a310a366adbdada32105/torch-2.7.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:e08d7e6f21a617fe38eeb46dd2213ded43f27c072e9165dc27300c9ef9570934", size = 99028857, upload-time = "2025-06-04T17:37:50.956Z" },
+    { url = "https://files.pythonhosted.org/packages/90/1c/48b988870823d1cc381f15ec4e70ed3d65e043f43f919329b0045ae83529/torch-2.7.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:30207f672328a42df4f2174b8f426f354b2baa0b7cca3a0adb3d6ab5daf00dc8", size = 821098066, upload-time = "2025-06-04T17:37:33.939Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/eb/10050d61c9d5140c5dc04a89ed3257ef1a6b93e49dd91b95363d757071e0/torch-2.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:79042feca1c634aaf6603fe6feea8c6b30dfa140a6bbc0b973e2260c7e79a22e", size = 216336310, upload-time = "2025-06-04T17:36:09.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/29/beb45cdf5c4fc3ebe282bf5eafc8dfd925ead7299b3c97491900fe5ed844/torch-2.7.1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:988b0cbc4333618a1056d2ebad9eb10089637b659eb645434d0809d8d937b946", size = 68645708, upload-time = "2025-06-04T17:34:39.852Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.68.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/5f/57ff8b434839e70dab45601284ea413e947a63799891b7553e5960a793a8/tqdm-4.68.4.tar.gz", hash = "sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520", size = 792418, upload-time = "2026-07-07T09:58:18.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl", hash = "sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2", size = 676612, upload-time = "2026-07-07T09:58:16.256Z" },
+]
+
+[[package]]
+name = "transformers"
+version = "4.57.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "huggingface-hub" },
+    { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13' or (python_full_version == '3.12.*' and extra == 'extra-18-mobiletransformers-export') or (python_full_version == '3.12.*' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version == '3.12.*' and extra != 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (python_full_version < '3.12' and extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (python_full_version < '3.12' and extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "regex" },
+    { name = "requests" },
+    { name = "safetensors" },
+    { name = "tokenizers" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", hash = "sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3", size = 10134912, upload-time = "2026-01-16T10:38:39.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", hash = "sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550", size = 11993498, upload-time = "2026-01-16T10:38:31.289Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "setuptools" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/a9/549e51e9b1b2c9b854fd761a1d23df0ba2fbc60bd0c13b489ffa518cfcb7/triton-3.3.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e", size = 155600257, upload-time = "2025-05-29T23:39:36.085Z" },
+    { url = "https://files.pythonhosted.org/packages/21/2f/3e56ea7b58f80ff68899b1dbe810ff257c9d177d288c6b0f55bf2fe4eb50/triton-3.3.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b", size = 155689937, upload-time = "2025-05-29T23:39:44.182Z" },
+    { url = "https://files.pythonhosted.org/packages/24/5f/950fb373bf9c01ad4eb5a8cd5eaf32cdf9e238c02f9293557a2129b9c4ac/triton-3.3.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43", size = 155669138, upload-time = "2025-05-29T23:39:51.771Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1f/dfb531f90a2d367d914adfee771babbd3f1a5b26c3f5fbc458dee21daa78/triton-3.3.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b89d846b5a4198317fec27a5d3a609ea96b6d557ff44b56c23176546023c4240", size = 155673035, upload-time = "2025-05-29T23:40:02.468Z" },
+    { url = "https://files.pythonhosted.org/packages/28/71/bd20ffcb7a64c753dc2463489a61bf69d531f308e390ad06390268c4ea04/triton-3.3.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3198adb9d78b77818a5388bff89fa72ff36f9da0bc689db2f0a651a67ce6a42", size = 155735832, upload-time = "2025-05-29T23:40:10.522Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.26.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-genai-smoke') or (extra == 'extra-18-mobiletransformers-export' and extra == 'group-18-mobiletransformers-ort-training-local') or (extra == 'group-18-mobiletransformers-genai-smoke' and extra == 'group-18-mobiletransformers-ort-training-local')" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/f7/68adc395201b20b872d68e975386832e8005ffeacedd43a1d837a32815be/typer-0.26.8.tar.gz", hash = "sha256:c244a6bd558886fe3f8780efb6bdd28bb9aff005a94eedebaa5cb32926fe2f7e", size = 202097, upload-time = "2026-06-26T09:22:45.705Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/87/b9fd69c92c6102a066e1b86a35243f53e70bd4c709f2a26d9f4fee4f4dc0/typer-0.26.8-py3-none-any.whl", hash = "sha256:3512ca79ac5c11113414b36e80281b872884477722440691c89d1112e321a49c", size = 122564, upload-time = "2026-06-26T09:22:44.72Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "uuid-utils"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/91/63938e0e7e7876658e5e40178e7c0735b53527886fe11797a11699c55edd/uuid_utils-0.17.0.tar.gz", hash = "sha256:abb5667a36119019b3fa320c4d10c21ebccfcc87c8a739e6a0056cee7f48dde2", size = 43220, upload-time = "2026-07-09T13:49:58.433Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/60/659104207938f2ac62508b9aa595fc0515ac7452dd515c8e1d47d0b91169/uuid_utils-0.17.0-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:d2d9a63a9e6f2416ace8c109043a9280d6b34f34bb2e5421903e149403db40a6", size = 564038, upload-time = "2026-07-09T13:47:51.731Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e7/e0d048a268b4163058bdd2f07a45bbe13c29e3cc6b7b88f8f00b001617ce/uuid_utils-0.17.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b776c7fc8755c7de06dd5a22b47c40ae84f67d13277ebb233cc84933ba4dcbcd", size = 286680, upload-time = "2026-07-09T13:47:53.141Z" },
+    { url = "https://files.pythonhosted.org/packages/84/83/e3606dc9b4224d0c9a6675d9347e7e0da7e67fa30e061bfdb686138844d0/uuid_utils-0.17.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1edf2f8732e4ed95bd7b65f2658f4aa072efaaff321144f4e0d4bf6a22709263", size = 323533, upload-time = "2026-07-09T13:47:54.433Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f8/aec5c34fa80c9fef09a506a098015e728080076494b72b9e8e5cfc9669c4/uuid_utils-0.17.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:84ed3a2d5cd3ae6db87af20bfed3331116195ba4757ad7177fc8f12c1bbce2a9", size = 330691, upload-time = "2026-07-09T13:47:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/08/73/85776566863514f37b0a761648368e96b07d64981a9b6c391220aa2563a9/uuid_utils-0.17.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bf4d9cd1e80e73922073b9b27c143bedeb109d65f94cd12712e2c87118f2b7d", size = 444094, upload-time = "2026-07-09T13:47:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/68/06/e0424b4268c0932e0ff8257303d70de4053f05958843268fac4cb0f79b57/uuid_utils-0.17.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52db0e471d3d2632d35445af352591f40a8f32959a412981d9f51e068bb9514b", size = 324548, upload-time = "2026-07-09T13:47:58.217Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d2/a0cb3a69ef6d9becc30a6a0594ddf6f798f6204953dfa85073cbec875b94/uuid_utils-0.17.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:344f7c755e280ea0ba6aeb08022190d867a80000b1715cacded54fc4b5633607", size = 350307, upload-time = "2026-07-09T13:47:59.418Z" },
+    { url = "https://files.pythonhosted.org/packages/82/81/d82766af7db541e4a78b920bc1c4303d44995f841805d1498934088cd12c/uuid_utils-0.17.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:589d9da7de8fa7f739bb970ac4632c9a268213117d634e1c4a58c1c1e821ca05", size = 500661, upload-time = "2026-07-09T13:48:00.726Z" },
+    { url = "https://files.pythonhosted.org/packages/10/71/b261cd0d38497ed8c2cce0263c5607ec9cd2bbace0f73cb19a6fc2060b6e/uuid_utils-0.17.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cee808b405e9095506f4e4e89924bec7ea77eac3129b6fe36eda04364b3b343b", size = 606577, upload-time = "2026-07-09T13:48:02.539Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/63/9e48512bb235e9533adbb25c30fd0c9cef09f6ecefe131ba392b98572b40/uuid_utils-0.17.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:53ce348ef4c6e98c02c19c522af01334fe94476ce9af0db8c4482f9f142ae9c1", size = 567054, upload-time = "2026-07-09T13:48:03.833Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cc/d7bad8799a37ec33fc21b29fcb459d63d9f88aa09056d0c3e58903ba2fb0/uuid_utils-0.17.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9e753e81457241e2200c56a898e268e8fa25796271af0489c608f24d8e631eed", size = 529682, upload-time = "2026-07-09T13:48:05.097Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3b/59b1e07ada8aadd3c046c97fe9814d85e770abb7e8cf68d5d86538bf62e9/uuid_utils-0.17.0-cp310-cp310-win32.whl", hash = "sha256:c589f5023d471ce75dd2cce61acb25ed6347e562041588a1a366808f22d7176c", size = 170595, upload-time = "2026-07-09T13:48:06.411Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/5c/23a2d0253ada2ee8c497d541d4ef0dd5576c3d2454ec2f9d0b8a06af9304/uuid_utils-0.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:981cc10163988defea96e8d6c507df151eab8f483e7df9ae543d5a41a4be073b", size = 177225, upload-time = "2026-07-09T13:48:07.561Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/b2/8f03b61f0aa4afc687855c4f00db35f4d3e58c480cd885abc46f6e41308f/uuid_utils-0.17.0-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:f9b093cb3b6c9d6233ef45a05cab064d2aa0a8cb3c5777084c9e20fcb77c2371", size = 563901, upload-time = "2026-07-09T13:48:08.961Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/cb/88b909ffb9ac11f88d2e6ceabc592ccc660b5830b06dbcbd290ab8981f1f/uuid_utils-0.17.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0bc4c431ccd59c764080ceb43b126043325fe17861b87759d026a0cdd8423bb2", size = 286383, upload-time = "2026-07-09T13:48:10.2Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b8/bc5b64e9898867227c535cd0366c571c580a736748e81329437c1773e442/uuid_utils-0.17.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c00d182e31034250690f417b9068b78eab423c10d76766664e82d9860c340479", size = 323244, upload-time = "2026-07-09T13:48:11.477Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d9/8a17462ce066fbf89670fb737a3f0c93a77816736d2a4d134787e759d8ea/uuid_utils-0.17.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:570db214f6d8507587a8faa968a3fe65e957daeb7bc48b27dc7f69bc3ecdd6f1", size = 330466, upload-time = "2026-07-09T13:48:13.092Z" },
+    { url = "https://files.pythonhosted.org/packages/43/37/0c65d0db3bae45183419756d938f1791a82c835fd92bf234eb4f008d2e02/uuid_utils-0.17.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:351462debd866f1f25e4d4f5c7fac89525b52151f0102a1bdfe94a999b046f5f", size = 443806, upload-time = "2026-07-09T13:48:14.372Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d5/7e698466d1f5254620b5ee0d711fdd20a0e9c2acd7040740c37193a8f673/uuid_utils-0.17.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:622cdde768300591ac79bfcd7bb3468e4b191b1105d5dbfe8d87c39d8f63dd46", size = 324261, upload-time = "2026-07-09T13:48:15.642Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/48/3a5b242d7f0b8e3ca77dcd7177f3cf73e0280cee32e2349d9796ca27f183/uuid_utils-0.17.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:75d7411e8eb9259764dd60310738540649057cda4509b4af14b36b7f663bfeb0", size = 350657, upload-time = "2026-07-09T13:48:17.273Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/f32ea82a89efed2eafee2f1d925d64687a81e550a9951933fb1b75c95ca6/uuid_utils-0.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1019476b6bdc047216ef7414be5babe0fa5ccfde977c0cac4fd6c75ddec66ff7", size = 500613, upload-time = "2026-07-09T13:48:18.459Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/5c/c7b73ec4bbe28db162a4841d352c6eda582801e0dd9fe72f6ad5cc584ee4/uuid_utils-0.17.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:04452640d8b6920c480c16e5afe91ff896d236e0c972830f9247e0898d38c803", size = 606306, upload-time = "2026-07-09T13:48:19.726Z" },
+    { url = "https://files.pythonhosted.org/packages/63/95/8a2777204e8691b4961e6aa619001c3e5175aa430ab43da3079142e8d310/uuid_utils-0.17.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:793229621e1ad6cac55f015cfa9f4eff102accbc3da25d607b91c6b0bec167fb", size = 567231, upload-time = "2026-07-09T13:48:21.024Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/6f/1d778ca3ed6d2cf35f22088e2de714675416747ab41be510f22c141043a7/uuid_utils-0.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03815cea572c8a693cab5475b9d750cc161470961c7defa27e9286cad62f38f5", size = 529373, upload-time = "2026-07-09T13:48:22.312Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d3/9ad1ab64b3bed0a0237d1db89dc6f5001d6116a82766753da4ac4496f979/uuid_utils-0.17.0-cp311-cp311-win32.whl", hash = "sha256:c4f845166b09acc65c5213a35551a7f81c17fa010ab467229b5813f79d17fe13", size = 169930, upload-time = "2026-07-09T13:48:23.504Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1a/e01417f52eae6e2cb412260bb332b4ee4b37af2982d9c38cff4b68b2e899/uuid_utils-0.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:14dc2f46abb1091260c0d203fcbdf4e045042cc07e49183fd3b255904b95eb70", size = 177242, upload-time = "2026-07-09T13:48:24.723Z" },
+    { url = "https://files.pythonhosted.org/packages/35/20/396c27f996add19f8ac31e49cc4570824e51a97719087dabf94694d25bc4/uuid_utils-0.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:29179ffb7b317239b6d6afb100d14c439c728770460718280b9c0a42d2561ec2", size = 177023, upload-time = "2026-07-09T13:48:25.834Z" },
+    { url = "https://files.pythonhosted.org/packages/20/80/a7e685968e3cec99d6fe2fb25d0f5726310e1bba356da68c13dfd8b7d140/uuid_utils-0.17.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9205068badf453d2f0821fd5d340389b4679992d7ff79d4f3e5608996dd1b287", size = 556403, upload-time = "2026-07-09T13:48:27.022Z" },
+    { url = "https://files.pythonhosted.org/packages/56/47/3102d93bcb7b0bfe6bede63ff8f221a7f91348e10a37f682773be27c56d9/uuid_utils-0.17.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0fcca4e838af9ac9243b3358d7c14afa4dca286a87781124c272d6c4cad9c968", size = 285608, upload-time = "2026-07-09T13:48:28.769Z" },
+    { url = "https://files.pythonhosted.org/packages/55/fb/d59695f0f8db065b93c63316eaafa05a22d75a0486978a33736c52c646d5/uuid_utils-0.17.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f3729e839209f3457d0d8b6a35a376fdf65577a5aecaf4cc3587d3305759ba6", size = 319926, upload-time = "2026-07-09T13:48:29.965Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/03/62fabcd1e990e07a0e220e8d552af45bc16f107fa8e55c2014a706bb1a1e/uuid_utils-0.17.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3dac0ad0cd9a2818d1775215365a4e8c2f8ada215529dd26f3f8cceeb67a6988", size = 327172, upload-time = "2026-07-09T13:48:31.187Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/37/a5081391338b459e2f8d8b12581f00f8caa6317fab510e0e85c18c59e938/uuid_utils-0.17.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e671b2322ef09106ecb1ca0f4c398b134d5e2c1f80d7a4f3336847a3072c0e94", size = 439075, upload-time = "2026-07-09T13:48:32.295Z" },
+    { url = "https://files.pythonhosted.org/packages/59/30/91795bd01e17a13661280d4899fbf38fb05e3f38e873f9aaec106ec30aa0/uuid_utils-0.17.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8eb3e5caca8d3a6f72ea4cce024583f989f6f2e9186f98800213fff0176e8bcc", size = 320247, upload-time = "2026-07-09T13:48:33.64Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/11/09102b78303e4eb62069d6d88ef9fd661dc523e8f429e1fd67eaa78a6f44/uuid_utils-0.17.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8b72c2002202038666bf647f9a790906214c7c11cd0d6efef77b7d07bef3034a", size = 344738, upload-time = "2026-07-09T13:48:34.786Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f9/be95bad6954b60328878c3800258f01a6accd24fd75112d13f023462d53f/uuid_utils-0.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e2ac1c0b56f2c91b6f158e29ed96b1503223fe8aa6e79b1be1dc55bd8a5131c", size = 496845, upload-time = "2026-07-09T13:48:36.057Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/02/8a19a34e0530d987488a068a71576a236f5c8c746630b870b57f71eb24ef/uuid_utils-0.17.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6c142bd0cb4dba31c10babe00d59f7ef6460f0ef55eaa9c1a9da270684af996a", size = 603233, upload-time = "2026-07-09T13:48:37.512Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a8/b1abab36ff73b0248d82179816467f6d39a2e80fd64329a895ca94f3508e/uuid_utils-0.17.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e252db239eb41c32248e096e0d170bce5896a4fd3405556362bc3dd83d912206", size = 561401, upload-time = "2026-07-09T13:48:38.977Z" },
+    { url = "https://files.pythonhosted.org/packages/61/91/70e7b528b351cc03a9ca43e6116371cdde31bb12bcead7ca2ca1367366cc/uuid_utils-0.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:237722b6581bb5b4eb4cefbcbe5c6e2980a440aabe781fbe50ebf1cb71eee4cc", size = 525314, upload-time = "2026-07-09T13:48:40.599Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/9167e90cf9937d6558f92d022ff3024a69d938a514d9c8faa4080f73b001/uuid_utils-0.17.0-cp312-cp312-win32.whl", hash = "sha256:46a73cacdf512f473a81f65dbf84186e08cfe6e9118fa582b6c6b33a8288a30d", size = 166831, upload-time = "2026-07-09T13:48:41.862Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/7d/0b889654d9ee3413f810cf4685e241285f650d98a4103ac9f3c6bcc95f29/uuid_utils-0.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:e59b60a0a4cb7541480e02090d37dc2df3b72df4c2e776fff64ce3a4e3dd4637", size = 172944, upload-time = "2026-07-09T13:48:42.992Z" },
+    { url = "https://files.pythonhosted.org/packages/be/35/8c6e1bf65e4d400352885dadc656ad6d0af96e89231e3f04686bc2197128/uuid_utils-0.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:d561a4c5747a1e6c7fa7c49a0292e78b4e8c456332caa084fc7abad8de828652", size = 172459, upload-time = "2026-07-09T13:48:44.271Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/dd/614fb9912157ac0128e6050859ccf06d9f13df9a944a803e8f80f6157e38/uuid_utils-0.17.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:d11a7bc1e02da8984d32e6de9e0826c6edac00eac17de270f372bf32f9a0af63", size = 557259, upload-time = "2026-07-09T13:48:45.664Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/11/d072711704de3d21bec08b6c2f36a215200ca1d5e01a390ea1ac434080a0/uuid_utils-0.17.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7a49f47ac26df3e431c56b825c1bae8e6d3d591fdbb7438c227cc9845a7e3d73", size = 286271, upload-time = "2026-07-09T13:48:47.018Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6d/8a63e5eb2d5a6ba69a6c2036e305075bd6f5a022e7ea25fc6ce0eb7c51d2/uuid_utils-0.17.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32df1944808877702ceea398c103881c09a679bb672a215e01c2a84231266bf9", size = 320025, upload-time = "2026-07-09T13:48:48.208Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/2d/bdc2caf9719d9090d7c46043242ae6136cba4f7a7ee384992ab905ad9aa1/uuid_utils-0.17.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:98c88d3edd08e7245562e9815996dbc6f0bd4745e1c76462f24af5ae4e187dd1", size = 327931, upload-time = "2026-07-09T13:48:49.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/33/9219d09d51ead282b578b2a4e0a515c2cce3ec52076cada8bfb7e35727d5/uuid_utils-0.17.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a4370089c8b2e42f1db51d76408c7fa8eaa2934bf854d17983d16179c07c098", size = 438537, upload-time = "2026-07-09T13:48:50.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/79/e8e0f8b3955f2081c116157119d87659937893242eb834aa170da04d660b/uuid_utils-0.17.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:09a55b7a5ae764985cb46467496a1787678d0a1400356157a080ad95b1a36869", size = 320656, upload-time = "2026-07-09T13:48:52.164Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5e/d1ceddc430ff04b6e21704b2030d4438074a2f478b265dab43da957791c1/uuid_utils-0.17.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:56aa6488b931246fae11924e4bd0e2b32677e63945eecb71c29e3c2ca0dc3131", size = 345310, upload-time = "2026-07-09T13:48:54.076Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/62/89438e12f389a843e626b7e37691319a057b3d6b80914609106891faadda/uuid_utils-0.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:309a35f12d99dde19032bc2259cda6431c85eeac0879134dc777cc3087d7e1cb", size = 496771, upload-time = "2026-07-09T13:48:55.365Z" },
+    { url = "https://files.pythonhosted.org/packages/87/d2/eedcd99f522d60e238ead03844f0d51743ba84d33044959e230b756bf212/uuid_utils-0.17.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:21c79b61ff750abcf057163dd764ccb6196cde7a26cda1b31b45cd97769e03b3", size = 603631, upload-time = "2026-07-09T13:48:56.746Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/a8/bb1b38aaddd7243b6e562c6694f499bf094800918316192fd8cb2cdc2620/uuid_utils-0.17.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4134353bfe3026ddab8e886002dc52bc5a0ab04611aabb0eaae23c32e6e57f64", size = 562008, upload-time = "2026-07-09T13:48:58.241Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/77/5f7ed930dc105e293845c09e4d5bd84076318a12f45a46783e1af64906d7/uuid_utils-0.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7c89359affecebe2e39e6a116d069b363c936511a9572b308402489a26957d89", size = 525527, upload-time = "2026-07-09T13:48:59.784Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/25/1b55697adf6811a6f92cff6340e6b03e31fd6bc51066a5c10698c29b3679/uuid_utils-0.17.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:6a019a31bc4db89a0903a3e4f6b218571f3a6ff0ad4b3d3fe1c8f91a05ff6e3e", size = 97965, upload-time = "2026-07-09T13:49:01.217Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bf/cd729343de4684230be8a966bad7bfc2cf10ce3e643b1189a8b5370dbe35/uuid_utils-0.17.0-cp313-cp313-win32.whl", hash = "sha256:b3131a82d0c7611f0aa480a6d36929e001a3f54ba0fc029a8118a5863cce513c", size = 167316, upload-time = "2026-07-09T13:49:02.354Z" },
+    { url = "https://files.pythonhosted.org/packages/76/f0/e602ae0a1b139a7826e5189b93d91902564def06d5006324fd2faf82c8fc/uuid_utils-0.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:9e311f908d2f842fca4c7dcebc4f10306b8089b204ef04cf6704b4332c9ff6ff", size = 173630, upload-time = "2026-07-09T13:49:03.529Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/52/024ebece265b387154115dc4f1d9727174ef82623069f4bec8b7ed7e73f7/uuid_utils-0.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:c351737e2e65497c7200ab4ffb8af97e9f48be6488309abdd265fe08d66ee92f", size = 173214, upload-time = "2026-07-09T13:49:04.836Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/14/4ae708968b15cac7b68d5b854bfce724b21faa1c7a5147fb96d87f468a45/uuid_utils-0.17.0-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7b9044ce4acbf392d4b3a503fe377641f4deff82e6c341c36ef27af0dea76cdf", size = 567823, upload-time = "2026-07-09T13:49:46.902Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/e2/d3af9c3d1dc6efb9ee1cffab30f3f2aacacc3892b21b495d78d34c6696bc/uuid_utils-0.17.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:9a91c4814c7150a4d798da691b7804eacd78c4b84fb392a60fa0de21341861eb", size = 288763, upload-time = "2026-07-09T13:49:48.491Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/c2/f1b183e412387529893015a94a8447633c665f6d0392de20e245680e636a/uuid_utils-0.17.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2dd4a21baaac9a88486f0dd166c5793feb101a0bb9f006f2c401657fff5a1343", size = 324919, upload-time = "2026-07-09T13:49:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3c/d32c799bdd51f3b08b6ee95f9de921b59c69075a96767f937fab55014813/uuid_utils-0.17.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32abaafc8e91928b3d9f4d82e42d2094041e38ad6bb964066faadff28e4162f1", size = 332689, upload-time = "2026-07-09T13:49:51.402Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/90/b4cd455619ff276dc3c3262a7420ead63aa1e531362f00df4cdb07d90e0a/uuid_utils-0.17.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd741c73440b328f937dc53b344ecadc46bc4f0cec0333a8f42b55f3468ce7ec", size = 445726, upload-time = "2026-07-09T13:49:52.757Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/f1/5cc042a37932aa9a66eb8ab4a9a5b31d80261ae4565ff0193d8cc1fb9392/uuid_utils-0.17.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89a0980d49683c00539c59cd9f46b1908c538e6b5b0a48ad12187bb856d0f391", size = 325610, upload-time = "2026-07-09T13:49:54.191Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/72/9e800c41d766484484e97845a7a7f677ba94462df86c97183e0290229d16/uuid_utils-0.17.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:de1064663aa7c839286488a319d2b3b478ca5ab5b2091ade888ed0eeca11a98a", size = 352672, upload-time = "2026-07-09T13:49:55.748Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8e/86ce2c03a1d9674530f6649e49067f7c69929600127077731de590d12132/uuid_utils-0.17.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2db386941cfdecdd0b5a8ceeed5cf7479c83d1730dcf64a48d43cfa018cc3310", size = 178681, upload-time = "2026-07-09T13:49:57.096Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390, upload-time = "2024-11-01T14:06:24.793Z" },
+    { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389, upload-time = "2024-11-01T14:06:27.112Z" },
+    { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020, upload-time = "2024-11-01T14:06:29.876Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" },
+    { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" },
+    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" },
+    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902, upload-time = "2024-11-01T14:06:53.119Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380, upload-time = "2024-11-01T14:06:55.19Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/74/c6428f875774288bec1396f5bfcbc2d925700a4dad61727fd5f2b12f249d/wcwidth-0.8.2.tar.gz", hash = "sha256:91fbef97204b96a3d4d421609b80340b760cf33e26da123ff243d76b1fda8dda", size = 1466253, upload-time = "2026-06-29T18:11:11.601Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/42/3e5985a0a7e57de470b320c6d6a1a67c844f6737a587f3d44dd13d1819e7/wcwidth-0.8.2-py3-none-any.whl", hash = "sha256:d63947694a0539a1d51e01eda7caf800c291020e6cdd7e28ad7b14dd33ad4f85", size = 323166, upload-time = "2026-06-29T18:11:09.888Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/02/b9a097e1e16fee4e2fd1ec8c39f6a9c5d6257bae8fa12640caf869f54436/websockets-16.1.tar.gz", hash = "sha256:299468cbe42e2b9981134c7c51d99387d8a7bf562b00183b3eec53f882846dad", size = 182530, upload-time = "2026-07-10T06:32:57.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/31/cd11d2796b95c93645bac8e396b0f4bac0896a07a7b87d473bfc359f02c3/websockets-16.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:de72a9c611178b15557d98eabd3101c9663c4d68938510478a6d162f99afd213", size = 179772, upload-time = "2026-07-10T06:30:22.983Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9b/34306d802f9b599eab041688a2086318037560cfae616a860234cca575b6/websockets-16.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:37b0e4d726ffea3776670092d3d13e1cb605076f036a695fd1259de0d9b9fe02", size = 177457, upload-time = "2026-07-10T06:30:24.636Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/36ebbb978a7af70ff952afe5b22561264967164e9ad68b6734cae94efeb4/websockets-16.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:00d50c0a27098fcb7ab47b3d99a1b1159b534dbcd959fbf05113ebc37e5f927b", size = 177737, upload-time = "2026-07-10T06:30:25.954Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d7/944f341d0d3c0450ffd3d171479531df1818cb1df1623af4065113999c44/websockets-16.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1acb698bff1da1782b31aebd8d7a24d7d05453964abcd7d03dbf6e25893908e8", size = 186244, upload-time = "2026-07-10T06:30:27.235Z" },
+    { url = "https://files.pythonhosted.org/packages/32/e5/a9b98fc49ef0214718a9c839c6c63856a921877256ec46f371be32decfa8/websockets-16.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc2c453f3b5f99c56b16e233aad5299860558487d26adb2ed27a00c14ca24b8c", size = 187484, upload-time = "2026-07-10T06:30:28.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/7a/a575b52ca090b1976ffbe4b5f0762d03f399dfcb48eab883101331be71a9/websockets-16.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1a9f08a0728b0835f1c6abe1d9b746ab3de49b7336a0e1919cf96be1e76273eb", size = 190143, upload-time = "2026-07-10T06:30:29.91Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/40/705fbbd5677242fd36f724e9a94103e6bbdcb7d71e8f4498bfc1a8a7d413/websockets-16.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a089979d6173b27af18026c8d8b0077f83669a9169174482c4651e9f5739a5b6", size = 188004, upload-time = "2026-07-10T06:30:31.357Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/0c/58227c8d66b1c4060c53bac8e066fb4fe2603060408e934f48660a448d72/websockets-16.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3c18dba232ec2b92a68579c9fed8ff5a18f853d1e09fc0b6ca3159e94f689fe", size = 186689, upload-time = "2026-07-10T06:30:32.712Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d0/5c1314782594aa347e0f18808ee277a61986a2a2f9f470df9893183995bd/websockets-16.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c1eb7df4170d5068892a8834fb5c07b9552353deb0dbeb0bff3820481ae4792", size = 184559, upload-time = "2026-07-10T06:30:34.127Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e6/109c6f16850fd674b7e3d0e58b8987f05d3881abaa25f42a9faf5e85f097/websockets-16.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c522bd48e625b6d557aa228967258d6d3da031c4cc21d3352fb302479aa9ba0a", size = 186997, upload-time = "2026-07-10T06:30:35.397Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ec/6afa1aebc59426438b85cf7a3868c53a89005e2250a648c99e99943b90a4/websockets-16.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d106396927a7f00b0f3a69215c3357f87bf0bca6844247121f7e8291e826a3b1", size = 185621, upload-time = "2026-07-10T06:30:36.88Z" },
+    { url = "https://files.pythonhosted.org/packages/27/24/c038fe8682e9345bfa422d2cc5cc68b0491ab942c92e176bf8dfa6e8331f/websockets-16.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d71bed12909b8039955536e192867d02d76cd3797cedfd0facf822e7668636c3", size = 187384, upload-time = "2026-07-10T06:30:38.096Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ca/dc0ef2be39c67394e24bc982a0af59cd6249bf2f4e4272813c5c505d0da9/websockets-16.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:9c1cf6f9a936b030b5bed0e800c5ee32069338129084546baf5ff5014dc62fa9", size = 185258, upload-time = "2026-07-10T06:30:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/17/6b/3ffecd83ca3404b41fbdf8e9b178e55b529cd59bf64ea08b5a37b616b568/websockets-16.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3fd3e6a7af2c8fcdcf4ffbeaf7f54a567b91a83267204187797f31faaa2a4efa", size = 186050, upload-time = "2026-07-10T06:30:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/75/26/2e068497c78f31591a610ab7ef6d8d383ecadbe98f9121e1ebda77ef6d2b/websockets-16.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dddd27175bf640acae5561fa79b77e8ec71fc445816200523e5c19b6a556fb72", size = 186273, upload-time = "2026-07-10T06:30:42.309Z" },
+    { url = "https://files.pythonhosted.org/packages/44/ab/4dc049cb2c9e1be3a2c6fef77118f9c5049979e99cd56a97759d2f40f980/websockets-16.1-cp310-cp310-win32.whl", hash = "sha256:cce36c80b3f2fede7942f1756d3d885fa6fa086766c8c1bcf00695ab80f0d51a", size = 180157, upload-time = "2026-07-10T06:30:43.565Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4f/5e010ce5f66a8e5df380843f704ada508195a021c0c8a0f933639c9ee1c0/websockets-16.1-cp310-cp310-win_amd64.whl", hash = "sha256:115fc4695b94bb855995b23fb1abcb66099a5995575d3d5bc5605a616c58d0eb", size = 180458, upload-time = "2026-07-10T06:30:45.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/13/d47429afcc2c28616c32640009c84ea3f95660dab805766345b9682468e0/websockets-16.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a9b1d7a63cba8e6b9b77e499a81eab29d31100298d090ad4507d1048c0b9cae0", size = 179770, upload-time = "2026-07-10T06:30:46.308Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c7/2f0a722039a1e0107be73ed672ba604449b4956e48733e8e6b8a005aea42/websockets-16.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bedbc5efeb96621aa2921d2d92608246691399418cac22acba427eb11877ea1f", size = 177455, upload-time = "2026-07-10T06:30:47.601Z" },
+    { url = "https://files.pythonhosted.org/packages/43/6a/c26b0ae449e93d256ce5cdd50d5fe97b575a63e8dcd311a1faa972fd6bc6/websockets-16.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fd847ab82133015afe65d778e7966ab42dba16bd7ad2e5b8a7918db6539f3f94", size = 177731, upload-time = "2026-07-10T06:30:49.102Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/3f/381550b344a02f0d2f84cda25e79b54575291bc7022128a41163fe8ba5b0/websockets-16.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e2fb33ccb16ee40a95cc676d7b0ff451a9a2632f11a0dbc2e666326892b2e1de", size = 187066, upload-time = "2026-07-10T06:30:50.505Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/87/5ab1ec2086910f23cfb9ec0c1c29fbcc24a9d190b5198b1557c00ce4a47e/websockets-16.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f15b6d9ea9c2eaf6ccab964a082b09bfa6634a495bb0c2e9e7ee6943f58976", size = 188301, upload-time = "2026-07-10T06:30:51.835Z" },
+    { url = "https://files.pythonhosted.org/packages/75/4b/bbbb8e6fac4cfc53d7aaa69a3d531bf10799354b0021f4b58914aced8c1a/websockets-16.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:638cf57c48b4ad8ac1ff1e453f4f97db2426b690ddc111e6da96b27b4a340bc3", size = 191594, upload-time = "2026-07-10T06:30:53.229Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/da/6c0c349443d6e999f481e3d9a0e57e7ac2956d75d6391bec24b92af3fe13/websockets-16.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2c1c85f61bc9d5eac57ce705d848dc2d2ce3680638300bf4e1da7d749e2cf4ce", size = 188862, upload-time = "2026-07-10T06:30:54.744Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ea/a368d37c010425a5451f42052fe804e754e23333e8448aef5d55c8a8d64f/websockets-16.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:eeab6d27f51c7e579023c971f5e6dff200deadf01faf6831beaecd32052dfaef", size = 187633, upload-time = "2026-07-10T06:30:56.055Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4e/2ecd59add10d0855ec03dbdedfcdacdbd1aaabcd44b7dcbeda27538662e9/websockets-16.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2ed64e5a97b0b97a0b66e18bfe281317a75fbbd5afe692f939ea8d14a4292f2c", size = 185089, upload-time = "2026-07-10T06:30:57.444Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/eb/c6c3dcd7a01097bb0d42f4e9ef21a2c2a491d36b77cd0870ab59f9e8e77f/websockets-16.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9b3b021d0ed4bc16eea9775f62c9fa71acdacba0fc790b38581754dedf29ca60", size = 187790, upload-time = "2026-07-10T06:30:58.731Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/3e/775d36885d5e48ab8020aaf377de0ff5fbeb8bc2682a7e46419e4a14521c/websockets-16.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6eb604a4167f0a0d53c2243dfc667a29f0b43c3436057184e070bb82a1000fa2", size = 186381, upload-time = "2026-07-10T06:31:00.355Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/90/6305c00812a92e47d0582604c02bd759db0118bbafc13f707d712dbcf898/websockets-16.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9a3f125e44c3e34d61d111652e608e0f5b85ce08c225c8d56ad0eb822fa40030", size = 188193, upload-time = "2026-07-10T06:31:01.677Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/96bf8302c81d961585b4d34a2ddd3f229782f9b8c57bc78bbf98f1b1a4ac/websockets-16.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8fdf0b00d0d1f30d1f06a92cab46fe542eec3eb302a7aee7163f142d0780f216", size = 185771, upload-time = "2026-07-10T06:31:03.062Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/1f/e8fe44b1d2dc417d740d9959d28fd2a846f268e7df38a686c04ac7dfe947/websockets-16.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:67b56828712f5fa7852de4c0265c28827311a657a4d275b7312ed0d1a918bee4", size = 186803, upload-time = "2026-07-10T06:31:04.34Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/b07d3a4e1eb2ab03e94e7f53f0c7a628e85fde6ad86011f7afd08f27b985/websockets-16.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:39c7e7730be33b8f0cd6f0aa8e8c82f9cdd1813f159765e073b2ece65f4824b5", size = 187041, upload-time = "2026-07-10T06:31:05.567Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/fd/e0abb8acc435642ac4a671490f6cf781c882f3fe682cdced9080ea455ab5/websockets-16.1-cp311-cp311-win32.whl", hash = "sha256:c54fe94fb2f11e11b48920c5f971e298cec73ac35db56efe57a49db63dfc95d4", size = 180158, upload-time = "2026-07-10T06:31:06.929Z" },
+    { url = "https://files.pythonhosted.org/packages/81/06/85574d9458d3b913090087b817df0cc47b68e9a01dd0ab6ac04b77f49b0a/websockets-16.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9f4fb9ae8b802e55609685db98382d48fd3feb1397804e1e774968dea0f28c7", size = 180456, upload-time = "2026-07-10T06:31:08.247Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/52/748c014f07f4e0e170c8932de7e647a1511d5ab3049cd978797136aee577/websockets-16.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b6aa3f7ad345cf3862c21f4fbf2ef5e14d911348476c2845e137c091fe3a3f0b", size = 179798, upload-time = "2026-07-10T06:31:09.664Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/5e/2a2e64d977d084e49d37c187c26c056daaff41965be7300cd5dbde6f8b07/websockets-16.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b43fcfb521ac2f34ba80b7b8ea16303e4ad82dd8af667bf40839ad3a5d37b164", size = 177478, upload-time = "2026-07-10T06:31:11.072Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/12/5b85b4e75d697e548a94962ce5c036b05dd21cb9545759d555c5586422fc/websockets-16.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2bd3e12cd9afbe2baedae0b1eeade8ba64329b60fe2f9abdc966bd10fd2c2ef5", size = 177746, upload-time = "2026-07-10T06:31:12.386Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/62/79b1c8f0cee0da648b4899e1c5b0dbd3aa59846985136a54854db6827ab4/websockets-16.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f41979c8623df9bd30d949d82010a8fda5c56ff12cd8508a5b7272b6d4b53a", size = 187345, upload-time = "2026-07-10T06:31:13.754Z" },
+    { url = "https://files.pythonhosted.org/packages/25/34/b7c5c52c2f24280e1c017acb7ad491a566750a5cceca7f3cf999373bba21/websockets-16.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a24d1f35aef07d794a16c853c688e74956c50239bec37b4f2de080056046419b", size = 188581, upload-time = "2026-07-10T06:31:15.075Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/37/604193bebcbeffe96fdf795960b83a15d600880c64dc17ec9c31c5b3427d/websockets-16.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0c64c024ddf7a35331b21fcddb562a039c275d2c82e8c2d12939e7da23997270", size = 191362, upload-time = "2026-07-10T06:31:16.395Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b4/5ee27575b367d7110d4d13945e2a9de067ec84dc71e54b87f01e38550d9a/websockets-16.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c3e99757f5baafe20fc598e202ea6f5b0b265186ad38d0a17bd8beca16296955", size = 189216, upload-time = "2026-07-10T06:31:17.776Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/22/3e2dcc78d85fc5d9d814895ce6d07d0dfacc0f6aaa1d151f2b8c8d772299/websockets-16.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:353f3bc6e058ac1ccab4b3588e8598837a8c04cfc8351233e6d523be675d844c", size = 187971, upload-time = "2026-07-10T06:31:19.152Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/2f/cd271717b93d5ee19626cb5e38a85baab745c86e33db7c31a3ac729b31b8/websockets-16.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0352f5b38b40e857b6428d468fa21dbb4dd4a567d933c26d9831b4efe1b92f43", size = 185381, upload-time = "2026-07-10T06:31:20.665Z" },
+    { url = "https://files.pythonhosted.org/packages/78/91/6ad6f2f1426317b5001bd490534208c7360636b35bac1dec2e0c22bfc40e/websockets-16.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:70bd789afab579602968c39f21cb925466505f3edff22f0ae852bca54978a4f9", size = 188015, upload-time = "2026-07-10T06:31:22.024Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/6d/533733132ab4c07540efd4a8f0b9a435d3a5059b2f26cc476ace1abf7f45/websockets-16.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d0fb4b46f121eccd539353baebd1083a8767a9a351109453d1d1caecd1ba40c2", size = 186619, upload-time = "2026-07-10T06:31:23.376Z" },
+    { url = "https://files.pythonhosted.org/packages/08/73/16c059f3d73b3331eba10793704afa4faa9939234fb08ef7dca35794e8f0/websockets-16.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c14b6634af01541e4efe2954fd8f263386f7aa6d37c01e55dd8109fd17661452", size = 188497, upload-time = "2026-07-10T06:31:25.024Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/89/9a8fae7dd2acdcfb1a8844c29fe42b518a04b64fce38a0923b6290e452f1/websockets-16.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a58532c49a851bcb481e58c1be23b315c17fe2fbbed509d75aeea12f543d2c15", size = 186051, upload-time = "2026-07-10T06:31:26.291Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/b240c7dd6a0e0c59c1f68377cc3015263521080c327c15f5e753c1f6d378/websockets-16.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4e969170c3b08e1d8dabd990fef1fa702c4233aeaabec33f871806e444f6a0e4", size = 187029, upload-time = "2026-07-10T06:31:27.605Z" },
+    { url = "https://files.pythonhosted.org/packages/50/35/524e3fac40e47d6fdcf6c4b2c95ef1bc8a97e01593c90eff86621df7b716/websockets-16.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff9b000064b88787ba9f7a3cb2af2b68a658ca5aad76458a46469e7124b678a0", size = 187308, upload-time = "2026-07-10T06:31:28.927Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/56840cf62c8859af6ba22b9529da937332468c80f32b598753e8a66d3990/websockets-16.1-cp312-cp312-win32.whl", hash = "sha256:b9f5d83f80f4d7c4bba6d97f3755ac05850c784dce0fd2ab371c4e41172f53ff", size = 180161, upload-time = "2026-07-10T06:31:30.316Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/ff/87eb9eb44cb62424a8d729834f2b0515a47e2669fabec29820268f4d50a1/websockets-16.1-cp312-cp312-win_amd64.whl", hash = "sha256:6852c9f653966c16109d3b6f31181fd734f7914927e3f0fa1117af7a18c9aa21", size = 180462, upload-time = "2026-07-10T06:31:31.708Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/63/df158b155420b566f025e75613424ad9649a24bcb0e9f259321ab3d58bea/websockets-16.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b0232ed141cec3df2af5a3959a071c51f40036336b0d37e17faf9ef52fc73e47", size = 179791, upload-time = "2026-07-10T06:31:33.108Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cf/00fe9414dfeafa6fe54eae9f5716c8c8e9ac59d192be3b893c096d395846/websockets-16.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a71b73d143991714144e159f767b698f03c4a70b8a65ae1733b650cff488045b", size = 177472, upload-time = "2026-07-10T06:31:34.522Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/76/b10633424d40681b4e892ffd08ca5226322b2426e62d4ab71eae484c3a32/websockets-16.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:187323204c3b2fc465e8fc2609e60437c521790cb9c1acb49c4c452a33e57f37", size = 177737, upload-time = "2026-07-10T06:31:35.964Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/d3bb03b2229bb1afd72008742d586cf1ea240dce64dd48c71c8c7fd3294c/websockets-16.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9dba74233c8c3ce368850818c98354dad2570f57231b3fd3bd00d7aa57628881", size = 187403, upload-time = "2026-07-10T06:31:37.496Z" },
+    { url = "https://files.pythonhosted.org/packages/26/16/cc2e80478f688fc3c39c67dc1fac6a0783858058914ebc2489917462cb42/websockets-16.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:63339bc8c63c86a463177775cb7c677691f5bcfac7b3b2f01b286d42acd41600", size = 188639, upload-time = "2026-07-10T06:31:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/15/d6/ad87b2507e57de1cbf897a56c963f2925962ed5e85fbe06aaa83ced27acd/websockets-16.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23e545ea8ae4263e37cdfd4e22a217f519e48e432728bc461185bbf585f38a83", size = 190078, upload-time = "2026-07-10T06:31:40.218Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1a/5b37b3fd335d5811f29fc829f2646a3e6d1463a4bf09c3100708684c766e/websockets-16.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2237081454846fb40403a80ba86d82e2038b9c45865ab96af0abe7d002a91045", size = 189267, upload-time = "2026-07-10T06:31:41.523Z" },
+    { url = "https://files.pythonhosted.org/packages/42/98/06afc33e9450d4230f94c664db78875d90f5f6a5fb77f0bc6ec15ae74e1c/websockets-16.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5f5218de1ed047385ca53744caba9435d65f75d008364970a3fae95a05812cf9", size = 188022, upload-time = "2026-07-10T06:31:42.838Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/42fef5d5887c18cf2d148b02debf56cecb9cfbffc68027cde9b12c8f432c/websockets-16.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:75c98e3920039d0edff03b74478ada504b7ce3a1bc406db2cabfca84320f7baf", size = 185435, upload-time = "2026-07-10T06:31:44.219Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/9b/8021c133add5fe40ed40312553a6cd1408c069d7efe3444ad483d4973ed3/websockets-16.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1facd189d8190af30487a55b4c3688484dd50801628a3b5b2ccd26db08e67057", size = 188080, upload-time = "2026-07-10T06:31:45.986Z" },
+    { url = "https://files.pythonhosted.org/packages/69/54/1e37384f395eaa127383aab15c1c45e200890a7d7b99db5c312233d193e0/websockets-16.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:cc0c6a6eef613c7da32d4fb068f82ef834b58134f6a16b54e6c1e5bf9529ab3d", size = 186678, upload-time = "2026-07-10T06:31:47.449Z" },
+    { url = "https://files.pythonhosted.org/packages/68/79/1caeacab5bc2081e4519288d248bc8bd2de30652e6eaa94be6be09a1fe5b/websockets-16.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:ad9411eded8988b879be6038206698bf7106c85a78f642c004485bcb95be17eb", size = 188554, upload-time = "2026-07-10T06:31:48.886Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/83/b3dca5fad71487b726e31cb0acf56f226792c1cc34e6ab18cbf146bd2d74/websockets-16.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:cd68f0914f3b64694895bc5e9b14e8b447e41d7bf5ffaf989bb8dcb5e2dfdce7", size = 186109, upload-time = "2026-07-10T06:31:50.508Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/0b/8f246c3712f07f207b52ea5fb47f3b2b66fafec7303162644c74aed51c6a/websockets-16.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fef2debfe7f7ebdda12176f26166f95b7af17af05ba06150fcf889032e0213e9", size = 187061, upload-time = "2026-07-10T06:31:51.861Z" },
+    { url = "https://files.pythonhosted.org/packages/47/eb/27d6c92a01696b6495386af4fc941d7d0a13f2eab2bf9c336111d7321491/websockets-16.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a3cd6c9b798218798f4bb7b2e71c38f0e744bb94ca537b13376f88019d46384d", size = 187347, upload-time = "2026-07-10T06:31:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/d5/eeee439921f55d5eaeabcea18d0f7ce32cdc39cb8fc1e185431a094c5c7b/websockets-16.1-cp313-cp313-win32.whl", hash = "sha256:84c170c6869633536921e4474b1cce7254c0c9b0053ef5725f966cee47e718e4", size = 180149, upload-time = "2026-07-10T06:31:55.058Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/03/971e98d4a4864cf263f9e94c5b2b7c9a9b7682d77bfbba4e732c55ee85a9/websockets-16.1-cp313-cp313-win_amd64.whl", hash = "sha256:bef52d327d70fa75dad93ee61ea2cb1d1489aca9f35c188833563f5a3b4df0a5", size = 180458, upload-time = "2026-07-10T06:31:56.767Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/f4/84ef884775bbe77c46cce79bc7d705ea3bc6574cc00acf81af89754c077d/websockets-16.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7289d899c79e763e6221c8dcb8959361cb43274418538d7c7ad16a43b01d12f9", size = 177387, upload-time = "2026-07-10T06:32:48.574Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/d9/6831ec6f65e1eeac770375f4f4b604f23df9bafaa1b47004bc5f9488d513/websockets-16.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:e22e9e3719f5131bd62da4db63c8da63eb8c91cc99e16c1cbd122f130e1ae07a", size = 177663, upload-time = "2026-07-10T06:32:50.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/21d4922fa7fe855813a8b38f181a0ecf02a586e16c1f095fd05471f78cc2/websockets-16.1-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:83bdabafef431247e6b11a9aab8a0893fd8e82e1ed95b32e0373625b03ffce4a", size = 178501, upload-time = "2026-07-10T06:32:51.439Z" },
+    { url = "https://files.pythonhosted.org/packages/91/87/7a0320df854dacd09507ca972cb04a4dc5aae279583cc5b80ad5f5819533/websockets-16.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b8d13ceabc5c60995f201b5211d76876e17e68706ebf5d3bc666b32eefff1a6", size = 179397, upload-time = "2026-07-10T06:32:52.892Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6a/0da1eb8c8da2ace7b578c8523d32618af85e62a9ebad56051d4a14a38a1c/websockets-16.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:81495f9c0085361c582efbc3207fb877174cfe03370f17d9cd70624404aa526f", size = 180546, upload-time = "2026-07-10T06:32:54.619Z" },
+    { url = "https://files.pythonhosted.org/packages/66/58/bd83247f39ddc26ffc2c24eb05087a3b749e00cb4509fc6d19daa23c8495/websockets-16.1-py3-none-any.whl", hash = "sha256:c5149dfe490ec7e5ee5dbf624c642fb725f93a5575c7f00ab594ca9eddb8dd81", size = 174031, upload-time = "2026-07-10T06:32:56.079Z" },
+]
+
+[[package]]
+name = "wheel"
+version = "0.47.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/39/62/75f18a0f03b4219c456652c7780e4d749b929eb605c098ce3a5b6b6bc081/wheel-0.47.0.tar.gz", hash = "sha256:cc72bd1009ba0cf63922e28f94d9d83b920aa2bb28f798a31d0691b02fa3c9b3", size = 63854, upload-time = "2026-04-22T15:51:27.727Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/1b/9e33c09813d65e248f7f773119148a612516a4bea93e9c6f545f78455b7c/wheel-0.47.0-py3-none-any.whl", hash = "sha256:212281cab4dff978f6cedd499cd893e1f620791ca6ff7107cf270781e587eced", size = 32218, upload-time = "2026-04-22T15:51:26.296Z" },
+]
+
+[[package]]
+name = "xxhash"
+version = "3.8.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/63/71aa56b151a1b28770037a61bd4e461c2619cfc8866a4fcaf1548605e325/xxhash-3.8.1.tar.gz", hash = "sha256:b0de4bf3aa66363552d52c6a89003c479911f12098cd48a53d44a0f7a25f7c46", size = 86223, upload-time = "2026-07-06T10:49:58.937Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/97/1a8cebf0a6650417f08a18231590e2515aacd5ce39c3ad8b9e013ebd437d/xxhash-3.8.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:27a9e475157f7315826118e3f3127909a0fe25f1b43d3d3be9c584f9d265f937", size = 34695, upload-time = "2026-07-06T10:43:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/cf/745b9bc0dd9c341bc074b5fc700db7bbef0f3b69ab21446492296ab37e50/xxhash-3.8.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9b2ce44bf8f4a1d01f418b3110ff8dff32fd3f3e836c0e06333c3725f243fa6c", size = 32376, upload-time = "2026-07-06T10:43:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/65/a4/8512a901b1d6ad4a9838d1b40385907a879d7e005a5afbec5d39526b69f6/xxhash-3.8.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:942bc86e9be6fdd6e1175048f5fe8f8fdaaf2309dd1323ef1e155a69cd346780", size = 217470, upload-time = "2026-07-06T10:43:43.572Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/ad/0ffd8094ea29579bb2dc42fa74d08570e9ea3d95db561e6b1105e69b9ca6/xxhash-3.8.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0204701e6d01f64254e0e5ff4255812b1febe027ddd7dda63372e27f98b5e91f", size = 237799, upload-time = "2026-07-06T10:43:45.248Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/90/783c6b3f9336bd07449fe672be32cef6833633936bbfda8d3b23ee18d202/xxhash-3.8.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7dc4bdf008f77c88d544849c48c1a40faf25a5eff6cc466de2e8edc37c191fce", size = 262587, upload-time = "2026-07-06T10:43:46.733Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/77/ba0316a7c3e661b86830a47ae4987798616ce1b15af8d2a6358e2d89ef60/xxhash-3.8.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c566b123dce7e4867ca518434cdfb9f84e5023771235b2e3107a26c9a41cbd8", size = 238484, upload-time = "2026-07-06T10:43:48.453Z" },
+    { url = "https://files.pythonhosted.org/packages/09/79/33001037c1cba90f4ced38b257161c13452024c0db44208f883e2e47f3fc/xxhash-3.8.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9f23083e1bd9d901f844af7a126727c486e7eada9a1a6791c8f7e73f94fac656", size = 469909, upload-time = "2026-07-06T10:43:50.188Z" },
+    { url = "https://files.pythonhosted.org/packages/45/90/237eded9dd6ae638083294e5a9f77b317aaebd480a330806b39c192a0de1/xxhash-3.8.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:64af54dd1c3a45a27c04942f9a1a4683322bdd127f4745cca4e02549c1d2d2bb", size = 217166, upload-time = "2026-07-06T10:43:51.816Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/6a/8cb439dc9920e1468e1c2d69ef77cbeb4be3b1ae9f4b5344c07a2b59af18/xxhash-3.8.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8ea8a141eeced4f6262ab6dd71c681ac546a558c30bb586abe087d814b5f85ea", size = 307593, upload-time = "2026-07-06T10:43:53.436Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/c6/c0607d373c8affea92101a3926c4fc8b026bcf8983e05fd58f3a0380ebf8/xxhash-3.8.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a98b2f95cab589e0f5e92c48431afb4d56238b8bf6668edcc66166180e9b509b", size = 234702, upload-time = "2026-07-06T10:43:55.042Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/cb/f4cfd456624c1f017858168b7ba9443dad810da8aac779a612658450e827/xxhash-3.8.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1b86ae798a976ccbc1d02af6ccb98f5b4d24756b1f65e995f11d10fe071f486f", size = 265749, upload-time = "2026-07-06T10:43:56.749Z" },
+    { url = "https://files.pythonhosted.org/packages/33/f3/9006669c04b01206e21b2177425c649461ba188930a052c2f1728d6ec6a8/xxhash-3.8.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81f4ed9ca9644bc95cd976bfe10f7a4cafab8ffdc3aed52877d4600e445be7ef", size = 221992, upload-time = "2026-07-06T10:43:58.12Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0b/7e6f3eaa05df5e0b6c94aa452b0672801f7031e602081f07fd441aaaaed5/xxhash-3.8.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:cb3fe820c27593f170770d6c8d791936cf6275d9269405fbb7b30a55363c10c8", size = 236899, upload-time = "2026-07-06T10:43:59.562Z" },
+    { url = "https://files.pythonhosted.org/packages/da/cc/bbaee4987f3aab1d7b33bb430bb49e940646160af448b9167431c931126d/xxhash-3.8.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:7345007c12780985de4fd740148776d1eee18c0d41407c6fa1e48c5450304fe5", size = 297934, upload-time = "2026-07-06T10:44:01.132Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/97/6bee358660eb8b4f73c00b00b00bc616ebde00e1ab4b67c63486ce360648/xxhash-3.8.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:12eaeaa9ab8b9e6033a1fa5f6b338aaf55ff4df4bee11b59fd6ee03b19186ee4", size = 439315, upload-time = "2026-07-06T10:44:02.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/50/7e35275f39256bedace0c3cd5be3c72d4ac9d5aecf5e5fdc3530337cd263/xxhash-3.8.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e2a845687219ba3214126f14a8a5861f97c9e065a7d0b8252adb6df13eea86fb", size = 214038, upload-time = "2026-07-06T10:44:04.504Z" },
+    { url = "https://files.pythonhosted.org/packages/59/2d/69d02d096ee50bdf3ef0d208d874f52c71b1aa6906066bce3c52fedb8bc6/xxhash-3.8.1-cp310-cp310-win32.whl", hash = "sha256:656256c9f9303e47f07d5cb8ae4468285370adfafd7ba48aea33a458e7697626", size = 31939, upload-time = "2026-07-06T10:44:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1d/e06fca9844919ca91c6587d530cfa1e745830ec73ad38f44f04b25d1bfb7/xxhash-3.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:27cfc2f1ed76f956f36dfe0c56e5f5a3e94cd91eb78b893f63e2ef2ae404fcdf", size = 32729, upload-time = "2026-07-06T10:44:07.621Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c2/800648d99039927b5a86d8ae02cd86a556a5ee1678d388216f6b44c8966c/xxhash-3.8.1-cp310-cp310-win_arm64.whl", hash = "sha256:c85949d02c85adf6d786eb94858e124989a632a4e65739835b2fc5761827fac3", size = 29215, upload-time = "2026-07-06T10:44:08.916Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/5a/05eaa129555f85476a3e16ff869e95f81a78bbe4647eef9d0229f515a317/xxhash-3.8.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602efcad4a42c184e81d43a2b7e6e4f524d619878f2b6ee2ba469011f47c8147", size = 34699, upload-time = "2026-07-06T10:44:10.14Z" },
+    { url = "https://files.pythonhosted.org/packages/80/59/0df1133958b2228929355e022aab1e958c7b2c43e27bf7f59bc9edfa8a54/xxhash-3.8.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:131324f719957b988861714de7d6ddf57b47abec3b0cc691302ffeaba0e05e10", size = 32373, upload-time = "2026-07-06T10:44:11.353Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/bf/1cfda5b5e6bf26617812b4a31662ef2220d2ad04e0a55b8ff9eb36e56a5c/xxhash-3.8.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:db77278a6eddadbf44ce5aae2fee5ebb4d061f026b1ce2130d058cd4d7a7b670", size = 220284, upload-time = "2026-07-06T10:44:12.683Z" },
+    { url = "https://files.pythonhosted.org/packages/70/93/45dc0ad7913b69e5b08bd039236cf628380e4c9cc76a8a4c6625a328e058/xxhash-3.8.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c332dd48b8cb050da2bb2a3c96d72b1664168650a250ef9718e423df7989e05", size = 240980, upload-time = "2026-07-06T10:44:14.297Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/02/f28ba7d17f2c1410ee397982c817ab1bd5b2701070c2d2c373539aad000a/xxhash-3.8.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a5cd96f6dcdf4fa657b2d95668d71d58455248f98712ecffaa9c528edf40ccae", size = 264526, upload-time = "2026-07-06T10:44:16.017Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/d0/f10651cec2c7981b20d693deae6bdfc438427d92be2db4ccabb6181f0021/xxhash-3.8.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c959f88160b13b4e730b0d75b459b7929fc0d2225c284c9683ac95d6feeeac6a", size = 241369, upload-time = "2026-07-06T10:44:17.698Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/40/136e0cbaf5db51e191423b1c98643593189f02b6cd90837bf64b19113d70/xxhash-3.8.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:027dee4355f3fcc41481650d846cf6cfc895c85a1ab7acd063063821a0df5b4c", size = 473186, upload-time = "2026-07-06T10:44:19.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/3f/6aa808a96bdc43dba9a740dec56c744526ee3c0019e32c75e810fa90ae4d/xxhash-3.8.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad52a0e4bcc0ba956a953a169d1feec2734a64981d689e4fc8f490f7bf91af60", size = 220092, upload-time = "2026-07-06T10:44:20.956Z" },
+    { url = "https://files.pythonhosted.org/packages/47/28/a8675e78a9ced96dab853416162268e10e05b452e95db7888cf69f58ac5f/xxhash-3.8.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5d3dfb1f0ff146da7952867a9414f0c7a29762f8825a84879592612fd6139342", size = 309846, upload-time = "2026-07-06T10:44:22.543Z" },
+    { url = "https://files.pythonhosted.org/packages/89/0f/7fe4d4ef4e69f0033e012396ee2a115886bca7b10b7e45ce398626436bfc/xxhash-3.8.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4482380b462ca9e59994d072a877ecadd1cf51102daeeab2db696f96ab763723", size = 237659, upload-time = "2026-07-06T10:44:24.135Z" },
+    { url = "https://files.pythonhosted.org/packages/38/8f/83e9e31d4ed57fe963b99cb5b13a23e3e0f0dad1885aa0ebd2a7819dd423/xxhash-3.8.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:950ac754d16daea42038f38e7465eb84cda4d08d7343c1c915771b29470f065a", size = 268737, upload-time = "2026-07-06T10:44:25.875Z" },
+    { url = "https://files.pythonhosted.org/packages/57/79/7e7de46dbe5d1f49afc96a0bc42e6b8df24eae3d6bad6007b99e42f48430/xxhash-3.8.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0418ec8b2331b9d4d575fc9284427e8e69449d7172e99e1a86fcdd1f51a0a937", size = 224955, upload-time = "2026-07-06T10:44:27.777Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/34/b8540839e958d5ef5c6101af6f16032109e7099698ae8edbc8dcefe4d8f4/xxhash-3.8.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:32a94ad2763e0263d9102037d349002c3d3c401e42770542c3eeb4801f311661", size = 239653, upload-time = "2026-07-06T10:44:29.422Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/87/a735d05f7f859354acadabe470ff40e2c46672275f96dcf096a761904def/xxhash-3.8.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:89b11a5cdd441aa463f6d34ca0241602bc09b001a76994b6059828494108c673", size = 300213, upload-time = "2026-07-06T10:44:31.401Z" },
+    { url = "https://files.pythonhosted.org/packages/98/31/3e1cb020237b68117fc212dc5f9753b87f865b4dfee7c1ce62d0836955b5/xxhash-3.8.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:09a204dd4bb0823daf938cdd0dc8057d5f1e14fe3cbde929424255f23f9de872", size = 442508, upload-time = "2026-07-06T10:44:33.023Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/f80090622141cc734b039ce1d15ce3ff6dced375e9680249bf5b9b8c6bf9/xxhash-3.8.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e710ad822c493fb80a4fbc1e3d0a807b1422cb90adbe64378f98291b7fa48fef", size = 216853, upload-time = "2026-07-06T10:44:34.983Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/a3/60157acecc307b238d3651c2483168e224b48b23a36ae6d6903588341d80/xxhash-3.8.1-cp311-cp311-win32.whl", hash = "sha256:5013be3bea7612852c62a7437f3302c1cfb91ca7e703b194459db0b2b2e0d792", size = 31936, upload-time = "2026-07-06T10:44:36.542Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5c/ef70c418d878d187b8da56d4cdc06aea6cf5e456b301e96e51e1d2cc8625/xxhash-3.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:f377012b86c0a23a1df0cf5a1b05aa7187649e472f71c7892e5f2c2815bbe74f", size = 32724, upload-time = "2026-07-06T10:44:38.177Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/25/f008db952cec6b2a26445b456eeed2ebebd65e08e848ebe09ed6ac0634e6/xxhash-3.8.1-cp311-cp311-win_arm64.whl", hash = "sha256:836f11d4474d3228e9909d97216faa4f7505df41cfaf3927eb29809de785a78d", size = 29212, upload-time = "2026-07-06T10:44:39.577Z" },
+    { url = "https://files.pythonhosted.org/packages/42/91/f65c34a7aa7b4e7cf4854f8e6ef3f7ee32ceac41d4f008da0780db0612f6/xxhash-3.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e6e49370822c1f4d8d90e678b06dbcb08b51a026a7c4b55479e7d467f2e813bc", size = 34680, upload-time = "2026-07-06T10:44:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/57/04/b10a245a4c09a9cfa88f8e9ae755029413ad1ac17047f9a61906e5ae0799/xxhash-3.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:220d68130f83f7cc86d6edfdeab176adc73d7200bf3a8ec10c629e8cf605c215", size = 32397, upload-time = "2026-07-06T10:44:42.196Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/75/45ab795b5945b6388583bd75202106af505537935566c15a1577797a0e08/xxhash-3.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4d365ee1892c1fa803536f8c6ce21d24b29c9718ec75eb856095c07830f8c478", size = 220549, upload-time = "2026-07-06T10:44:43.603Z" },
+    { url = "https://files.pythonhosted.org/packages/13/44/5ba2bd0a14ddf4193fc7d8ec29625f659f22c06d60b28f04bf46305d8330/xxhash-3.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:852bfe059720632e2f16a6a4745e41d20937b2bf2a42a401e2412046bb6971cc", size = 241186, upload-time = "2026-07-06T10:44:45.534Z" },
+    { url = "https://files.pythonhosted.org/packages/23/32/c4147def4d1e4538b906f82731e0ba23424377fc50a7cddd03cd284c8f63/xxhash-3.8.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2f8c25a7061d952de589bd0ea0eaadee32378ff83dd6a677b267f9cd86f401f8", size = 264852, upload-time = "2026-07-06T10:44:47.199Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/bd/71ed14f4f0318bb7fd7b2ec51999413487fa8da8d41208e84d50d1ef0f98/xxhash-3.8.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:868a8dcaff1a84ba78038e1cef14fc88ccf84d9b4d12ea604696e0693296aa56", size = 242663, upload-time = "2026-07-06T10:44:48.846Z" },
+    { url = "https://files.pythonhosted.org/packages/91/09/70af22c565a8473b3f2ae73f88e7721af281bc4a575236dbd1970c9f76f6/xxhash-3.8.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6536d8677d2fff7e64cd0b98b976df9de7aee0e69590044c2af5f51b76b7a170", size = 473510, upload-time = "2026-07-06T10:44:50.695Z" },
+    { url = "https://files.pythonhosted.org/packages/18/96/34db781c8f0cf99c544ca1f2bc2e5bf55426e1eb4ca6de8ea5da56a9f352/xxhash-3.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:82c0cedd280eab2e8291270e6c04894dbc096f8159a39dcf1807429f026ca3cc", size = 220469, upload-time = "2026-07-06T10:44:52.422Z" },
+    { url = "https://files.pythonhosted.org/packages/93/5f/9a184f615fa5a4dce30c01534f62946ce5a11ce40f73785cbd356ccabaa9/xxhash-3.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:daa86e4b68221d38e669bb236ba112d0335353829fb627c82e5909e4bbe8694c", size = 310290, upload-time = "2026-07-06T10:44:54.142Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/dc/9b9a9789011ee153723a5eb9e7dd7fcbae2ba9b3fe7a729249ca7c252056/xxhash-3.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2bc7113e6f2b6b3922dd61796ca9f36af09da3773898e7003038dc992fc83b8d", size = 238173, upload-time = "2026-07-06T10:44:55.693Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4d/71c6005ada9dcb608a4e1902e8475ecadb5f3fbfa04e1e244d276a2d0c43/xxhash-3.8.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5eed32dad81d6ba8e62dc7b9ffa0500199385d7810a8dd9d4eafaceb8c6e20bb", size = 269026, upload-time = "2026-07-06T10:44:57.424Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/87/d6c036ba25dfbd9c8633be5aa86fc9474bbb9e2c68212a841d090abe7344/xxhash-3.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:83697b0ea1f10e7f5d8b26a4906fa851393c61546c63839643a2b7fe2d868061", size = 224970, upload-time = "2026-07-06T10:44:59.085Z" },
+    { url = "https://files.pythonhosted.org/packages/48/62/4c1f035a41c5752aa05e195b6c904c07b94fe9061a16de61e72a6e6b135f/xxhash-3.8.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:36fc69160465ae75c6ec4ac9f781bb2aa16ae7ff869e73c26fee85fbb11b9887", size = 240820, upload-time = "2026-07-06T10:45:00.746Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/d39d565069b87e86d21a2af2a31d04db79249d25aa8d5b62959056a89857/xxhash-3.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:445e0f5a31f2f3546ae0895d4811e159518cdc9d824c11419898d40cfadb677e", size = 300619, upload-time = "2026-07-06T10:45:02.716Z" },
+    { url = "https://files.pythonhosted.org/packages/13/22/75467acc887edc8cf71c97ab1708feb3df7a88bda589b9f399765c6387d2/xxhash-3.8.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:dfe0580fbfd5e4af87d0cc52d2044f155d55ebd8c8a93568758a2ea7d8e15975", size = 443267, upload-time = "2026-07-06T10:45:04.653Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b6/1da3baa5fa6ef705e3425fddd382be7dfc4dfba2686df90a20f16e9c7b1b/xxhash-3.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:095e1323fa108be1292c54c86da3ef3c7a7dc015b105a52133973bc07a6ad11a", size = 217338, upload-time = "2026-07-06T10:45:06.304Z" },
+    { url = "https://files.pythonhosted.org/packages/78/dd/b5295a9f97484e7a1c2b283a742ca45e3104991c55a1ef670dde161829ba/xxhash-3.8.1-cp312-cp312-win32.whl", hash = "sha256:bf28f55e427e0483acb1f666bd0d869b6d5e5a716680c216ad7befe3d4cfba2e", size = 31970, upload-time = "2026-07-06T10:45:07.823Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/31/3fa0b807d7e21515cd975e7fe5c039d52ac3e9401a96d6ad68dae6305215/xxhash-3.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:2256e80e4960ee282f63428adb349cb7f8bd8efe4db770d88eb815f4b9860724", size = 32741, upload-time = "2026-07-06T10:45:09.42Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/05/86feada74e239600e6875aa507afb40482a89b92700aa74a92da83bdcb77/xxhash-3.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:9df56e6df96a60590935e22373041cccc91fd55858763dcffb55bf63b3a2b396", size = 29234, upload-time = "2026-07-06T10:45:10.809Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8c/446bb782cd0d27007a917b5569a08dd73219c3e8d6e459014db104b27bdb/xxhash-3.8.1-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:3c682fcd96eb4bf64be32a4d95f96107e1588005831bd8a741b324fdda01b913", size = 38562, upload-time = "2026-07-06T10:45:12.425Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ec/c0c45627eaa6be7a5d6117423adf8f7a15b17ee74b4b17072cca5959a225/xxhash-3.8.1-cp313-cp313-android_21_x86_64.whl", hash = "sha256:036a024d8b9c01f70782e09ed98d532e76fd23f950ae7154bd950fe94e90ebec", size = 36656, upload-time = "2026-07-06T10:45:13.932Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/94/8324c04cc7597154caaeba6c094e01fbd2e7601d01e7a13eea9f5420e77b/xxhash-3.8.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d6a5c0bce213b23b0166fe0d35bcbbe23ce4b968f257cc7eb6fd57cb8e1e6297", size = 31169, upload-time = "2026-07-06T10:45:15.687Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a4/beb6bb26e1184e126dbe7a5682330214ef54dcfbf882078aa9f4b5428d42/xxhash-3.8.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:5177aa44eddaa97c6ef0cc00c6d540edb64d51781d2f8fb941612ec61a92c9ed", size = 32177, upload-time = "2026-07-06T10:45:17.035Z" },
+    { url = "https://files.pythonhosted.org/packages/56/0f/fc4c92a5a528f839b34b6419b2e53c8597f2a629d5a1f5d721f65bfa1fd6/xxhash-3.8.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7801b7223db017b9c0c9ccf37e44524edb35a1544a1c032add22c061c6af0276", size = 34642, upload-time = "2026-07-06T10:45:18.39Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/58/edbfb141d4000767ac6a9694f8ac0763e2c2e983e65c9e31620ba56e2667/xxhash-3.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9e80238259655bf69d7bcd08226a970d7f42605f3157786bfa76dd13472d7fa0", size = 34684, upload-time = "2026-07-06T10:45:20.033Z" },
+    { url = "https://files.pythonhosted.org/packages/07/3f/5072f1f0f5714186f0ac2a0b5a4929ce30d4b845e94886b6c01b6ebda0be/xxhash-3.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bcab50a389cc04d87f90092af78a6adba2ab3deca63175a3344ca83514045315", size = 32401, upload-time = "2026-07-06T10:45:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/49/c7/802ea2f9c2ed59219934d6d65c470d502b1788043eae277a52af8658bda6/xxhash-3.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a2489d3a776fa380cb8e71f54c7fda268a9baf3de9b1395093fd280f95735907", size = 220617, upload-time = "2026-07-06T10:45:23.234Z" },
+    { url = "https://files.pythonhosted.org/packages/99/a8/e10488efd31fcb13fcd6acbc6e788f10c6f8e3a0cc4ae3eb89dc19c55a12/xxhash-3.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32ab1e5432690276e71192be7401b55f96db2d0eedea5d44eb1f164505669cc0", size = 241295, upload-time = "2026-07-06T10:45:25.364Z" },
+    { url = "https://files.pythonhosted.org/packages/18/cc/14180b17d44892a631f8ae7323c30bfbb1328efc8209e528a480293528ac/xxhash-3.8.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b30e01a0b97a4bc3f519a4d7a82da3dc53251fb0de5eeea8660dcd4ff094c0c2", size = 264688, upload-time = "2026-07-06T10:45:27.09Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/72/a14019d0c5f6c41ee407a503036ae32787c91325ca218a96a9b5627be651/xxhash-3.8.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1f44275ddb0978b67a58a951501903f04d49335a91f7681c9ce122ecb8ccb329", size = 242740, upload-time = "2026-07-06T10:45:28.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/08/92550e556c6fcfcb96c6a336945eb53a431ed43120ed749636debb16c5cf/xxhash-3.8.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e3b87cbd974512c0c5fc7b469c36b2cdc9ee6d76e4ec78bccb2c7184611c49b0", size = 473599, upload-time = "2026-07-06T10:45:30.524Z" },
+    { url = "https://files.pythonhosted.org/packages/29/83/e361d3c1acd1b21e1d489616de6fa4aaf843365d8179f612e3743eac20a9/xxhash-3.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98ee81b4b7f3023c9cb04a78cc67610baffcb5812d92f2096cb5a5efc6f19437", size = 220559, upload-time = "2026-07-06T10:45:32.979Z" },
+    { url = "https://files.pythonhosted.org/packages/05/01/006a4243c2c2a6831827f9999f6d1c23feeef100eb023c1f886022a00bf3/xxhash-3.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2666f059a1588a99267e33605365ed89cea92f424b3522806a9f4bd8ad2e3d62", size = 310383, upload-time = "2026-07-06T10:45:35.875Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/20/af388e8bf9f9a0f89eeef7d2a1935d176ee1c20bc6adeda05035879379cf/xxhash-3.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0093cf7eeb91b84776e8742113afa4bdf47533d36cf719179aaaf1f56f6f8bf", size = 238228, upload-time = "2026-07-06T10:45:38.02Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6b/4666579a87eebd1744663c404297355fa0658617b015cedfa58810ee7036/xxhash-3.8.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3a800912a2e5e975d4128969d645c4a2a80aa886ccd6c9b1c6f44529e327e8cf", size = 269137, upload-time = "2026-07-06T10:45:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d3/e963a8a46f900a137d91b02144d8ea07a8f812971b138204a3b2f8b8e55c/xxhash-3.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0fe37f72a207223d22a4eddc3149d4298993385aa9daef25c039246ca5a309f3", size = 225068, upload-time = "2026-07-06T10:45:41.718Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/80/9d181dbcde4b0fe48375f48833a5832d4b8cd2b349b15110c92ee472d874/xxhash-3.8.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5db43f249b4be9f99ef4b967863f37094fb40e67effafb78ba4f0356b6396104", size = 240874, upload-time = "2026-07-06T10:45:43.414Z" },
+    { url = "https://files.pythonhosted.org/packages/39/15/ce3ab5a1cd27ead25a5196e55a7284220f6ad6e316da494ffd900b2b600f/xxhash-3.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c4ed42965c2cd9081f011be22f69d0e65d3b6165fe7734072fd0c232840bbd4e", size = 300702, upload-time = "2026-07-06T10:45:45.135Z" },
+    { url = "https://files.pythonhosted.org/packages/96/c0/2281a8ab5f2a62dbf57a23c58a01ccc1d98abf40f71193c8a81f59e759b5/xxhash-3.8.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3557bec8fcb11738a8920eeb68974bc76b75262f6947998d3147954ce0a4b893", size = 443351, upload-time = "2026-07-06T10:45:47.188Z" },
+    { url = "https://files.pythonhosted.org/packages/81/2e/071a58c1a53a52d4f7a3aa0987be0c396dffd40da8204805fe1b130a81f4/xxhash-3.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:00de40f3b42240db23a82a5c682b55d7263d84a26a953240c1aee463409660e3", size = 217396, upload-time = "2026-07-06T10:45:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/68/44/36ab58134badd9d3433fc7b53c4ca8d113d8e807782885628640f8297a4d/xxhash-3.8.1-cp313-cp313-win32.whl", hash = "sha256:b5196cc2574cfec572a5f3fb7cfa5ade27305ae3d06516a082132441aff4c83a", size = 31974, upload-time = "2026-07-06T10:45:50.591Z" },
+    { url = "https://files.pythonhosted.org/packages/96/2a/2a0b84798448e766f7b89ceed073cb0cb5a43fc9ebbacbdea74a38de18e3/xxhash-3.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:538f5f865df6cd8c32dd63158a0e5b4f5dd08d732a7da8b7228a5a0776c8ce55", size = 32739, upload-time = "2026-07-06T10:45:52.221Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/60/bb51dbf7c363ff88a7cbd50b7959718219577ef44d7cf255929ffc4a2194/xxhash-3.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:a6617f30641ba0d8baa1635fbefb1dffc5165ec36d26921bd5cee13497cd937a", size = 29239, upload-time = "2026-07-06T10:45:53.714Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d3/827ca123c2ee5443a6aaed3c5dd199237dc2f010e2bebd7ec09ef36f3a5f/xxhash-3.8.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:bfcd82852c62a60e314670a9602de354c4460f8adad916e2e42a20860c7870bc", size = 34964, upload-time = "2026-07-06T10:45:55.535Z" },
+    { url = "https://files.pythonhosted.org/packages/05/67/67ae2a3ccdeb8b8ef025d35aee9edd1d26c3abe5051d47da9286232afbf8/xxhash-3.8.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:08ea2081f5e88615fec8622a9f87fbe21b8ea58d88cfc02163ca11026ee62a92", size = 32697, upload-time = "2026-07-06T10:45:57.288Z" },
+    { url = "https://files.pythonhosted.org/packages/38/5a/3d3994346e1f45493679cb5c1ffc2bf454e410e9d1e8a662d253becee91e/xxhash-3.8.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2e32855b6f9e5b18f449e59d45e3d5778bdeb660632ef2693cca267a11246c75", size = 225954, upload-time = "2026-07-06T10:45:58.897Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/2c/53169270309b7cd8e05504e07fe123bac053b89d00ac63617faacf0a2ec0/xxhash-3.8.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6e088bd7870775624256a0d84c2a6714afd223b2eeb56b0ca58398e52a32fda", size = 249776, upload-time = "2026-07-06T10:46:00.977Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e0/5c551d8d592f944506f7c5185e210255c15e672a3c6008c156a1bd9b775e/xxhash-3.8.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:72eb5ae575cc7ae2b23f6f8064a8b10f638c7149819ae9cc6d20ebd4d37a1629", size = 274776, upload-time = "2026-07-06T10:46:02.869Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/2a/d3a762270cee2d7bcd0e25e28c623e5f3f5c0dc637b66e3e47dd5b0bb3f0/xxhash-3.8.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d0b48cdf690a64cedf7258c3dc9506cc41fc86edd7739c40e3098952265dc068", size = 252056, upload-time = "2026-07-06T10:46:04.688Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/b78e4373b2cb6d1c42af60ea2d7e9146ad0710b239ac7f706d5d31d5bb98/xxhash-3.8.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb9e256a357dfcede7818c6d34e70db2d6b664394803d1de4b6984d2de76c0f1", size = 482108, upload-time = "2026-07-06T10:46:06.498Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/642d923336ea61a15f8ce64fc7e078729e6e06c3a026e517fa79b2c23b7a/xxhash-3.8.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51f71a6e2ad071e70c937e41fcb6c19f82c3f9f49831eba850ed4a106ffbb647", size = 226739, upload-time = "2026-07-06T10:46:08.598Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/0a/a37d6da6427d45a8d23e3ee3a0ca9c9d4a90364849c6637fe2963a755f9b/xxhash-3.8.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e4a6443968c4e8dc69967e12776776a5952c119cc1bd94168ad1c5ad667c2be1", size = 319658, upload-time = "2026-07-06T10:46:10.504Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/51/ebbd40da8a3f1bc53b4b7a9a87f8e28bd95c5f21bc14b8a57860cf367d1b/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:714503083a1f2065c9ad15340dd49ac8a8e948a505a705ffa1750cb951519113", size = 246059, upload-time = "2026-07-06T10:46:12.634Z" },
+    { url = "https://files.pythonhosted.org/packages/24/4c/d9014030147e1f0bb26e7da47aa240dd9ec61c763c573e558111d869f8e1/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:77f74e45a1e5574bbbf80181c8027b3a4c65c2248fffbd557bd596fff13102f9", size = 275535, upload-time = "2026-07-06T10:46:14.614Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/caee2db41fadcd5a25aa4323213f9afec5a8586d4e419241e3d659362bd7/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4e0e1b0fb0259c1b75d1251ac0bb4d7ab675d36f7a6bf4ba6aa630dae94f9ffa", size = 231292, upload-time = "2026-07-06T10:46:16.452Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/60/f52f08bcdc904c4514ea5c25caa19e9f3214144434a6ff96dc82dc1cbddd/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:10e4393ec33633c2f05ad01869e546ad080b1a18f2650503731f153774608b31", size = 250490, upload-time = "2026-07-06T10:46:18.318Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a0/94dc7ae310838f250669c6ad7168e6d6fca17d49dac1053f06dc232c4a56/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b3ba794c3d885803db6c3116686923f1ec13bc86e621e169a375282b63ea1cc6", size = 309861, upload-time = "2026-07-06T10:46:20.503Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f9/adeead7d0eb28cdfc2832544ea639ffbc6749ccde47a8e228d667459182e/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:57189a69c0891e4818853feaa521c972d22c880a001453addea015f48e3c3398", size = 448739, upload-time = "2026-07-06T10:46:22.79Z" },
+    { url = "https://files.pythonhosted.org/packages/04/a4/22ec0e07db57d901c9298ae98aa3cf2be45bafded6f07c13131e85b89032/xxhash-3.8.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d59e71153fe9ff85648d00e18649b07e9b22c797291abb7e27274fa06df8b838", size = 223657, upload-time = "2026-07-06T10:46:24.831Z" },
+    { url = "https://files.pythonhosted.org/packages/94/32/8a9531f37b59e5a013003db7cb7414baf4ce7e0e1268e0d5947cd3d6a2df/xxhash-3.8.1-cp313-cp313t-win32.whl", hash = "sha256:5b96f0024e9840f449bd91b2d005c921a4b666055a0d1b6492463799f32aae22", size = 32377, upload-time = "2026-07-06T10:46:26.86Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/ab/2ca45fd7f671de5f81fc297ef1c95080b40c86ec6be0cc6034b8f7707ac8/xxhash-3.8.1-cp313-cp313t-win_amd64.whl", hash = "sha256:37d5a56c36dcc0b9a87b814cd992598d33863ff683749de6c86081f278d5e629", size = 33274, upload-time = "2026-07-06T10:46:28.39Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/54/20d7163463ddb6438b73a427d1655a77a502cf9b9b0c3ada3599629d9c0a/xxhash-3.8.1-cp313-cp313t-win_arm64.whl", hash = "sha256:6696c8752aded28ff3b16f33ef28ce28fb5d209b80c206746f943199fcf5fd65", size = 29375, upload-time = "2026-07-06T10:46:29.962Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/4d8040435aeac814fc69ba63621565fbeb19229a138e2568324a26b2a45c/xxhash-3.8.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:39c9d5b61508b0bb68f29e54546de0ed2a74943c6a18585535a7e37356f1dd12", size = 32687, upload-time = "2026-07-06T10:49:42.803Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6a/975f1f2318c760e5bcec109ed379713ae645d8d856c2a3b9ec5d26857087/xxhash-3.8.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:83b9130b80b216d56fdf9e87131946b353c9627930c061955a101ea82b09fed9", size = 29879, upload-time = "2026-07-06T10:49:45.172Z" },
+    { url = "https://files.pythonhosted.org/packages/08/0b/40a2a55ff52cf635bfdc5eae67a772bec85b4f44c6c737f73f6f528d51d1/xxhash-3.8.1-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8304be0982130954b7fd3aad18e2c6f8ee40254bc3d2e635991c16d77c91e2bd", size = 43246, upload-time = "2026-07-06T10:49:47.905Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6d/56ed2b6b200f26fb474f3fd387d95d0601efcd5bb33430c90c68924bdd77/xxhash-3.8.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4b512261801b1e5fde7b6ebf2fef7977339c620cbbca88a0040ad9ad134f4d02", size = 38202, upload-time = "2026-07-06T10:49:50.59Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/a3/56864d895d1161a9f17502088e9c1fb7c06bde2c2efdde620d22bb7a9c43/xxhash-3.8.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49aa8692507835dcc1e8ad8021f20c74c2dc13d83b5112e87877faa2a0035b20", size = 34448, upload-time = "2026-07-06T10:49:53.242Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/57/5c6e0908a47f61dca96d01c8ee6fce01ed1050611eb779083ba8758fed81/xxhash-3.8.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:345b07b78e2bf583d71682aa34ae5b5fab575f7a1cb31e10263ebbc6f89f8c42", size = 32869, upload-time = "2026-07-06T10:49:55.972Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.24.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/df/f1c7a3de0831cd83194f1a85c5bb431b13f81e6b45079314c86d1c4ef3f2/yarl-1.24.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5249a113065c2b7a958bc699759e359cd61cfc81e3069662208f48f191b7ed12", size = 129057, upload-time = "2026-05-19T21:27:47.564Z" },
+    { url = "https://files.pythonhosted.org/packages/48/41/7daafb32dd7562bf45b1ce56562e7e1a9146f6479b6456873eb8a3413c40/yarl-1.24.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7f4425fa244fbf530b006d0c5f79ce920114cfff5b4f5f6056e669f8e160fdc0", size = 91545, upload-time = "2026-05-19T21:27:50.089Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/8f/7b3ec212f1ea0683f55f978e3246bc313c38818664edfc97a9f349a4901e/yarl-1.24.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:15c0b5e49d3c44e2a0b93e6a49476c5edad0a7686b92c395765a7ea775572a75", size = 91380, upload-time = "2026-05-19T21:27:51.953Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/1b/8bafab7db23b0567ae9db749099b329d91e3b82bc6028b2050ba583e116c/yarl-1.24.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:246d32a53a947c8f0189f5d699cbd4c7036de45d9359e13ba238d1239678c727", size = 105957, upload-time = "2026-05-19T21:27:53.98Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/77/21030c2f8d21d21559719beafc772ada2014be933418ed1eaed9cc800e42/yarl-1.24.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:64480fb3e4d4ed9ed71c48a91a477384fc342a50ca30071d2f8a88d51d9c9413", size = 97242, upload-time = "2026-05-19T21:27:55.981Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d8/f9ea63d1b6aa910a866e089d871fff6cbd49caab29b86b35221a62dfa0d5/yarl-1.24.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:349de4701dc3760b6e876628423a8f147ef4f5599d10aba1e10702075d424ed9", size = 114719, upload-time = "2026-05-19T21:27:58.037Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a3/04e0ee98ac58a249ea7ed75223f5f901ba81a834f0b4921b58e5cec11757/yarl-1.24.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d162677af8d5d3d6ebab8394b021f4d041ac107a4b705873148a77a49dc9e1b2", size = 112140, upload-time = "2026-05-19T21:27:59.618Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ad/0b9cc9f38a7324a7eb1d80f834eaa5283d17e9271bbda3186e598dddaeac/yarl-1.24.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5f5c6ec23a9043f2d139cc072f53dd23168d202a334b9b2fda8de4c3e890d90", size = 106721, upload-time = "2026-05-19T21:28:02.586Z" },
+    { url = "https://files.pythonhosted.org/packages/65/e7/a52478ebfc66ec989e085c6ae038b9f1bfa4190baa193b133b669c709e2f/yarl-1.24.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:60de6742447fbbf697f16f070b8a443f1b5fe6ca3826fbef9fe70ecd5328e643", size = 106478, upload-time = "2026-05-19T21:28:04.523Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d8/5508530fea8472542de00013ae280765fc938ee196fc4030c43a498afb36/yarl-1.24.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:acf93187c3710e422368eb768aee98db551ec7c85adc250207a95c16548ab7ac", size = 105423, upload-time = "2026-05-19T21:28:06.515Z" },
+    { url = "https://files.pythonhosted.org/packages/84/f1/ece28505e9628e8b756e11bb4f28864a17cc33b6b44db4d2aaf0622bf630/yarl-1.24.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f4b0352fd41fd34b6651934606268816afd6914d09626f9bcbbf018edb0afb3f", size = 99878, upload-time = "2026-05-19T21:28:08.637Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/52/fb5d34529b46dd84013afcfb30b8d2bc2832ed03d412736f577d604fa393/yarl-1.24.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6b208bb939099b4b297438da4e9b25357f0b1c791888669b963e45b203ea9f36", size = 114025, upload-time = "2026-05-19T21:28:10.64Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f0/ff9d31aaab024f7a251c0ed308a98ae29bf9f7dc344e78f28b1322431ca2/yarl-1.24.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:4b85b8825e631295ff4bc8943f7471d54c533a9360bbe15ebb38e018b555bb8a", size = 105613, upload-time = "2026-05-19T21:28:12.784Z" },
+    { url = "https://files.pythonhosted.org/packages/31/7d/3296fb3f3ecd52bf9ae6c16b0895c1cda7e9170a2083861552b683f70264/yarl-1.24.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e26acf20c26cb4fefc631fdb75aca2a6b8fa8b7b5d7f204fb6a8f1e63c706f53", size = 111665, upload-time = "2026-05-19T21:28:14.393Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/74/77aa6ddaca4fbf42e45e675a465c43956dd40702281049975a2aa04eae59/yarl-1.24.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:819ca24f8eafcfb683c1bd5f44f2f488cea1274eb8944731ffd2e1f10f619342", size = 106914, upload-time = "2026-05-19T21:28:15.893Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/02/7611f22cd1d4ed7373eb7f9ee21fde1046edba2e7c0e514880d760352f48/yarl-1.24.2-cp310-cp310-win_amd64.whl", hash = "sha256:5cb0f995a901c36be096ccbf4c673591c2faabbe96279598ffaec8c030f85bf4", size = 92658, upload-time = "2026-05-19T21:28:17.471Z" },
+    { url = "https://files.pythonhosted.org/packages/91/00/671d0add79938127292839ae44506ce2f7fe8909c72d5a931864f128fd0b/yarl-1.24.2-cp310-cp310-win_arm64.whl", hash = "sha256:f408eace7e22a68b467a0562e0d27d322f91fe3eaaa6f466b962c6cfaea9fa39", size = 87887, upload-time = "2026-05-19T21:28:19.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c5/1ce244152ff2839645e7cae92f90e7bafcb2c52bea7ff586ac714f14f5df/yarl-1.24.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:36348bebb147b83818b9d7e673ea4debc75970afc6ffdc7e3975ad05ce5a58c1", size = 128971, upload-time = "2026-05-19T21:28:20.543Z" },
+    { url = "https://files.pythonhosted.org/packages/87/5a/00f36967203ed89cb3acd2c8ed526cc3fed9418eb70ce128160a911c8499/yarl-1.24.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a97e42c8a2233f2f279ecadd9e4a037bcb5d813b78435e8eedd4db5a9e9708c", size = 91507, upload-time = "2026-05-19T21:28:22.556Z" },
+    { url = "https://files.pythonhosted.org/packages/31/d0/1fb0c1cd27288f39f6974da4318c32768d72c9890984541fdf1e2e32a51d/yarl-1.24.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8d027d56f1035e339d1001ac33eceab5b2ec8e42e449787bb75e289fb9a5cd1d", size = 91343, upload-time = "2026-05-19T21:28:24.092Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ce/d4a646508bed2f8dec6435b40166fe9308dd191262033d3f307b2bbcaecd/yarl-1.24.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a6377060e7927187a42b7eb202090cbe2b34933a4eeaf90e3bd9e33432e5cae", size = 105704, upload-time = "2026-05-19T21:28:25.872Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/07/b3278e82d8bc41485bcf6d856cd0433262593de615b1d3dc43bd3f5bead4/yarl-1.24.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:17076578bce0049a5ce57d14ad1bded391b68a3b213e9b81b0097b090244999a", size = 97281, upload-time = "2026-05-19T21:28:27.352Z" },
+    { url = "https://files.pythonhosted.org/packages/17/5b/4cee6e7c92e487bebe7afc797da0aa54a248ab4e776a68fe369ec29665a5/yarl-1.24.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:50713f1d4d6be6375bb178bb43d140ee1acb8abe589cd723320b7925a275be1e", size = 114020, upload-time = "2026-05-19T21:28:29.458Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/82/111076571545a7d4f9cca3fbd5c6f40615af58642be09f12328f48022468/yarl-1.24.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:34263e2fa8fb5bb63a0d97706cda38edbad62fddb58c7f12d6acbc092812aa50", size = 111450, upload-time = "2026-05-19T21:28:31.262Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ec/08f671f69a444d704aeecebf92af659b67b97a869942411d0a578b08c334/yarl-1.24.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49016d82f032b1bd1e10b01078a7d29ae71bf468eeae0ea22df8bab691e60003", size = 106384, upload-time = "2026-05-19T21:28:32.856Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/86/ce41e7a7a199340b2330d52b60f25c4074b6636dd0e60b1a80d31a9db042/yarl-1.24.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3f6d2c216318f8f32038ca3f72501ba08536f0fd18a36e858836b121b2deed9f", size = 106153, upload-time = "2026-05-19T21:28:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5d/31be8a729531ab3e55ac3e7e5c800be8c89ea98947f418b2f6ea259fb6ee/yarl-1.24.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:08d3a33218e0c64393e7610284e770409a9c31c429b078bcb24096ed0a783b8f", size = 105322, upload-time = "2026-05-19T21:28:36.642Z" },
+    { url = "https://files.pythonhosted.org/packages/47/9b/b57afb22b386ae87ac9940f09878b98d8c333f89113e6fc96fcf4ca9eb64/yarl-1.24.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:5d699376c4ca3cba49bbfae3a05b5b70ded572937171ce1e0b8d87118e2ba294", size = 99057, upload-time = "2026-05-19T21:28:38.386Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4f/06348c27c8389256c313e8a57d796808fc0264c915dd5e7cfd3c0e314dc7/yarl-1.24.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a1cab588b4fa14bea2e55ebea27478adfb05372f47573738e1acc4a36c0b05d2", size = 113502, upload-time = "2026-05-19T21:28:40.091Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/1c/284f307b298e4a17b7943b07d9d7ecc4151537f8d137ba51f3bb6c31ca20/yarl-1.24.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ec87ccc31bd21db7ad009d8572c127c1000f268517618a4cc09adba3c2a7f21c", size = 105253, upload-time = "2026-05-19T21:28:41.987Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/bf/0de123bec8619e45c80cbded9085f61b5b4a9eddb8abe6d25d28ee1ec866/yarl-1.24.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d1dd47a22843b212baa8d74f37796815d43bd046b42a0f41e9da433386c3136b", size = 111345, upload-time = "2026-05-19T21:28:43.93Z" },
+    { url = "https://files.pythonhosted.org/packages/90/af/0248eb065e51129d2a9b2436cd1b5c772c19a6b04e5b6a186955671e3319/yarl-1.24.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7b54b9c67c2b06bd7b9a77253d242124b9c95d2c02def5a1144001ee547dd9d5", size = 106558, upload-time = "2026-05-19T21:28:45.806Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3c/f960d7a65ef97d8ba9b424fb5128796a4bc710fc6df2ddbbd7dfdc3bbd20/yarl-1.24.2-cp311-cp311-win_amd64.whl", hash = "sha256:f8fdbcff8b2c7c9284e60c196f693588598ddcee31e11c18e14949ce44519d45", size = 92808, upload-time = "2026-05-19T21:28:48.465Z" },
+    { url = "https://files.pythonhosted.org/packages/03/1a/49fb03750e4de4d2284cd5b885a383133c34eef45bd59631b2bb8b7e81e8/yarl-1.24.2-cp311-cp311-win_arm64.whl", hash = "sha256:b32c37a7a337e90822c45797bf3d79d60875cfcccd3ecc80e9f453d87026c122", size = 87610, upload-time = "2026-05-19T21:28:50.07Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/da/866bcb01076ba49d2b42b309867bed3826421f1c479655eb7a607b44f20b/yarl-1.24.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b975866c184564c827e0877380f0dae57dcca7e52782128381b72feff6dfceb8", size = 129957, upload-time = "2026-05-19T21:28:51.695Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/1d/fcefb70922ea2268a8971d8e5874d9a8218644200fb8465f1dcad55e6851/yarl-1.24.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3b075301a2836a0e297b1b658cb6d6135df535d62efefdd60366bd589c2c82f2", size = 92164, upload-time = "2026-05-19T21:28:53.242Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b6/170e2b8d4e3bc30e6bfdcca53556537f5bf595e938632dfcb059311f3ff6/yarl-1.24.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8ae44649b00947634ab0dab2a374a638f52923a6e67083f2c156cd5cbd1a881d", size = 91688, upload-time = "2026-05-19T21:28:54.865Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a5/c9f655d5553ea0b99fdac9d6a99ad3f9b3e73b8e5758bb46f58c9831f74c/yarl-1.24.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507cc19f0b45454e2d6dcd62ff7d062b9f77a2812404e62dbdaec05b50faa035", size = 102902, upload-time = "2026-05-19T21:28:56.963Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/bc/6b9664d815d79af4ee553337f9d606c56bbf269186ada9172de45f1b5f60/yarl-1.24.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4c17bad5a530912d2111825d3f05e89bab2dd376aaa8cbc77e449e6db63e576", size = 97931, upload-time = "2026-05-19T21:28:58.56Z" },
+    { url = "https://files.pythonhosted.org/packages/98/ec/32ba48acae30fecd60928f5791188b80a9d6ee3840507ffda29fecd37b71/yarl-1.24.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f5f0cbb112838a4a293985b6ed73948a547dadcc1ba6d2089938e7abdedceef8", size = 111030, upload-time = "2026-05-19T21:29:00.148Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5a/6f4cd081e5f4934d2ae3a8ef4abe3afacc010d26f0035ee91b35cd7d7c37/yarl-1.24.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ec8356b8a6afcf81fc7aeeef13b1ff7a49dec00f313394bbb9e83830d32ccd7", size = 110392, upload-time = "2026-05-19T21:29:02.155Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/da/323a01c349bd5fb01bb6652e314d9bb218cee630a736bdb810ad50e4013f/yarl-1.24.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e7ebcdef69dec6c6451e616f32b622a6d4a2e92b445c992f7c8e5274a6bbc4c", size = 105612, upload-time = "2026-05-19T21:29:04.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/80/264ab684f181e1a876389374519ff05d10248725535ae2ac4e8ac4e563d6/yarl-1.24.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:47a55d6cf6db2f401017a9e96e5288844e5051911fb4e0c8311a3980f5e59a7d", size = 104487, upload-time = "2026-05-19T21:29:06.491Z" },
+    { url = "https://files.pythonhosted.org/packages/41/07/efabe5df87e96d7ad5959760b888344be48cd6884db127b407c6b5503adc/yarl-1.24.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3065657c80a2321225e804048597ad55658a7e76b32d6f5ee4074d04c50401db", size = 102333, upload-time = "2026-05-19T21:29:08.267Z" },
+    { url = "https://files.pythonhosted.org/packages/44/0c/bcf7c42603e1009295f586d8890f2ba032c8b53310e815adf0a202c73d9f/yarl-1.24.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cb84b80d88e19ede158619b80813968713d8d008b0e2497a576e6a0557d50712", size = 99025, upload-time = "2026-05-19T21:29:10.682Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/82/84482ab1a57a0f21a08afe6a7004c61d741f8f2ecc3b05c321577c612164/yarl-1.24.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:990de4f680b1c217e77ff0d6aa0029f9eb79889c11fb3e9a3942c7eba29c1996", size = 110507, upload-time = "2026-05-19T21:29:12.954Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/8d/a546ba1dfe1b0f290e05fef145cd07614c0f15df1a707195e512d1e39d1d/yarl-1.24.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:abb8ec0323b80161e3802da3150ef660b41d0e9be2048b76a363d93eee992c2b", size = 103719, upload-time = "2026-05-19T21:29:14.893Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b6/267f2a09213138473adfce6b8a6e17791d7fee70bd4d9003218e4dec58b0/yarl-1.24.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e7977781f83638a4c73e0f88425563d70173e0dfd90ac006a45c65036293ee3c", size = 110438, upload-time = "2026-05-19T21:29:16.485Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2d/1c8d89c7c5f9cad9fb2902445d94e2ab1d7aa35de029afbb8ae95c42d00f/yarl-1.24.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e30dd55825dc554ec5b66a94953b8eda8745926514c5089dfcacecb9c99b5bd1", size = 105719, upload-time = "2026-05-19T21:29:18.367Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/25/722e3b93bd687009afb2d59a35e13d30ddd8f80571445bb0c4e4ce26ec66/yarl-1.24.2-cp312-cp312-win_amd64.whl", hash = "sha256:7dafe10c12ddd4d120d528c4b5599c953bd7b12845347d507b95451195bb6cad", size = 92901, upload-time = "2026-05-19T21:29:20.014Z" },
+    { url = "https://files.pythonhosted.org/packages/39/47/4486ccfb674c04854a1ef8aa77868b6a6f765feaf69633409d7ca4f02cb8/yarl-1.24.2-cp312-cp312-win_arm64.whl", hash = "sha256:044a09d8401fcf8681977faef6d286b8ade1e2d2e9dceda175d1cfa5ca496f30", size = 87229, upload-time = "2026-05-19T21:29:22.1Z" },
+    { url = "https://files.pythonhosted.org/packages/82/62/fcf0ce677f17e5c471c06311dd25964be38a4c586993632910d2e75278bc/yarl-1.24.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:491ac9141decf49ee8030199e1ee251cdff0e131f25678817ff6aa5f837a3536", size = 128978, upload-time = "2026-05-19T21:29:23.83Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/58/8e63299bb71ed61a834121d9d3fe6c9fcf2a6a5d09754ff4f20f2d20baf5/yarl-1.24.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e89418f65eda18f99030386305bd44d7d504e328a7945db1ead514fbe03a0607", size = 91733, upload-time = "2026-05-19T21:29:25.375Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/24/16748d5dab6daec8b0ed81ccec639a1cded0f18dcc62a4f696b4fe366c37/yarl-1.24.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cdfcce633b4a4bb8281913c57fcafd4b5933fbc19111a5e3930bbd299d6102f1", size = 91113, upload-time = "2026-05-19T21:29:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/b63fff7b71211e866624b21432d5943cbb633eb0c2872d9ee3070648f22c/yarl-1.24.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:863297ddede92ee49024e9a9b11ecb59f310ca85b60d8537f56bed9bbb5b1986", size = 103899, upload-time = "2026-05-19T21:29:28.842Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ac/ba1974b8533909636f7733fe86cf677e3619527c3c2fa913e0ea89c48757/yarl-1.24.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:374423f70754a2c96942ede36a29d37dc6b0cb8f92f8d009ddf3ed78d3da5488", size = 97862, upload-time = "2026-05-19T21:29:31.086Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a5/123ac993b5c2ba6f554a140305620cb8f150fa543711bbc49be3ec0a65a4/yarl-1.24.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33a29b5d00ccbf3219bb3e351d7875739c19481e030779f48cc46a7a71681a9b", size = 111060, upload-time = "2026-05-19T21:29:32.657Z" },
+    { url = "https://files.pythonhosted.org/packages/23/37/c472d3af3509688392134a88a825276770a187f1daa4de3f6dc0a327a751/yarl-1.24.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a9532c57211730c515341af11fef6e9b61d157487272a096d0c04da445642592", size = 110613, upload-time = "2026-05-19T21:29:34.379Z" },
+    { url = "https://files.pythonhosted.org/packages/df/88/09c28dad91e662ccfaa1b78f1c57badde74fc9d0b23e74aef644750ecd73/yarl-1.24.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91e72cf093fd833483a97ee648e0c053c7c629f51ff4a0e7edd84f806b0c5617", size = 107012, upload-time = "2026-05-19T21:29:36.216Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ab/9d4f69d571a94f4d112fa7e2e007200f5a54d319f58c82ac7b7baa61f5c6/yarl-1.24.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b3177bc0a768ef3bacceb4f272632990b7bea352f1b2f1eee9d6d6ff16516f92", size = 105887, upload-time = "2026-05-19T21:29:38.746Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9a/000b2b66c0d772a499fc531d21dab92dfeb73b640a12eed6ba89f49bb2d0/yarl-1.24.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e196952aacaf3b232e265ff02980b64d483dc0972bd49bcb061171ff22ac203a", size = 103620, upload-time = "2026-05-19T21:29:40.368Z" },
+    { url = "https://files.pythonhosted.org/packages/41/7c/7c1050f73450fbdaa3f0c72017059f00ce5e13366692f3dba25275a1083d/yarl-1.24.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:204e7a61ce99919c0de1bf904ab5d7aa188a129ea8f690a8f76cfb6e2844dc44", size = 100599, upload-time = "2026-05-19T21:29:42.66Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/b1/29e5756b3926705f5f6089bd5b9f50a56eaac550da6e260bf713ead44d04/yarl-1.24.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b156914620f0b9d78dc1adb3751141daee561cfec796088abb89ed49d220f1a", size = 110604, upload-time = "2026-05-19T21:29:44.632Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4b/8415bc96e9b150cde942fbac9a8182985e58f40ce5c54c34ed015407d3ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8372a2b976cf70654b2be6619ab6068acabb35f724c0fda7b277fbf53d66a5cf", size = 105161, upload-time = "2026-05-19T21:29:46.755Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/d4/cde059abfa229553b7298a2eadde2752e723d50aeedaef86ce59da2718ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f9a1e9b622ca284143aab5d885848686dcd85453bb1ca9abcdb7503e64dc0056", size = 110619, upload-time = "2026-05-19T21:29:48.972Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2c/d6a6c9a61549f7b6c7e6dc6937d195bcf069582b47b7200dcd0e7b256acf/yarl-1.24.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:810e19b685c8c3c5862f6a38160a1f4e4c0916c9390024ec347b6157a45a0992", size = 107362, upload-time = "2026-05-19T21:29:51Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dd/3ae5fe417e9d1c353a548553326eb9935e76b6b727161563b424cc296df3/yarl-1.24.2-cp313-cp313-win_amd64.whl", hash = "sha256:7d37fb7c38f2b6edab0f845c4f85148d4c44204f52bc127021bd2bc9fdbf1656", size = 92667, upload-time = "2026-05-19T21:29:52.743Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cc/a7beb239f78f27fca1b053c8e8595e4179c02e62249b4687ec218c370c50/yarl-1.24.2-cp313-cp313-win_arm64.whl", hash = "sha256:1e831894be7c2954240e49791fa4b50c05a0dc881de2552cfe3ffd8631c7f461", size = 87069, upload-time = "2026-05-19T21:29:54.442Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" },
+]
+
+[[package]]
+name = "zstandard"
+version = "0.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },
+    { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" },
+    { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" },
+    { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" },
+    { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" },
+    { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" },
+    { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" },
+    { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" },
+    { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" },
+    { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" },
+    { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" },
+]